Convert more phases to use stores

Author: odersky

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

@@ -485,6 +485,12 @@ object Contexts {
       loc
     }
 
+    def addLocation[T](): Store.Location[T] = {
+      val (loc, store1) = store.newLocation[T]()
+      setStore(store1)
+      loc
+    }
+
     def updateStore[T](loc: Store.Location[T], value: T): this.type =
       setStore(store.updated(loc, value))
 

compiler/src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -501,7 +501,7 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   private def lifter(implicit ctx: Context) = ctx.store(Lifter)
 
   override def initContext(ctx: FreshContext) =
-    Lifter = ctx.addLocation[Lifter](null)
+    Lifter = ctx.addLocation[Lifter]()
 
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) =
     ctx.fresh.updateStore(Lifter, new Lifter(thisPhase))

compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala

@@ -14,19 +14,9 @@ import core.NameOps._
 import core.NameKinds.DirectMethodName
 import ast.Trees._
 import ast.tpd
-import util.Property
+import util.Store
 import collection.mutable
 
-object ShortcutImplicits {
-  private type DirectMeths = mutable.HashMap[Symbol, Symbol]
-  private val DirectMeth = new Property.Key[DirectMeths]
-
-  /** A map to cache mapping local methods to their direct counterparts.
-   *  A fresh map is created for each unit.
-   */
-  private def directMeth(implicit ctx: Context) = ctx.property(DirectMeth).get
-}
-
 /** This phase optimizes code using implicit function types, by applying two rewrite rules.
  *  Let IF be the implicit function type
  *
@@ -57,12 +47,20 @@ object ShortcutImplicits {
  */
 class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import tpd._
-  import ShortcutImplicits._
 
   override def phaseName: String = "shortcutImplicits"
 
   override def changesMembers = true  // the phase adds "direct" methods
 
+  /** A map to cache mapping local methods to their direct counterparts.
+   *  A fresh map is created for each unit.
+   */
+  private var DirectMeth: Store.Location[mutable.HashMap[Symbol, Symbol]] = _
+  private def directMeth(implicit ctx: Context) = ctx.store(DirectMeth)
+
+  override def initContext(ctx: FreshContext) =
+    DirectMeth = ctx.addLocation[mutable.HashMap[Symbol, Symbol]]()
+
   /** If this option is true, we don't specialize symbols that are known to be only
    *  targets of monomorphic calls.
    *  The reason for this option is that benchmarks show that on the JVM for monomorphic dispatch
@@ -72,7 +70,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
   final val specializeMonoTargets = true
 
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) =
-    ctx.fresh.setProperty(DirectMeth, new DirectMeths)
+    ctx.fresh.updateStore(DirectMeth, new mutable.HashMap[Symbol, Symbol])
 
   /** Should `sym` get a ..$direct companion?
     *  This is the case if (1) `sym` is a method with an implicit function type as final result type.

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -9,11 +9,11 @@ import StdNames._, Denotations._, Scopes._, Constants.Constant, SymUtils._
 import NameKinds.DefaultGetterName
 import Annotations._
 import util.Positions._
+import util.Store
 import scala.collection.{ mutable, immutable }
 import ast._
 import Trees._
 import SuperPhase._
-import util.Property
 import config.Printers.{checks, noPrinter}
 import util.DotClass
 import scala.util.{Try, Success, Failure}
@@ -758,11 +758,6 @@ object RefChecks {
   }
 
   val NoLevelInfo = new OptLevelInfo()
-
-  val LevelInfo = new Property.Key[OptLevelInfo]
-
-  def currentLevel(implicit ctx: Context): OptLevelInfo =
-    ctx.property(LevelInfo).getOrElse(NoLevelInfo)
 }
 import RefChecks._
 
@@ -807,9 +802,15 @@ class RefChecks extends MiniPhase { thisPhase =>
   // Needs to run after ElimRepeated for override checks involving varargs methods
   override def runsAfter = Set(classOf[ElimRepeated])
 
+  private var LevelInfo: Store.Location[OptLevelInfo] = _
+  private def currentLevel(implicit ctx: Context): OptLevelInfo = ctx.store(LevelInfo)
+
+  override def initContext(ctx: FreshContext) =
+    LevelInfo = ctx.addLocation(NoLevelInfo)
+
   override def prepareForStats(trees: List[Tree])(implicit ctx: Context) =
     if (ctx.owner.isTerm)
-      ctx.fresh.setProperty(LevelInfo, new LevelInfo(currentLevel.levelAndIndex, trees))
+      ctx.fresh.updateStore(LevelInfo, new LevelInfo(currentLevel.levelAndIndex, trees))
     else ctx
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context) = {

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

@@ -10,13 +10,18 @@ object Store {
 class Store(private val elems: Array[AnyRef]) extends AnyVal {
   import Store._
 
-  def newLocation[T](initial: T): (Location[T], Store) = {
+  def newLocation[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 newLocation[T](initial: T): (Location[T], Store) = {
+    val (loc, store) = newLocation[T]()
+    store.elems(loc.idx) = initial.asInstanceOf[AnyRef]
+    (loc, store)
+  }
+
   def updated[T](loc: Location[T], value: T): Store = {
     val elems1 = elems.clone
     elems1(loc.idx) = value.asInstanceOf[AnyRef]