Use Store in MiniPhases

Convert phases that created new TreeTransforms before to
use the new Store concept instead of Properties.

Author: odersky

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

@@ -15,25 +15,25 @@ import core.NameOps._
 import core.NameKinds.TempResultName
 import ast.Trees._
 import SymUtils._
-import util.Property
+import util.Store
 import collection.{ mutable, immutable }
 import collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
 
-object CapturedVars {
-  val Captured = new Property.Key[collection.Set[Symbol]]
-  def captured(implicit ctx: Context) = ctx.property(Captured).getOrElse(Set.empty)
-}
-
 /** This phase translates variables that are captured in closures to
  *  heap-allocated refs.
  */
 class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =>
-  import CapturedVars._
   import ast.tpd._
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "capturedVars"
 
+  private var Captured: Store.Location[collection.Set[Symbol]] = _
+  private def captured(implicit ctx: Context) = ctx.store(Captured)
+
+  override def initContext(ctx: FreshContext) =
+    Captured = ctx.addLocation(Set.empty)
+
   private class RefInfo(implicit ctx: Context) {
     /** The classes for which a Ref type exists. */
     val refClassKeys: collection.Set[Symbol] =
@@ -79,7 +79,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
     val captured = (new CollectCaptured)
       .runOver(ctx.compilationUnit.tpdTree)(ctx.withPhase(thisPhase))
-    ctx.fresh.setProperty(Captured, captured)
+    ctx.fresh.updateStore(Captured, captured)
   }
 
   /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`,

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

@@ -4,28 +4,27 @@ package transform
 import core._
 import DenotTransformers.SymTransformer
 import Phases.Phase
-import Contexts.Context
+import Contexts.{Context, FreshContext}
 import Flags._
 import SymDenotations.SymDenotation
 import collection.mutable
 import SuperPhase.MiniPhase
-import util.Property
-
-object Flatten {
-  import ast.tpd._
-  val LiftedDefs = new Property.Key[mutable.ListBuffer[Tree]]
-  def liftedDefs(implicit ctx: Context) = ctx.property(LiftedDefs).get
-}
+import util.Store
 
 /** Lift nested classes to toplevel */
 class Flatten extends MiniPhase with SymTransformer {
   import ast.tpd._
-  import Flatten._
 
   override def phaseName = "flatten"
 
   override def changesMembers = true // the phase removes inner classes
 
+  private var LiftedDefs: Store.Location[mutable.ListBuffer[Tree]] = _
+  private def liftedDefs(implicit ctx: Context) = ctx.store(LiftedDefs)
+
+  override def initContext(ctx: FreshContext) =
+    LiftedDefs = ctx.addLocation[mutable.ListBuffer[Tree]](null)
+
   def transformSym(ref: SymDenotation)(implicit ctx: Context) = {
     if (ref.isClass && !ref.is(Package) && !ref.owner.is(Package)) {
       ref.copySymDenotation(
@@ -36,7 +35,7 @@ class Flatten extends MiniPhase with SymTransformer {
   }
 
   override def prepareForPackageDef(tree: PackageDef)(implicit ctx: Context) =
-    ctx.fresh.setProperty(LiftedDefs, new mutable.ListBuffer[Tree])
+    ctx.fresh.updateStore(LiftedDefs, new mutable.ListBuffer[Tree])
 
   private def liftIfNested(tree: Tree)(implicit ctx: Context) =
     if (ctx.owner is Package) tree

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

@@ -16,7 +16,7 @@ import core.Phases._
 import ast.Trees._
 import SymUtils._
 import ExplicitOuter.outer
-import util.Property
+import util.Store
 import util.Positions._
 import collection.{ mutable, immutable }
 import collection.mutable.{ HashMap, HashSet, LinkedHashMap, LinkedHashSet, TreeSet }
@@ -450,9 +450,6 @@ object LambdaLift {
 
     def needsLifting(sym: Symbol) = liftedOwner contains sym
   }
-
-  val Lifter = new Property.Key[Lifter]
-  def lifter(implicit ctx: Context) = ctx.property(Lifter).get
 }
 
 /** This phase performs the necessary rewritings to eliminate classes and methods
@@ -500,8 +497,14 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
     // lambda lift for super calls right. Witness the implementation restrictions to
     // this effect in scalac.
 
+  private var Lifter: Store.Location[Lifter] = _
+  private def lifter(implicit ctx: Context) = ctx.store(Lifter)
+
+  override def initContext(ctx: FreshContext) =
+    Lifter = ctx.addLocation[Lifter](null)
+
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) =
-    ctx.fresh.setProperty(Lifter, new Lifter(thisPhase))
+    ctx.fresh.updateStore(Lifter, new Lifter(thisPhase))
 
   override def transformIdent(tree: Ident)(implicit ctx: Context) = {
     val sym = tree.symbol

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

@@ -10,13 +10,7 @@ import core.Flags._
 import core.Decorators._
 import core.NameKinds.LiftedTreeName
 import NonLocalReturns._
-import util.Property
-
-object LiftTry {
-  val NeedLift = new Property.Key[Boolean]
-  def needLift(implicit ctx: Context) = ctx.property(NeedLift).getOrElse(false)
-  def liftingCtx(p: Boolean)(implicit ctx: Context) = ctx.withProperty(NeedLift, Some(p))
-}
+import util.Store
 
 /** Lifts try's that might be executed on non-empty expression stacks
  *  to their own methods. I.e.
@@ -29,11 +23,19 @@ object LiftTry {
  */
 class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
-  import LiftTry._
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "liftTry"
 
+  private var NeedLift: Store.Location[Boolean] = _
+  private def needLift(implicit ctx: Context): Boolean = ctx.store(NeedLift)
+
+  override def initContext(ctx: FreshContext) =
+    NeedLift = ctx.addLocation(false)
+
+  private def liftingCtx(p: Boolean)(implicit ctx: Context) =
+    if (needLift == p) ctx else ctx.fresh.updateStore(NeedLift, p)
+
   override def prepareForApply(tree: Apply)(implicit ctx: Context) =
     if (tree.fun.symbol.is(Label)) ctx
     else liftingCtx(true)