Fix miniphase assembly.

There were two architectural errors here, which confused TreeTransforms and MiniPhases
and which caused "NotDefinedHere" on transformFollowing:

1. TreeTransforms should not have idx fields, MiniPhases have them.2
2. TreeTransformers initialize arrays of MiniPhases not TreeTransforms.

Author: odersky

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

@@ -135,7 +135,7 @@ object Decorators {
    */
   implicit class PhaseListDecorator(val names: List[String]) extends AnyVal {
     def containsPhase(phase: Phase): Boolean = phase match {
-      case phase: TreeTransformer => phase.transformations.exists(trans => containsPhase(trans.phase))
+      case phase: TreeTransformer => phase.miniPhases.exists(containsPhase)
       case _ =>
         names exists { name =>
           name == "all" || {

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

@@ -109,11 +109,9 @@ object Phases {
                     assert(false, s"Only tree transforms can be squashed, ${phase.phaseName} can not be squashed")
                 }
               }
-              val transforms = filteredPhaseBlock.asInstanceOf[List[MiniPhase]].map(_.treeTransform)
               val block = new TreeTransformer {
-                override def phaseName: String = transformations.map(_.phase.phaseName).mkString("TreeTransform:{", ", ", "}")
-
-                override def transformations: Array[TreeTransform] = transforms.toArray
+                override def phaseName: String = miniPhases.map(_.phaseName).mkString("TreeTransform:{", ", ", "}")
+                override def miniPhases: Array[MiniPhase] = filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray
               }
               prevPhases ++= filteredPhaseBlock.map(_.getClazz)
               block
@@ -145,7 +143,7 @@ object Phases {
       val flatPhases = collection.mutable.ListBuffer[Phase]()
 
       phasess.foreach(p => p match {
-        case t: TreeTransformer => flatPhases ++= t.transformations.map(_.phase)
+        case t: TreeTransformer => flatPhases ++= t.miniPhases
         case _ => flatPhases += p
       })
 
@@ -173,11 +171,11 @@ object Phases {
         val phase = phasess(i)
         phase match {
           case t: TreeTransformer =>
-            val transforms = t.transformations
-            transforms.foreach{ x =>
-              checkRequirements(x.phase)
-              x.phase.init(this, nextPhaseId)}
-            t.init(this, transforms.head.phase.id, transforms.last.phase.id)
+            val miniPhases = t.miniPhases
+            miniPhases.foreach{ phase =>
+              checkRequirements(phase)
+              phase.init(this, nextPhaseId)}
+            t.init(this, miniPhases.head.id, miniPhases.last.id)
           case _ =>
             phase.init(this, nextPhaseId)
             checkRequirements(phase)

src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -103,7 +103,7 @@ class TreeChecker extends Phase with SymTransformer {
 
   private def previousPhases(phases: List[Phase])(implicit ctx: Context): List[Phase] = phases match {
     case (phase: TreeTransformer) :: phases1 =>
-      val subPhases = phase.transformations.map(_.phase)
+      val subPhases = phase.miniPhases
       val previousSubPhases = previousPhases(subPhases.toList)
       if (previousSubPhases.length == subPhases.length) previousSubPhases ::: previousPhases(phases1)
       else previousSubPhases

src/dotty/tools/dotc/transform/TreeTransform.scala

@@ -63,9 +63,6 @@ object TreeTransforms {
 
     def treeTransformPhase: Phase = phase.next
 
-    /** id of this treeTransform in group */
-    var idx: Int = _
-
     def prepareForIdent(tree: Ident)(implicit ctx: Context) = this
     def prepareForSelect(tree: Select)(implicit ctx: Context) = this
     def prepareForThis(tree: This)(implicit ctx: Context) = this
@@ -137,10 +134,10 @@ object TreeTransforms {
     def transform(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transform(tree, info, 0)
 
     /** Transform subtree using all transforms following the current one in this group */
-    def transformFollowingDeep(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transform(tree, info, idx + 1)
+    def transformFollowingDeep(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transform(tree, info, phase.idx + 1)
 
     /** Transform single node using all transforms following the current one in this group */
-    def transformFollowing(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transformSingle(tree, idx + 1)
+    def transformFollowing(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transformSingle(tree, phase.idx + 1)
 
     def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) = {
       val last = info.transformers(info.transformers.length - 1)
@@ -152,14 +149,17 @@ object TreeTransforms {
   trait MiniPhase extends Phase { thisPhase =>
     def treeTransform: TreeTransform
 
+    /** id of this mini phase in group */
+    var idx: Int = _
+
     /** List of names of phases that should have finished their processing of all compilation units
      *  before this phase starts
      */
     def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set.empty
 
     protected def mkTreeTransformer = new TreeTransformer {
       override def phaseName: String = thisPhase.phaseName
-      override def transformations = Array(treeTransform)
+      override def miniPhases = Array(thisPhase)
     }
 
     override def run(implicit ctx: Context): Unit = {
@@ -197,7 +197,6 @@ object TreeTransforms {
 
   @sharable val NoTransform = new TreeTransform {
     def phase = unsupported("phase")
-    idx = -1
   }
 
   type Mutator[T] = (TreeTransform, T, Context) => TreeTransform
@@ -474,7 +473,7 @@ object TreeTransforms {
   /** A group of tree transforms that are applied in sequence during the same phase */
   abstract class TreeTransformer extends Phase {
 
-    def transformations: Array[TreeTransform]
+    def miniPhases: Array[MiniPhase]
 
     override def run(implicit ctx: Context): Unit = {
       val curTree = ctx.compilationUnit.tpdTree
@@ -549,10 +548,10 @@ object TreeTransforms {
     val prepForStats: Mutator[List[Tree]] = (trans, trees, ctx) => trans.prepareForStats(trees)(ctx)
     val prepForUnit: Mutator[Tree] = (trans, tree, ctx) => trans.prepareForUnit(tree)(ctx)
 
-    val initialTransformationsCache = transformations.zipWithIndex.map {
-      case (transform, id) =>
-        transform.idx = id
-        transform
+    val initialTransformationsCache = miniPhases.zipWithIndex.map {
+      case (miniPhase, id) =>
+        miniPhase.idx = id
+        miniPhase.treeTransform
     }
 
     val initialInfoCache = new TransformerInfo(initialTransformationsCache, new NXTransformations(initialTransformationsCache), this)

test/test/transform/TreeTransformerTest.scala

@@ -20,7 +20,7 @@ class TreeTransformerTest extends DottyTest {
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new TreeTransformer {
-        override def transformations = Array(new EmptyTransform)
+        override def miniPhases = Array(new EmptyTransform)
 
         override def phaseName: String = "test"
       }
@@ -42,7 +42,7 @@ class TreeTransformerTest extends DottyTest {
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new TreeTransformer {
-        override def transformations = Array(new ConstantTransform)
+        override def miniPhases = Array(new ConstantTransform)
 
         override def phaseName: String = "test"
       }
@@ -72,7 +72,7 @@ class TreeTransformerTest extends DottyTest {
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new TreeTransformer {
-        override def transformations = Array(new Transformation)
+        override def miniPhases = Array(new Transformation)
 
         override def phaseName: String = "test"
 
@@ -119,7 +119,7 @@ class TreeTransformerTest extends DottyTest {
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new TreeTransformer {
-        override def transformations = Array(new Transformation1, new Transformation2)
+        override def miniPhases = Array(new Transformation1, new Transformation2)
 
         override def phaseName: String = "test"
       }
@@ -187,7 +187,7 @@ class TreeTransformerTest extends DottyTest {
         init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new TreeTransformer {
-        override def transformations = Array(new Transformation1, new Transformation2)
+        override def miniPhases = Array(new Transformation1, new Transformation2)
 
         override def phaseName: String = "test"
       }