Fix #415 - initialization of pickler registry when switching runtime strategies

build.sbt

@@ -3,7 +3,7 @@ import Dependencies._ // see project/Dependencies.scala
 import scala.xml.{Node => XmlNode, NodeSeq => XmlNodeSeq, _}
 import scala.xml.transform.{RewriteRule, RuleTransformer}
 
-val buildVersion = "0.11.0-SNAPSHOT"
+val buildVersion = "0.11.0-M4"
 
 def commonSettings = Seq(
   version in ThisBuild := buildVersion,
@@ -58,7 +58,7 @@ def noPublish = Seq(
 
 // Use root project
 lazy val root: Project = (project in file(".")).
-  aggregate(core, benchmark, sandbox, macroTests).
+  aggregate(core, benchmark, sandbox, sandboxTests, macroTests).
   settings(commonSettings ++ noPublish: _*).
   settings(
     name := "Scala Pickling",
@@ -126,6 +126,18 @@ lazy val sandbox: Project = (project in file("sandbox")).
     // scalacOptions ++= Seq("-Xprint:typer")
   )
 
+/* This submodule is meant to store tests that need to be executed
+ * independently from the main test suite placed in `core`. */
+lazy val sandboxTests: Project = (project in file("sandbox-test")).
+  dependsOn(core).
+  settings(commonSettings ++ noPublish: _*).
+  settings(
+    libraryDependencies ++= Seq(
+      "org.scala-lang" % "scala-compiler" % scalaVersion.value,
+      scalaTest
+    )
+  )
+
 lazy val benchmark: Project = (project in file("benchmark")).
   dependsOn(core).
   settings(commonSettings ++ noPublish ++ benchmarkSettings: _*).

core/src/main/scala/scala/pickling/internal/DefaultPicklerRegistry.scala

@@ -10,14 +10,16 @@ import scala.pickling.spi.{PicklerRegistry, RuntimePicklerGenerator}
 
 /** Default pickle registry just uses TrieMaps and delgates behavior to a runtime pickler generator. */
 final class DefaultPicklerRegistry(generator: RuntimePicklerGenerator) extends PicklerRegistry with RuntimePicklerRegistryHelper {
-  type PicklerGenerator = FastTypeTag[_] => Pickler[_]
-  type UnpicklerGenerator = FastTypeTag[_] => Unpickler[_]
+
+  type PicklerGen = FastTypeTag[_] => Pickler[_]
+  type UnpicklerGen = FastTypeTag[_] => Unpickler[_]
+
   // TODO - We need to move the special encoding for runtime classes into here, rather than in magical traits.
 
   private val picklerMap: mutable.Map[String, Pickler[_]] = new TrieMap[String, Pickler[_]]
-  private val picklerGenMap: mutable.Map[String, PicklerGenerator] = new TrieMap[String, PicklerGenerator]
+  private val picklerGenMap: mutable.Map[String, PicklerGen] = new TrieMap[String, PicklerGen]
   private val unpicklerMap: mutable.Map[String, Unpickler[_]] = new TrieMap[String, Unpickler[_]]
-  private val unpicklerGenMap: mutable.Map[String, UnpicklerGenerator] = new TrieMap[String, UnpicklerGenerator]
+  private val unpicklerGenMap: mutable.Map[String, UnpicklerGen] = new TrieMap[String, UnpicklerGen]
 
   // During constrcution, we can now register the default picklers against our cache of picklers.
   autoRegisterDefaults()
@@ -130,6 +132,7 @@ final class DefaultPicklerRegistry(generator: RuntimePicklerGenerator) extends P
     picklerGenMap.put(typeConstructorKey, generator)
 
   /** Registers a pickler and unpickler for a type with this registry for future use.
+ *
     * @param key  The type key for the pickler. Note: In reflective scenarios this may not include type parameters.
     *             In those situations, the pickler should be able to handle arbitrary (existential) type parameters.
     * @param p  The unpickler to register.
@@ -149,4 +152,25 @@ final class DefaultPicklerRegistry(generator: RuntimePicklerGenerator) extends P
     registerPicklerGenerator(typeConstructorKey, generator)
     registerUnpicklerGenerator(typeConstructorKey, generator)
   }
+
+  /** Transfer the "state" between different [[scala.pickling.spi.PicklingRuntime]]s.
+    *
+    * Watch out, this operation is not thread-safe.
+    *
+    * Make a new [[scala.pickling.spi.PicklingRuntime]] aware of
+    * the already registered [[Pickler]]s and [[Unpickler]]s present
+    * in the one that will be replaced.
+    */
+  private[pickling] def dumpStateTo(r: PicklerRegistry): Unit = {
+
+    type AnyPicklerGen = FastTypeTag[_] => Pickler[Any]
+    type AnyUnpicklerGen = FastTypeTag[_] => Unpickler[Any]
+
+    for(p <- picklerMap) r.registerPickler(p._1, p._2.asInstanceOf[Pickler[Any]])
+    for(p <- picklerGenMap) r.registerPicklerGenerator(p._1, p._2.asInstanceOf[AnyPicklerGen])
+    for(u <- unpicklerMap) r.registerUnpickler(u._1, u._2.asInstanceOf[Unpickler[Any]])
+    for(u <- unpicklerGenMap) r.registerUnpicklerGenerator(u._1, u._2.asInstanceOf[AnyUnpicklerGen])
+
+  }
+
 }

core/src/main/scala/scala/pickling/internal/NoReflectionRuntime.scala

@@ -4,7 +4,6 @@ package internal
 import java.util.concurrent.locks.ReentrantLock
 
 import scala.pickling.refs.Share
-import scala.pickling.{Pickler, Unpickler, FastTypeTag}
 import scala.pickling.spi.{PicklerRegistry, RefRegistry, PicklingRuntime}
 import scala.reflect.runtime
 
@@ -32,6 +31,7 @@ final class NoReflectionRuntime() extends PicklingRuntime {
     override def registerUnpickler[T](key: String, p: Unpickler[T]): Unit = ()
     override def registerPicklerUnpickler[T](key: String, p: Pickler[T] with Unpickler[T]): Unit = ()
     override private[pickling] def clearRegisteredPicklerUnpicklerFor[T: FastTypeTag]: Unit = ()
+    override private[pickling] def dumpStateTo(r: scala.pickling.spi.PicklerRegistry): Unit = ()
   }
   override val refRegistry: RefRegistry = new DefaultRefRegistry()
   override val GRL: ReentrantLock = new ReentrantLock()

core/src/main/scala/scala/pickling/internal/package.scala

@@ -5,13 +5,12 @@ import java.util.concurrent.atomic.AtomicReference
 import scala.language.experimental.macros
 import scala.language.reflectiveCalls
 
-import java.util.IdentityHashMap
-
 import HasCompat._
 
 package object internal {
 
   import scala.reflect.runtime.{universe => ru}
+  import spi._
   import ru._
   import compat._
 
@@ -24,10 +23,19 @@ package object internal {
 
     }
   }
-  private[this] var currentRuntimeVar = new AtomicReference[spi.PicklingRuntime](initDefaultRuntime)
-  def currentRuntime: spi.PicklingRuntime = currentRuntimeVar.get
-  // Here we inject a new runtime for usage.
-  def replaceRuntime(r: spi.PicklingRuntime): Unit = {
+  private[this] var currentRuntimeVar = new AtomicReference[PicklingRuntime](initDefaultRuntime)
+  def currentRuntime: PicklingRuntime = currentRuntimeVar.get
+
+  /** Replace the old [[PicklingRuntime]] keeping its state. This operation
+    * is not thread-safe and it's expected to be executed in a single thread.
+    *
+    * Note that we don't do anything with the [[RefRegistry]] because in
+    * future versions we are going to change how cyclic references work.
+    */
+  def replaceRuntime(r: PicklingRuntime): Unit = {
+    if(r.picklers.isLookupEnabled) {
+      currentRuntime.picklers.dumpStateTo(r.picklers)
+    }
     currentRuntimeVar.lazySet(r)
   }
 

core/src/main/scala/scala/pickling/spi/PicklerRegistry.scala

@@ -106,4 +106,13 @@ trait PicklerRegistry {
     */
   private[pickling] def clearRegisteredPicklerUnpicklerFor[T: FastTypeTag]: Unit
 
+  /** Transfer the "state" between different [[PicklingRuntime]]s.
+    *
+    * Watch out, this operation is not thread-safe.
+    *
+    * Make a new [[PicklingRuntime]] aware of the already registered [[Pickler]]s
+    * and [[Unpickler]]s present in the one that will be replaced.
+    */
+  private[pickling] def dumpStateTo(r: PicklerRegistry): Unit
+
 }

sandbox-test/src/test/scala/scala/pickling/registry/SwitchRuntimeRegistryInit.scala

@@ -0,0 +1,44 @@
+package scala.pickling.registry
+
+import org.scalatest.FunSuite
+
+import scala.pickling._
+import scala.pickling.internal.HybridRuntime
+import scala.pickling.json.JsonFormats
+import scala.pickling.pickler.AllPicklers
+
+object Protocol extends {
+  val oldRuntime = internal.currentRuntime
+  val currentRuntime = new HybridRuntime
+  val onlyLookup = internal.replaceRuntime(currentRuntime)
+} with Ops with AllPicklers with JsonFormats
+
+class SwitchRuntimeRegistryInit extends FunSuite {
+
+  import Protocol._
+
+  test("registry should be initialized when switching runtime strategies") {
+
+    case class Foo(i: Int)
+    val pf = implicitly[AbstractPicklerUnpickler[Foo]]
+
+    // If the test passes, this should not initialize
+    // the registry again. If it fails it does.
+    implicitly[Pickler[List[String]]]
+
+    try {
+    val lookup = currentRuntime.picklers.lookupPickler(pf.tag.key)
+    assert(lookup !== None)
+
+    val pf2 = implicitly[AbstractPicklerUnpickler[Foo]]
+    val lookup2 = currentRuntime.picklers.lookupPickler(pf.tag.key)
+    assert(lookup === lookup2)
+    } finally {
+      internal.replaceRuntime(oldRuntime)
+      // Just in case it doesn't get init
+      implicitly[Pickler[List[String]]]
+    }
+
+  }
+
+}