Collapse ctx and localCtx together

Author: DarkDimius

compiler/src/dotty/tools/dotc/transform/localopt/BubbleUpNothing.scala

@@ -4,6 +4,7 @@ package transform.localopt
 import core.Contexts.Context
 import core.Symbols._
 import ast.Trees._
+import dotty.tools.dotc.ast.tpd
 
 /**
  * If a block has a statement that evaluates to Nothing:
@@ -19,12 +20,16 @@ import ast.Trees._
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
-class BubbleUpNothing(implicit val ctx: Context) extends Optimisation {
+class BubbleUpNothing extends Optimisation {
   import ast.tpd._
 
-  val visitor = NoVisitor
+  def visitor(implicit ctx: Context) = NoVisitor
 
-  def transformer(localCtx: Context): Tree => Tree = {
+
+  /** Does the actual Tree => Tree transformation, possibly using a different
+   * context from the one used in Optimisation.
+   */
+  def transformer(implicit ctx: Context): (tpd.Tree) => tpd.Tree = {
     case t @ Apply(Select(Notathing(qual), _), args) =>
       Typed(qual, TypeTree(t.tpe))
     // This case leads to complications with multiple argument lists,
@@ -50,16 +55,16 @@ class BubbleUpNothing(implicit val ctx: Context) extends Optimisation {
   }
 
   object Notathing {
-    def unapply(t: Tree): Option[Tree] = Option(lookup(t))
-    def lookup(t: Tree): Tree = t match {
+    def unapply(t: Tree)(implicit ctx: Context): Option[Tree] = Option(lookup(t))
+    def lookup(t: Tree)(implicit ctx: Context): Tree = t match {
       case x if x.tpe.derivesFrom(defn.NothingClass) => t
       case Typed(x, _) => lookup(x)
       case Block(_, x) => lookup(x)
       case _ => null
     }
   }
 
-  def notathing(t: Tree): Boolean = t match {
+  def notathing(t: Tree)(implicit ctx: Context): Boolean = t match {
     case Notathing(_) => true
     case _ => false
   }

compiler/src/dotty/tools/dotc/transform/localopt/ConstantFold.scala

@@ -20,12 +20,12 @@ import Simplify.desugarIdent
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
- class ConstantFold(implicit val ctx: Context) extends Optimisation {
+ class ConstantFold extends Optimisation {
   import ast.tpd._
 
-  val visitor = NoVisitor
+  def visitor(implicit ctx: Context) = NoVisitor
 
-  def transformer(localCtx: Context): Tree => Tree = { x => preEval(x) match {
+  def transformer(implicit ctx: Context): Tree => Tree = { x => preEval(x) match {
     // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator
     // TODO: include methods such as Int.int2double(see ./tests/pos/harmonize.scala)
     case If(cond1, thenp, elsep) if isSimilar(thenp, elsep) =>
@@ -160,7 +160,7 @@ import Simplify.desugarIdent
     }
   }
 
-  def preEval(t: Tree) = {
+  def preEval(t: Tree)(implicit ctx: Context) = {
     if (t.isInstanceOf[Literal] || t.isInstanceOf[CaseDef] || !isPureExpr(t)) t
     else {
       val s = ConstFold.apply(t)
@@ -171,7 +171,7 @@ import Simplify.desugarIdent
     }
   }
 
-  def isSimilar(t1: Tree, t2: Tree): Boolean = t1 match {
+  def isSimilar(t1: Tree, t2: Tree)(implicit ctx: Context): Boolean = t1 match {
     case t1: Apply =>
       t2 match {
         case t2: Apply =>
@@ -209,7 +209,7 @@ import Simplify.desugarIdent
     case _ => false
   }
 
-  def isBool(tpe: Type): Boolean = tpe.derivesFrom(defn.BooleanClass)
-  def isConst(tpe: Type): Boolean      = tpe.isInstanceOf[ConstantType]
-  def asConst(tpe: Type): ConstantType = tpe.asInstanceOf[ConstantType]
+  def isBool(tpe: Type)(implicit ctx: Context): Boolean = tpe.derivesFrom(defn.BooleanClass)
+  def isConst(tpe: Type)(implicit ctx: Context): Boolean      = tpe.isInstanceOf[ConstantType]
+  def asConst(tpe: Type)(implicit ctx: Context): ConstantType = tpe.asInstanceOf[ConstantType]
 }

compiler/src/dotty/tools/dotc/transform/localopt/Devalify.scala

@@ -20,7 +20,7 @@ import transform.SymUtils._
  * This phase has to be careful not to eliminate vals that are parts of other types
  * @author DarkDimius, OlivierBlanvillain
  * */
-class Devalify(implicit val ctx: Context) extends Optimisation {
+class Devalify extends Optimisation {
   import ast.tpd._
 
   val timesUsed = mutable.HashMap[Symbol, Int]()
@@ -31,7 +31,7 @@ class Devalify(implicit val ctx: Context) extends Optimisation {
   // Either a duplicate or a read through series of immutable fields
   val copies = mutable.HashMap[Symbol, Tree]()
 
-  def visitType(tp: Type): Unit = {
+  def visitType(tp: Type)(implicit ctx: Context): Unit = {
     tp.foreachPart(x => x match {
       case TermRef(NoPrefix, _) =>
         val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
@@ -40,7 +40,7 @@ class Devalify(implicit val ctx: Context) extends Optimisation {
     })
   }
 
-  def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
+  def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int])(implicit ctx: Context): Unit = tree match {
     case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
                            valdef.symbol.exists && !valdef.symbol.owner.isClass =>
       defined += valdef.symbol
@@ -73,7 +73,7 @@ class Devalify(implicit val ctx: Context) extends Optimisation {
     case _ =>
   }
 
-  def visitor: Tree => Unit = { tree =>
+  def visitor(implicit ctx: Context): Tree => Unit = { tree =>
     def crossingClassBoundaries(t: Tree): Boolean = t match {
       case _: New      => true
       case _: Template => true
@@ -98,7 +98,7 @@ class Devalify(implicit val ctx: Context) extends Optimisation {
     doVisit(tree, timesUsed)
   }
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  override def transformer(implicit ctx: Context): Tree => Tree = {
     val valsToDrop = defined -- timesUsed.keySet -- timesUsedAsType.keySet
     val copiesToReplaceAsDuplicates = copies.filter { x =>
       val rhs = dropCasts(x._2)

compiler/src/dotty/tools/dotc/transform/localopt/DropGoodCasts.scala

@@ -19,12 +19,12 @@ import transform.SymUtils._
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
- class DropGoodCasts(implicit val ctx: Context) extends Optimisation {
+ class DropGoodCasts extends Optimisation {
   import ast.tpd._
 
-  val visitor = NoVisitor
+  def visitor(implicit ctx: Context) = NoVisitor
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     case t @ If(cond, thenp, elsep) =>
       val newTypeTested = collectTypeTests(cond)
       val nullTested = collectNullTests(cond).toSet

compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala

@@ -16,12 +16,12 @@ import Simplify.desugarIdent
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
-class DropNoEffects(val simplifyPhase: Simplify)(implicit val ctx: Context) extends Optimisation {
+class DropNoEffects(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
-  val visitor = NoVisitor
+  def visitor(implicit ctx: Context) = NoVisitor
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     // Remove empty blocks
     case Block(Nil, expr) => expr
 
@@ -59,7 +59,7 @@ class DropNoEffects(val simplifyPhase: Simplify)(implicit val ctx: Context) exte
     case t => t
   }
 
-  val keepOnlySideEffects: Tree => Tree = {
+  def keepOnlySideEffects(t: Tree)(implicit ctx: Context):  Tree = t match {
     case l: Literal =>
       EmptyTree
 
@@ -194,7 +194,7 @@ class DropNoEffects(val simplifyPhase: Simplify)(implicit val ctx: Context) exte
   )
 
   /** Does this tree has side effects? This is an approximation awaiting real purity analysis... */
-  def effectsDontEscape(t: Tree): Boolean = t match {
+  def effectsDontEscape(t: Tree)(implicit ctx: Context): Boolean = t match {
     case Apply(fun, _) if fun.symbol.isConstructor && constructorWhiteList.contains(fun.symbol.owner.fullName.toString) =>
       true
     case Apply(fun, _) if methodsWhiteList.contains(fun.symbol.fullName.toString) =>

compiler/src/dotty/tools/dotc/transform/localopt/InlineCaseIntrinsics.scala

@@ -20,12 +20,12 @@ import dotty.tools.dotc.ast.tpd
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
-class InlineCaseIntrinsics(implicit val ctx: Context) extends Optimisation {
+class InlineCaseIntrinsics extends Optimisation {
   import ast.tpd._
 
-  val visitor = NoVisitor
+  def visitor(implicit ctx: Context): (tpd.Tree) => Unit = NoVisitor
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit localCtx: Context): Tree => Tree = {
     // For synthetic applies on case classes (both dotty/scalac)
     // - CC.apply(args) → new CC(args)
     case a: Apply
@@ -125,7 +125,7 @@ class InlineCaseIntrinsics(implicit val ctx: Context) extends Optimisation {
 
   // Apply fun may be a side-effectful function. E.g. a block, see tests/run/t4859.scala
   // we need to maintain expressions that were in this block
-  def evalreceiver(a: Apply, res: Tree) = {
+  def evalreceiver(a: Apply, res: Tree)(implicit ctx: Context) = {
     def receiver(t: Tree): Tree = t match {
       case TypeApply(fun, targs) if fun.symbol eq t.symbol => receiver(fun)
       case Apply(fn, args) if fn.symbol == t.symbol => receiver(fn)

compiler/src/dotty/tools/dotc/transform/localopt/InlineLabelsCalledOnce.scala

@@ -8,14 +8,18 @@ import transform.SymUtils._
 import scala.collection.mutable
 import config.Printers.simplify
 
-/** Inlines LabelDef which are used exactly once. */
-class InlineLabelsCalledOnce(implicit val ctx: Context) extends Optimisation {
+/** Inlines LabelDef which are used exactly once.
+ *
+ * @author DarkDimius, OlivierBlanvillain
+ *         
+ * */
+class InlineLabelsCalledOnce extends Optimisation {
   import ast.tpd._
 
   val timesUsed = mutable.HashMap[Symbol, Int]()
   val defined   = mutable.HashMap[Symbol, DefDef]()
 
-  val visitor: Tree => Unit = {
+  def visitor(implicit ctx: Context): Tree => Unit = {
     case d: DefDef if d.symbol.is(Label)  =>
       var isRecursive = false
       d.rhs.foreachSubTree { x =>
@@ -32,12 +36,12 @@ class InlineLabelsCalledOnce(implicit val ctx: Context) extends Optimisation {
     case _ =>
   }
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     case a: Apply =>
       defined.get(a.symbol) match {
         case Some(defDef) if usedOnce(a) && a.symbol.info.paramInfoss == List(Nil) =>
           simplify.println(s"Inlining labeldef ${defDef.name}")
-          defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
+          defDef.rhs.changeOwner(defDef.symbol, ctx.owner)
 
         case Some(defDef) if defDef.rhs.isInstanceOf[Literal] =>
           defDef.rhs
@@ -57,11 +61,11 @@ class InlineLabelsCalledOnce(implicit val ctx: Context) extends Optimisation {
     case t => t
   }
 
-  def usedN(t: Tree, n: Int): Boolean =
+  def usedN(t: Tree, n: Int)(implicit ctx: Context): Boolean =
     t.symbol.is(Label)                    &&
     timesUsed.getOrElse(t.symbol, 0) == n &&
     defined.contains(t.symbol)
 
-  def usedOnce(t: Tree): Boolean  = usedN(t, 1)
-  def neverUsed(t: Tree): Boolean = usedN(t, 0)
+  def usedOnce(t: Tree)(implicit ctx: Context): Boolean  = usedN(t, 1)
+  def neverUsed(t: Tree)(implicit ctx: Context): Boolean = usedN(t, 0)
 }

compiler/src/dotty/tools/dotc/transform/localopt/InlineLocalObjects.scala

@@ -17,7 +17,7 @@ import config.Printers.simplify
  *  parameter value classes. The main motivation is to get ride of all the
  *  intermediate tuples coming from pattern matching expressions.
  */
-class InlineLocalObjects(implicit val ctx: Context) extends Optimisation {
+class InlineLocalObjects extends Optimisation {
   import ast.tpd._
 
   // In the end only calls constructor. Reason for unconditional inlining
@@ -27,7 +27,7 @@ class InlineLocalObjects(implicit val ctx: Context) extends Optimisation {
   val forwarderWritesTo = mutable.HashMap[Symbol, Symbol]()
   val gettersCalled = mutable.HashSet[Symbol]()
 
-  def followTailPerfect(t: Tree, symbol: Symbol): Unit = {
+  def followTailPerfect(t: Tree, symbol: Symbol)(implicit ctx: Context): Unit = {
     t match {
       case Block(_, expr) => followTailPerfect(expr, symbol)
       case If(_, thenp, elsep) => followTailPerfect(thenp, symbol); followTailPerfect(elsep, symbol);
@@ -43,7 +43,7 @@ class InlineLocalObjects(implicit val ctx: Context) extends Optimisation {
     }
   }
 
-  val visitor: Tree => Unit = {
+  def visitor(implicit ctx: Context): Tree => Unit = {
     case vdef: ValDef if (vdef.symbol.info.classSymbol is CaseClass) &&
                          !vdef.symbol.is(Lazy)                       &&
                          !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Mutable)) =>
@@ -63,7 +63,7 @@ class InlineLocalObjects(implicit val ctx: Context) extends Optimisation {
     case _ =>
   }
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     var hasChanged = true
     while(hasChanged) {
       hasChanged = false

compiler/src/dotty/tools/dotc/transform/localopt/InlineOptions.scala

@@ -9,14 +9,18 @@ import core.Flags._
 import ast.Trees._
 import scala.collection.mutable
 
-/** Inlines Option methods whose result is known statically. */
-class InlineOptions(implicit val ctx: Context) extends Optimisation {
+/** Inlines Option methods whose result is known statically.
+ *
+ *
+ * @author DarkDimius, OlivierBlanvillain
+ * */
+class InlineOptions extends Optimisation {
   import ast.tpd._
 
-  val somes = mutable.HashMap[Symbol, Tree]()
-  val nones = mutable.HashSet[Symbol]()
+  private val somes = mutable.HashMap[Symbol, Tree]()
+  private val nones = mutable.HashSet[Symbol]()
 
-  val visitor: Tree => Unit = {
+  def visitor(implicit ctx: Context): Tree => Unit = {
     case valdef: ValDef if !valdef.symbol.is(Mutable) &&
       valdef.rhs.isInstanceOf[Apply] && valdef.rhs.tpe.derivesFrom(defn.SomeClass) &&
       valdef.rhs.symbol.isPrimaryConstructor =>
@@ -29,7 +33,7 @@ class InlineOptions(implicit val ctx: Context) extends Optimisation {
     case _ =>
   }
 
-  def transformer(localCtx: Context): Tree => Tree = { tree =>
+  def transformer(implicit ctx: Context): Tree => Tree = { tree =>
     def rewriteSelect(x: Tree) = x match {
       case Select(rec, nm) if nm == nme.get       && somes.contains(rec.symbol) => somes(rec.symbol)
       case Select(rec, nm) if nm == nme.isDefined && somes.contains(rec.symbol) => Literal(Constant(true))

compiler/src/dotty/tools/dotc/transform/localopt/Jumpjump.scala

@@ -11,13 +11,16 @@ import scala.collection.mutable
 import config.Printers.simplify
 import core.Flags._
 
-/** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target. */
-class Jumpjump(implicit val ctx: Context) extends Optimisation {
+/** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target.
+ *
+ * @author DarkDimius, OlivierBlanvillain
+ * */
+class Jumpjump extends Optimisation {
   import ast.tpd._
 
   val defined = mutable.HashMap[Symbol, Symbol]()
 
-  val visitor: Tree => Unit = {
+  def visitor(implicit ctx: Context): Tree => Unit = {
     case defdef: DefDef if defdef.symbol.is(Label)  =>
       defdef.rhs match {
         case Apply(t, args)
@@ -34,7 +37,7 @@ class Jumpjump(implicit val ctx: Context) extends Optimisation {
     case _ =>
   }
 
-  def transformer(localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     case a: Apply if  defined.contains(a.fun.symbol) =>
       defined.get(a.symbol) match {
         case None => a

compiler/src/dotty/tools/dotc/transform/localopt/Optimisation.scala

@@ -7,12 +7,12 @@ import ast.tpd.Tree
 trait Optimisation {
 
   /** Run first to gather information on Trees (using mutation) */
-  def visitor: Tree => Unit
+  def visitor(implicit ctx: Context): Tree => Unit
 
   /** Does the actual Tree => Tree transformation, possibly using a different
    *  context from the one used in Optimisation.
    */
-  def transformer(localCtx: Context): Tree => Tree
+  def transformer(implicit ctx: Context): Tree => Tree
 
   def name: String = this.getClass.getSimpleName