Use SuperPhase instead of TreeTransformer

SuperPhase is a simplified version of TreeTransformer

 - about half of the size
 - no need for separate TransformerInfo arguments
 - simpler wiring logic

The simplifications are largely due to two changes

 - use of function values, where wiring is done by a sort
   of staging
 - prepare... operations return a Context instead of a TreeTranform

Author: odersky

compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala

@@ -3,7 +3,7 @@ package dotty.tools.backend.jvm
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Types
-import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, TreeTransform, MiniPhase, MiniPhaseTransform}
+import dotty.tools.dotc.transform.SuperPhase._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc
 import dotty.tools.dotc.backend.jvm.DottyPrimitives
@@ -35,10 +35,10 @@ import StdNames.nme
 /**
  * Created by dark on 26/11/14.
  */
-class CollectEntryPoints extends MiniPhaseTransform {
+class CollectEntryPoints extends MiniPhase {
   def phaseName: String = "Collect entry points"
 
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context): tpd.Tree = {
     if ((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntryPoint(tree.symbol)) {
       ctx.genBCodePhase.asInstanceOf[GenBCode].registerEntryPoint(tree.symbol)
     }

compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala

@@ -5,7 +5,7 @@ import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Flags.Trait
-import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.transform.SuperPhase.MiniPhase
 
 /** Collect all super calls to trait members.
  *
@@ -17,12 +17,12 @@ import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, Transforme
  *  methods in a redundant mixin class could be implemented with a default abstract method,
  *  the redundant mixin class could be required as a parent by the JVM.
  */
-class CollectSuperCalls extends MiniPhaseTransform {
+class CollectSuperCalls extends MiniPhase {
   import tpd._
 
   def phaseName: String = "collectSuperCalls"
 
-  override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree = {
+  override def transformSelect(tree: Select)(implicit ctx: Context): Tree = {
     tree.qualifier match {
       case sup: Super =>
         if (tree.symbol.owner.is(Trait))

compiler/src/dotty/tools/backend/jvm/LabelDefs.scala

@@ -4,7 +4,7 @@ import dotty.tools.dotc.ast.Trees.Thicket
 import dotty.tools.dotc.ast.{Trees, tpd}
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Types
-import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, TreeTransform, MiniPhase, MiniPhaseTransform}
+import dotty.tools.dotc.transform.SuperPhase._
 import dotty.tools.dotc
 import dotty.tools.dotc.backend.jvm.DottyPrimitives
 import dotty.tools.dotc.core.Flags.FlagSet
@@ -81,14 +81,14 @@ import StdNames.nme
  *
  * @author Dmitry Petrashko
  */
-class LabelDefs extends MiniPhaseTransform {
+class LabelDefs extends MiniPhase {
   def phaseName: String = "labelDef"
 
   val queue = new ArrayBuffer[Tree]()
   val beingAppended = new mutable.HashSet[Symbol]()
   var labelLevel = 0
 
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context): tpd.Tree = {
     if (tree.symbol is Flags.Label) tree
     else {
       collectLabelDefs.clear

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

@@ -12,7 +12,6 @@ import reporting.{Reporter, ConsoleReporter}
 import Phases.Phase
 import transform._
 import util.FreshNameCreator
-import transform.TreeTransforms.{TreeTransform, TreeTransformer}
 import core.DenotTransformers.DenotTransformer
 import core.Denotations.SingleDenotation
 

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

@@ -10,7 +10,6 @@ import Types._
 import Scopes._
 import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import Decorators._
-import dotty.tools.dotc.transform.TreeTransforms.TreeTransformer
 import io.PlainFile
 import scala.io.Codec
 import util._

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -63,6 +63,8 @@ object Trees {
     final val Annotated = 38
     final val Thicket = 39
 
+    final val NumTypedTreeTags = 40
+
     final val TypedSplice = 40
     final val ModuleDef = 41
     final val ParsedTry = 42
@@ -83,6 +85,8 @@ object Trees {
     final val GenAlias = 47
     final val ContextBounds = 48
     final val PatDef = 49
+
+    final val NumTags = 50
   }
 
   // Note: it would be more logical to make Untyped = Nothing.

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

@@ -6,7 +6,7 @@ import Symbols._
 import Contexts._, Names._, Phases._, printing.Texts._, printing.Printer, printing.Showable
 import util.Positions.Position, util.SourcePosition
 import collection.mutable.ListBuffer
-import dotty.tools.dotc.transform.TreeTransforms._
+import dotty.tools.dotc.transform.SuperPhase
 import ast.tpd._
 import scala.language.implicitConversions
 import printing.Formatting._
@@ -152,7 +152,7 @@ object Decorators {
    */
   implicit class PhaseListDecorator(val names: List[String]) extends AnyVal {
     def containsPhase(phase: Phase): Boolean = phase match {
-      case phase: TreeTransformer => phase.miniPhases.exists(containsPhase)
+      case phase: SuperPhase => phase.miniPhases.exists(containsPhase)
       case _ =>
         names exists { name =>
           name == "all" || {

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

@@ -11,7 +11,7 @@ import Denotations._
 import Decorators._
 import config.Printers.config
 import scala.collection.mutable.{ListBuffer, ArrayBuffer}
-import dotty.tools.dotc.transform.TreeTransforms.{TreeTransformer, MiniPhase, TreeTransform}
+import dotty.tools.dotc.transform.SuperPhase._
 import dotty.tools.dotc.transform._
 import Periods._
 import typer.{FrontEnd, RefChecks}
@@ -111,12 +111,9 @@ object Phases {
                     assert(false, s"Only tree transforms can be squashed, ${phase.phaseName} can not be squashed")
                 }
               }
-              val block = new TreeTransformer {
-                override def phaseName: String = miniPhases.map(_.phaseName).mkString("TreeTransform:{", ", ", "}")
-                override def miniPhases: Array[MiniPhase] = filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray
-              }
+              val superPhase = new SuperPhase(filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray)
               prevPhases ++= filteredPhaseBlock.map(_.getClazz)
-              block
+              superPhase
             } else { // block of a single phase, no squashing
               val phase = filteredPhaseBlock.head
               prevPhases += phase.getClazz
@@ -144,7 +141,7 @@ object Phases {
       val flatPhases = collection.mutable.ListBuffer[Phase]()
 
       phasess.foreach(p => p match {
-        case t: TreeTransformer => flatPhases ++= t.miniPhases
+        case p: SuperPhase => flatPhases ++= p.miniPhases
         case _ => flatPhases += p
       })
 
@@ -172,12 +169,12 @@ object Phases {
       while (i < phasess.length) {
         val phase = phasess(i)
         phase match {
-          case t: TreeTransformer =>
-            val miniPhases = t.miniPhases
+          case p: SuperPhase =>
+            val miniPhases = p.miniPhases
             miniPhases.foreach{ phase =>
               checkRequirements(phase)
               phase.init(this, nextPhaseId)}
-            t.init(this, miniPhases.head.id, miniPhases.last.id)
+            p.init(this, miniPhases.head.id, miniPhases.last.id)
           case _ =>
             phase.init(this, nextPhaseId)
             checkRequirements(phase)
@@ -345,7 +342,7 @@ object Phases {
     final def sameParentsStartId = mySameParentsStartId
       // id of first phase where all symbols are guaranteed to have the same parents as in this phase
 
-    protected[Phases] def init(base: ContextBase, start: Int, end:Int): Unit = {
+    protected[Phases] def init(base: ContextBase, start: Int, end: Int): Unit = {
       if (start >= FirstPhaseId)
         assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused")
       assert(start <= Periods.MaxPossiblePhaseId, s"Too many phases, Period bits overflow")

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

@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import TreeTransforms._
+import SuperPhase._
 import Contexts.Context
 import Flags._
 import SymUtils._
@@ -29,12 +29,12 @@ import scala.collection.immutable.::
  * It assummes that generic arrays have already been handled by typer(see Applications.convertNewGenericArray).
  * Additionally it optimizes calls to scala.Array.ofDim functions by replacing them with calls to newArray with specific dimensions
  */
-class ArrayConstructors extends MiniPhaseTransform { thisTransform =>
+class ArrayConstructors extends MiniPhase {
   import ast.tpd._
 
   override def phaseName: String = "arrayConstructors"
 
-  override def transformApply(tree: tpd.Apply)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = {
     def rewrite(elemType: Type, dims: List[Tree]) =
       tpd.newArray(elemType, tree.tpe, tree.pos, JavaSeqLiteral(dims, TypeTree(defn.IntClass.typeRef)))
 

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

@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import TreeTransforms._
+import SuperPhase._
 import Contexts.Context
 import Flags._
 import SymUtils._
@@ -28,7 +28,7 @@ import ast.Trees._
  *  Furthermore, it expands the names of all private getters and setters as well as super accessors in the trait and makes
  *  them not-private.
  */
-class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransformer with FullParameterization { thisTransform =>
+class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer with FullParameterization { thisPhase =>
   import ast.tpd._
 
   override def changesMembers = true
@@ -37,7 +37,7 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform
 
   override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) = {
+  override def transformTemplate(impl: Template)(implicit ctx: Context) = {
     val cls = impl.symbol.owner.asClass
     for (mixin <- cls.mixins)
       if (mixin.is(Scala2x))
@@ -49,15 +49,15 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform
     if (mixin.implClass.is(Scala2x)) () // nothing to do, mixin was already augmented
     else {
       //println(i"creating new implclass for $mixin ${mixin.implClass}")
-      val ops = new MixinOps(cls, thisTransform)
+      val ops = new MixinOps(cls, thisPhase)
       import ops._
 
       val implClass = ctx.newCompleteClassSymbol(
         owner = mixin.owner,
         name = mixin.name.implClassName,
         flags = Abstract | Scala2x | ImplClass,
         parents = defn.ObjectType :: Nil,
-        assocFile = mixin.assocFile).enteredAfter(thisTransform)
+        assocFile = mixin.assocFile).enteredAfter(thisPhase)
 
       def implMethod(meth: TermSymbol): Symbol = {
         val mold =
@@ -91,11 +91,11 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform
           }
           else if (!sym.is(Deferred) && !sym.setter.exists &&
                    !sym.info.resultType.isInstanceOf[ConstantType])
-            traitSetter(sym.asTerm).enteredAfter(thisTransform)
+            traitSetter(sym.asTerm).enteredAfter(thisPhase)
         if ((sym.is(PrivateAccessor) && !sym.name.is(ExpandedName) &&
           (sym.isGetter || sym.isSetter)) // strangely, Scala 2 fields are also methods that have Accessor set.
           || sym.isSuperAccessor) // scala2 superaccessors are pickled as private, but are compiled as public expanded
-          sym.ensureNotPrivate.installAfter(thisTransform)
+          sym.ensureNotPrivate.installAfter(thisPhase)
       }
       ctx.log(i"Scala2x trait decls of $mixin = ${mixin.info.decls.toList.map(_.showDcl)}%\n %")
       ctx.log(i"Scala2x impl decls of $mixin = ${implClass.info.decls.toList.map(_.showDcl)}%\n %")

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

@@ -1,7 +1,6 @@
 package dotty.tools.dotc
 package transform
 
-import TreeTransforms._
 import core._
 import Symbols._
 import SymDenotations._
@@ -24,14 +23,14 @@ import core.StdNames.nme
  *
  *  is a synthetic method defined in Definitions. Erasure will later strip the <cbn-arg> wrappers.
  */
-class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer { thisTransformer =>
+class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
 
   override def phaseName: String = "byNameClosures"
 
   override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = {
     val meth = ctx.newSymbol(
       ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
-    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisTransformer))
+    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase))
   }
 }