Allow phases to choose to run at group end

Author: odersky

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

@@ -656,26 +656,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** After phase `trans`, set the owner of every definition in this tree that was formerly
      *  owner by `from` to `to`.
      */
-    def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(implicit ctx: Context): ThisTree = {
-      assert(ctx.phase == trans.next)
-      val traverser = new TreeTraverser {
-        def traverse(tree: Tree)(implicit ctx: Context) = tree match {
-          case tree: DefTree =>
-            val sym = tree.symbol
-            val prevDenot = sym.denot(ctx.withPhase(trans))
-            if (prevDenot.effectiveOwner == from.skipWeakOwner) {
-              val d = sym.copySymDenotation(owner = to)
-              d.installAfter(trans)
-              d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d)
-            }
-            if (sym.isWeakOwner) traverseChildren(tree)
-          case _ =>
-            traverseChildren(tree)
+    def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(implicit ctx: Context): ThisTree =
+      if (ctx.phase == trans.next) {
+        val traverser = new TreeTraverser {
+          def traverse(tree: Tree)(implicit ctx: Context) = tree match {
+            case tree: DefTree =>
+              val sym = tree.symbol
+              val prevDenot = sym.denot(ctx.withPhase(trans))
+              if (prevDenot.effectiveOwner == from.skipWeakOwner) {
+                val d = sym.copySymDenotation(owner = to)
+                d.installAfter(trans)
+                d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d)
+              }
+              if (sym.isWeakOwner) traverseChildren(tree)
+            case _ =>
+              traverseChildren(tree)
+          }
         }
+        traverser.traverse(tree)
+        tree
       }
-      traverser.traverse(tree)
-      tree
-    }
+      else changeOwnerAfter(from, to, trans)(ctx.withPhase(trans.next))
 
     /** A select node with the given selector name and a computed type */
     def select(name: Name)(implicit ctx: Context): Select =

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

@@ -62,7 +62,8 @@ object TreeTransforms {
     def phase: MiniPhase
 
     /** The phase at which the tree is transformed */
-    final def treeTransformPhase: Phase = phase.next
+    def treeTransformPhase(implicit ctx: Context, info: TransformerInfo): Phase =
+      phase.next
 
     val cpy: TypedTreeCopier = cpyBetweenPhases
 
@@ -140,10 +141,11 @@ object TreeTransforms {
     /** 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, phase.idx + 1)
 
-    def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) = {
-      val last = info.transformers(info.transformers.length - 1)
-      action(ctx.withPhase(last.phase.next))
-    }
+    def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) =
+      action(ctx.withPhase(groupEndPhase))
+
+    def groupEndPhase(implicit ctx: Context, info: TransformerInfo) =
+      info.transformers(info.transformers.length - 1).phase.next
   }
 
   /** A phase that defines a TreeTransform to be used in a group */
@@ -494,7 +496,7 @@ object TreeTransforms {
       var allDone = i < l
       while (i < l) {
         val oldTransform = result(i)
-        val newTransform = mutator(oldTransform, tree, ctx.withPhase(oldTransform.treeTransformPhase))
+        val newTransform = mutator(oldTransform, tree, ctx.withPhase(oldTransform.treeTransformPhase(ctx, info)))
         allDone = allDone && (newTransform eq NoTransform)
         if (!(oldTransform eq newTransform)) {
           if (!transformersCopied) result = result.clone()
@@ -1180,7 +1182,7 @@ object TreeTransforms {
           util.Stats.record("TreeTransform.transform")
           // if cur > 0 then some of the symbols can be created by already performed transformations
           // this means that their denotations could not exists in previous period
-          val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase)
+          val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase(ctx, info))
           tree match {
             //split one big match into 2 smaller ones
             case tree: NameTree => transformNamed(tree, info, cur)(pctx)