Add clear() method to share instances of optimisations

Author: OlivierBlanvillain

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

@@ -23,6 +23,7 @@ class BubbleUpNothing extends Optimisation {
   import ast.tpd._
 
   def visitor(implicit ctx: Context) = NoVisitor
+  def clear(): Unit = ()
 
   def transformer(implicit ctx: Context): Tree => Tree = {
     case t @ Apply(Select(Notathing(qual), _), args) =>

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

@@ -30,6 +30,7 @@ import Simplify.desugarIdent
   import ast.tpd._
 
   def visitor(implicit ctx: Context) = NoVisitor
+  def clear(): Unit = ()
 
   def transformer(implicit ctx: Context): Tree => Tree = { x => preEval(x) match {
     // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator

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

@@ -31,6 +31,14 @@ class Devalify extends Optimisation {
   // Either a duplicate or a read through series of immutable fields
   val copies = mutable.HashMap[Symbol, Tree]()
 
+  def clear(): Unit = {
+    timesUsed.clear()
+    timesUsedAsType.clear()
+    defined.clear()
+    usedInInnerClass.clear()
+    copies.clear()
+  }
+
   def visitType(tp: Type)(implicit ctx: Context): Unit = {
     tp.foreachPart(x => x match {
       case TermRef(NoPrefix, _) =>

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

@@ -24,6 +24,7 @@ import Simplify.isEffectivelyMutable
   import ast.tpd._
 
   def visitor(implicit ctx: Context) = NoVisitor
+  def clear(): Unit = ()
 
   def transformer(implicit ctx: Context): Tree => Tree = {
     case t @ If(cond, thenp, elsep) =>

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

@@ -19,6 +19,7 @@ class DropNoEffects(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
   def visitor(implicit ctx: Context) = NoVisitor
+  def clear(): Unit = ()
 
   def transformer(implicit ctx: Context): Tree => Tree = {
     // Remove empty blocks

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

@@ -24,6 +24,7 @@ class InlineCaseIntrinsics(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
   def visitor(implicit ctx: Context): Tree => Unit = NoVisitor
+  def clear(): Unit = ()
 
   def transformer(implicit ctx: Context): Tree => Tree = {
     // For synthetic applies on case classes (both dotty/scalac)

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

@@ -18,6 +18,11 @@ class InlineLabelsCalledOnce extends Optimisation {
   val timesUsed = mutable.HashMap[Symbol, Int]()
   val defined   = mutable.HashMap[Symbol, DefDef]()
 
+  def clear(): Unit = {
+    timesUsed.clear()
+    defined.clear()
+  }
+
   def visitor(implicit ctx: Context): Tree => Unit = {
     case d: DefDef if d.symbol.is(Label)  =>
       var isRecursive = false

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

@@ -17,8 +17,13 @@ import scala.collection.mutable
 class InlineOptions extends Optimisation {
   import ast.tpd._
 
-  private val somes = mutable.HashMap[Symbol, Tree]()
-  private val nones = mutable.HashSet[Symbol]()
+  val somes = mutable.HashMap[Symbol, Tree]()
+  val nones = mutable.HashSet[Symbol]()
+
+  def clear(): Unit = {
+    somes.clear()
+    nones.clear()
+  }
 
   def visitor(implicit ctx: Context): Tree => Unit = {
     case valdef: ValDef if !valdef.symbol.is(Mutable) &&

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

@@ -20,6 +20,8 @@ class Jumpjump extends Optimisation {
 
   val defined = mutable.HashMap[Symbol, Symbol]()
 
+  def clear(): Unit = defined.clear()
+
   def visitor(implicit ctx: Context): Tree => Unit = {
     case defdef: DefDef if defdef.symbol.is(Label)  =>
       defdef.rhs match {

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

@@ -6,12 +6,15 @@ import ast.tpd.Tree
 
 trait Optimisation {
 
-  /** Run first to gather information on Trees (using mutation) */
+  /** Gathers information on trees (using mutation), to be run first. */
   def visitor(implicit ctx: Context): Tree => Unit
 
   /** Does the actual Tree => Tree transformation. */
   def transformer(implicit ctx: Context): Tree => Tree
 
+  /** Clears all the state of this optimisation, to be run last. */
+  def clear(): Unit
+
   def name: String = this.getClass.getSimpleName
 
   val NoVisitor: Tree => Unit = _ => ()

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

@@ -26,6 +26,11 @@ import scala.collection.mutable
 
   val checkGood = mutable.HashMap[Symbol, Set[Symbol]]()
 
+  def clear(): Unit = {
+    initializedVals.clear()
+    checkGood.clear()
+  }
+
   def isGood(t: Symbol)(implicit ctx: Context): Boolean = {
     t.exists && initializedVals.contains(t) && {
       var changed = true

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

@@ -63,6 +63,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     new ConstantFold(this)          ::
     Nil
 
+  var optimisations: List[Optimisation] = Nil
+
   /** Optimisation fuel, for debugging. Decremented every time Simplify
    *  applies an optimisation until fuel == 0. Original idea from Automatic
    *  Isolation of Compiler Errors by David Whalley. Unable with -Yopt-fuel.
@@ -76,9 +78,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
     CommutativePrimitiveOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
+
     val maxFuel = ctx.settings.YoptFuel.value
     if (fuel < 0 && maxFuel > 0) // Both defaults are at -1
       fuel = maxFuel
+
+    optimisations = {
+      val o = if (ctx.erasedTypes) afterErasure else beforeErasure
+      val p = ctx.settings.YoptPhases.value
+      if (p.isEmpty) o else o.filter(x => p.contains(x.name))
+    }
+
     this
   }
 
@@ -87,12 +97,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val ctx0 = ctx
     if (ctx.settings.optimise.value && !tree.symbol.is(Label)) {
       implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
-      val optimisations = {
-        val o = if (ctx.erasedTypes) afterErasure else beforeErasure
-        val p = ctx.settings.YoptPhases.value
-        if (p.isEmpty) o else o.filter(x => p.contains(x.name))
-      }
-
       var rhs0 = tree.rhs
       var rhs1: Tree = null
       while (rhs1 ne rhs0) {
@@ -110,6 +114,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               printIfDifferent(childOptimizedTree, optimisation.transformer(ctx)(childOptimizedTree), optimisation)
             }
           }.transform(rhs0)
+
+          // Clean
+          optimisation.clear()
         }
       }
       if (rhs0 ne tree.rhs) tpd.cpy.DefDef(tree)(rhs = rhs0)

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

@@ -24,6 +24,13 @@ class Valify(val simplifyPhase: Simplify) extends Optimisation {
 
   val secondWrite: mutable.Map[Symbol, Assign] = mutable.Map()
 
+  def clear(): Unit = {
+    defined.clear()
+    firstRead.clear()
+    firstWrite.clear()
+    secondWrite.clear()
+  }
+
   def visitor(implicit ctx: Context): Tree => Unit = {
     case t: ValDef if t.symbol.is(Mutable, Lazy) && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
       if (isPureExpr(t.rhs))

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

@@ -31,6 +31,11 @@ import scala.collection.mutable
 
   val possibleRenames = mutable.HashMap[Symbol, Set[Symbol]]()
 
+  def clear(): Unit = {
+    paramsTimesUsed.clear()
+    possibleRenames.clear()
+  }
+
   def visitor(implicit ctx: Context): Tree => Unit = {
     case t: ValDef if t.symbol.is(Param) =>
       paramsTimesUsed += (t.symbol -> 0)