Store the JSDefinitions in a custom platform SJSPlatform.

This required the ability to instantiate a different `Platform`
depending on settings, which, in turn, required to defer the
initialization of `ContextBase.platform`.

Author: sjrd

src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -8,22 +8,12 @@ import Symbols._
 import StdNames._
 import Decorators._
 
+import dotty.tools.dotc.config.SJSPlatform
+
 object JSDefinitions {
-  @dotty.tools.sharable
-  private val cache = new java.util.WeakHashMap[ContextBase, JSDefinitions]
-
-  // TODO Figure out where best to define this
-  def jsdefn(implicit ctx: Context): JSDefinitions = cache.synchronized {
-    val baseCtx = ctx.base
-    val cached = cache.get(baseCtx)
-    if (cached != null) {
-      cached
-    } else {
-      val newJSDefinitions = new JSDefinitions()
-      cache.put(baseCtx, newJSDefinitions)
-      newJSDefinitions
-    }
-  }
+  /** The Scala.js-specific definitions for the current context. */
+  def jsdefn(implicit ctx: Context): JSDefinitions =
+    ctx.platform.asInstanceOf[SJSPlatform].jsDefinitions
 }
 
 final class JSDefinitions()(implicit ctx: Context) {

src/dotty/tools/dotc/Compiler.scala

@@ -102,7 +102,7 @@ class Compiler {
    *    imports      For each element of RootImports, an import context
    */
   def rootContext(implicit ctx: Context): Context = {
-    ctx.definitions.init(ctx)
+    ctx.initialize()(ctx)
     val actualPhases = if (ctx.settings.scalajs.value) {
       phases
     } else {
@@ -123,7 +123,7 @@ class Compiler {
       .setTyper(new Typer)
       .setMode(Mode.ImplicitsEnabled)
       .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
-    ctx.definitions.init(start) // set context of definitions to start
+    ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, refFn: () => TermRef) =
       ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
     (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)

src/dotty/tools/dotc/config/SJSPlatform.scala

@@ -0,0 +1,13 @@
+package dotty.tools.dotc.config
+
+import dotty.tools.dotc.core._
+import Contexts._
+
+import dotty.tools.backend.sjs.JSDefinitions
+
+class SJSPlatform()(implicit ctx: Context) extends JavaPlatform {
+
+  /** Scala.js-specific definitions. */
+  val jsDefinitions: JSDefinitions = new JSDefinitions()
+
+}

src/dotty/tools/dotc/core/Contexts.scala

@@ -26,7 +26,7 @@ import reporting._
 import collection.mutable
 import collection.immutable.BitSet
 import printing._
-import config.{Settings, ScalaSettings, Platform, JavaPlatform}
+import config.{Settings, ScalaSettings, Platform, JavaPlatform, SJSPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
 
@@ -514,8 +514,21 @@ object Contexts {
     /** The symbol loaders */
     val loaders = new SymbolLoaders
 
+    /** The platform, initialized by `initPlatform()`. */
+    private var _platform: Platform = _
+
     /** The platform */
-    val platform: Platform = new JavaPlatform
+    def platform: Platform = {
+      if (_platform == null) {
+        throw new IllegalStateException(
+            "initialize() must be called before accessing platform")
+      }
+      _platform
+    }
+
+    protected def newPlatform(implicit ctx: Context): Platform =
+      if (settings.scalajs.value) new SJSPlatform
+      else new JavaPlatform
 
     /** The loader that loads the members of _root_ */
     def rootLoader(root: TermSymbol)(implicit ctx: Context): SymbolLoader = platform.rootLoader(root)
@@ -526,6 +539,14 @@ object Contexts {
     /** The standard definitions */
     val definitions = new Definitions
 
+    /** Initializes the `ContextBase` with a starting context.
+     *  This initializes the `platform` and the `definitions`.
+     */
+    def initialize()(implicit ctx: Context): Unit = {
+      _platform = newPlatform
+      definitions.init
+    }
+
     def squashed(p: Phase): Phase = {
       allPhases.find(_.period.containsPhaseId(p.id)).getOrElse(NoPhase)
     }

src/dotty/tools/dotc/transform/Pickler.scala

@@ -80,7 +80,7 @@ class Pickler extends Phase {
 
   private def testUnpickler(units: List[CompilationUnit])(implicit ctx: Context): Unit = {
     pickling.println(i"testing unpickler at run ${ctx.runId}")
-    ctx.definitions.init
+    ctx.initialize()
     val unpicklers =
       for (unit <- units; (cls, pickler) <- unit.picklers) yield {
         val unpickler = new DottyUnpickler(pickler.assembleParts())

test/test/DottyTest.scala

@@ -22,7 +22,7 @@ class DottyTest /*extends ContextEscapeDetection*/ {
     val base = new ContextBase
     import base.settings._
     val ctx = base.initialCtx.fresh
-    base.definitions.init(ctx)
+    base.initialize()(ctx)
     ctx
   }
 /*