Add Store to Concept

... and provide a way to initialize contexts when phases are linked.

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -115,23 +115,30 @@ class Run(comp: Compiler, ictx: Context) {
     val phases = ctx.squashPhases(ctx.phasePlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.usePhases(phases)
-    var lastPrintedTree: PrintedTree = NoPrintedTree
-    for (phase <- ctx.allPhases)
-      if (phase.isRunnable)
-        Stats.trackTime(s"$phase ms ") {
-          val start = System.currentTimeMillis
-          units = phase.runOn(units)
-          if (ctx.settings.Xprint.value.containsPhase(phase)) {
-            for (unit <- units) {
-              lastPrintedTree =
-                printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+
+    def runPhases(implicit ctx: Context) = {
+      var lastPrintedTree: PrintedTree = NoPrintedTree
+      for (phase <- ctx.allPhases)
+        if (phase.isRunnable)
+          Stats.trackTime(s"$phase ms ") {
+            val start = System.currentTimeMillis
+            units = phase.runOn(units)
+            if (ctx.settings.Xprint.value.containsPhase(phase)) {
+              for (unit <- units) {
+                lastPrintedTree =
+                  printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+              }
             }
+            ctx.informTime(s"$phase ", start)
+            Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
+            for (unit <- units)
+              Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
           }
-          ctx.informTime(s"$phase ", start)
-          Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
-          for (unit <- units)
-            Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
-        }
+    }
+
+    val runCtx = ctx.fresh
+    ctx.phases.foreach(_.initContext(runCtx))
+    runPhases(runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
   }
 

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

@@ -31,6 +31,7 @@ import config.{Settings, ScalaSettings, Platform, JavaPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
 import util.Property.Key
+import util.Store
 import xsbti.AnalysisCallback
 
 object Contexts {
@@ -157,13 +158,6 @@ object Contexts {
     protected def runInfo_=(runInfo: RunInfo) = _runInfo = runInfo
     def runInfo: RunInfo = _runInfo
 
-    /** An optional diagostics buffer than is used by some checking code
-     *  to provide more information in the buffer if it exists.
-     */
-    private[this] var _diagnostics: Option[StringBuilder] = _
-    protected def diagnostics_=(diagnostics: Option[StringBuilder]) = _diagnostics = diagnostics
-    def diagnostics: Option[StringBuilder] = _diagnostics
-
     /** The current bounds in force for type parameters appearing in a GADT */
     private[this] var _gadt: GADTMap = _
     protected def gadt_=(gadt: GADTMap) = _gadt = gadt
@@ -174,6 +168,11 @@ object Contexts {
     protected def freshNames_=(freshNames: FreshNameCreator) = _freshNames = freshNames
     def freshNames: FreshNameCreator = _freshNames
 
+    /** A store that can be used by sub-components */
+    private var _store: Store = _
+    protected def store_=(store: Store) = _store = store
+    def store: Store = _store
+
     /** A map in which more contextual properties can be stored */
     private[this] var _moreProperties: Map[Key[Any], Any] = _
     protected def moreProperties_=(moreProperties: Map[Key[Any], Any]) = _moreProperties = moreProperties
@@ -300,13 +299,6 @@ object Contexts {
     def isNonEmptyScopeContext: Boolean =
       (this.scope ne outer.scope) && !this.scope.isEmpty
 
-    /** Leave message in diagnostics buffer if it exists */
-    def diagnose(str: => String) =
-      for (sb <- diagnostics) {
-        sb.setLength(0)
-        sb.append(str)
-      }
-
     /** The next outer context whose tree is a template or package definition
      *  Note: Currently unused
     def enclTemplate: Context = {
@@ -406,7 +398,6 @@ object Contexts {
           .withSettings(sstate)
           // tree is not preserved in condensed
           .withRunInfo(runInfo)
-          .withDiagnostics(diagnostics)
           .withMoreProperties(moreProperties)
       _condensed
     }
@@ -474,12 +465,12 @@ object Contexts {
     def setImportInfo(importInfo: ImportInfo): this.type = { this.importInfo = importInfo; this }
     def setImplicits(implicits: ContextualImplicits): this.type = { this.implicitsCache = implicits; this }
     def setRunInfo(runInfo: RunInfo): this.type = { this.runInfo = runInfo; this }
-    def setDiagnostics(diagnostics: Option[StringBuilder]): this.type = { this.diagnostics = diagnostics; this }
     def setGadt(gadt: GADTMap): this.type = { this.gadt = gadt; this }
     def setFreshGADTBounds: this.type = setGadt(new GADTMap(gadt.bounds))
     def setTypeComparerFn(tcfn: Context => TypeComparer): this.type = { this.typeComparer = tcfn(this); this }
     def setSearchHistory(searchHistory: SearchHistory): this.type = { this.searchHistory = searchHistory; this }
     def setFreshNames(freshNames: FreshNameCreator): this.type = { this.freshNames = freshNames; this }
+    def setStore(store: Store): this.type = { this.store = store; this }
     def setMoreProperties(moreProperties: Map[Key[Any], Any]): this.type = { this.moreProperties = moreProperties; this }
 
     def setProperty[T](key: Key[T], value: T): this.type =
@@ -488,13 +479,21 @@ object Contexts {
     def dropProperty(key: Key[_]): this.type =
       setMoreProperties(moreProperties - key)
 
+    def addLocation[T](initial: T): Store.Location[T] = {
+      val (loc, store1) = store.newLocation(initial)
+      setStore(store1)
+      loc
+    }
+
+    def updateStore[T](loc: Store.Location[T], value: T): this.type =
+      setStore(store.updated(loc, value))
+
     def setPhase(pid: PhaseId): this.type = setPeriod(Period(runId, pid))
     def setPhase(phase: Phase): this.type = setPeriod(Period(runId, phase.start, phase.end))
 
     def setSetting[T](setting: Setting[T], value: T): this.type =
       setSettings(setting.updateIn(sstate, value))
 
-
     def setDebug = setSetting(base.settings.debug, true)
   }
 
@@ -527,9 +526,9 @@ object Contexts {
     tree = untpd.EmptyTree
     typeAssigner = TypeAssigner
     runInfo = new RunInfo(this)
-    diagnostics = None
     freshNames = new FreshNameCreator.Default
     moreProperties = Map.empty
+    store = Store.empty
     typeComparer = new TypeComparer(this)
     searchHistory = new SearchHistory(0, Map())
     gadt = EmptyGADTMap
@@ -643,7 +642,7 @@ object Contexts {
     private[core] var phasesPlan: List[List[Phase]] = _
 
     /** Phases by id */
-    private[core] var phases: Array[Phase] = _
+    private[dotc] var phases: Array[Phase] = _
 
     /** Phases with consecutive Transforms grouped into a single phase, Empty array if squashing is disabled */
     private[core] var squashedPhases: Array[Phase] = Array.empty[Phase]

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -310,6 +310,8 @@ object Phases {
 
     def exists: Boolean = true
 
+    def initContext(ctx: FreshContext): Unit = ()
+
     private[this] var myPeriod: Period = Periods.InvalidPeriod
     private[this] var myBase: ContextBase = null
     private[this] var myErasedTypes = false

compiler/src/dotty/tools/dotc/util/Store.scala

@@ -0,0 +1,28 @@
+package dotty.tools.dotc.util
+
+object Store {
+
+  class Location[T](private[Store] val idx: Int) extends AnyVal
+
+  val empty: Store = new Store(Array())
+}
+
+class Store(private val elems: Array[AnyRef]) extends AnyVal {
+  import Store._
+
+  def newLocation[T](initial: T): (Location[T], Store) = {
+    val elems1 = new Array[AnyRef](elems.length + 1)
+    System.arraycopy(elems, 0, elems1, 0, elems.length)
+    elems1(elems.length) = initial.asInstanceOf[AnyRef]
+    (new Location(elems.length), new Store(elems1))
+  }
+
+  def updated[T](loc: Location[T], value: T): Store = {
+    val elems1 = elems.clone
+    elems1(loc.idx) = value.asInstanceOf[AnyRef]
+    new Store(elems1)
+  }
+
+  def apply[T](loc: Location[T]): T =
+    elems(loc.idx).asInstanceOf[T]
+}