Run most phases in 4th group at group end

Only exception: elimByName, which produces errors if run at group end.

Author: odersky

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

@@ -35,6 +35,9 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform
 
   override def phaseName: String = "augmentScala2Traits"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol
 
   override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) = {

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

@@ -42,7 +42,10 @@ class ElimByName extends TransformByNameApply with InfoTransformer { thisTransfo
 
   override def phaseName: String = "elimByName"
 
-  override def runsAfterGroupsOf = Set(classOf[Splitter])
+  //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+  //  groupEndPhase
+
+ override def runsAfterGroupsOf = Set(classOf[Splitter])
     // I got errors running this phase in an earlier group, but I did not track them down.
 
   /** Map `tree` to `tree.apply()` is `ftree` was of ExprType and becomes now a function */

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

@@ -17,6 +17,9 @@ class ElimOuterSelect extends MiniPhaseTransform { thisTransform =>
 
   override def phaseName: String = "elimOuterSelect"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def runsAfterGroupsOf = Set(classOf[ExplicitOuter])
     // ExplicitOuter needs to have run to completion before so that all classes
     // that need an outer accessor have one.

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

@@ -27,6 +27,9 @@ class FunctionXXLForwarders extends MiniPhaseTransform with IdentityDenotTransfo
 
   override def phaseName: String = "functionXXLForwarders"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo): Template = {
 
     def forwarderRhs(receiver: Tree, xsTree: Tree): Tree =  {

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

@@ -51,6 +51,9 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform =>
 
   override def phaseName = "getters"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =
       d.is(NoGetterNeeded) ||

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

@@ -43,6 +43,9 @@ class InterceptedMethods extends MiniPhaseTransform {
 
   override def phaseName: String = "intercepted"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   private[this] var primitiveGetClassMethods: Set[Symbol] = _
 
   var Any_## : Symbol = _ // cached for performance reason

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

@@ -29,6 +29,9 @@ class PhantomArgLift extends MiniPhaseTransform {
 
   override def phaseName: String = "phantomArgLift"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   /** Check what the phase achieves, to be called at any point after it is finished. */
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
     case tree: Apply =>

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

@@ -35,6 +35,9 @@ class PrimitiveForwarders extends MiniPhaseTransform with IdentityDenotTransform
 
   override def phaseName: String = "primitiveForwarders"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def runsAfter = Set(classOf[ResolveSuper])
 
   override def changesMembers = true   // the phase adds primitive forwarders

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

@@ -50,6 +50,9 @@ class ResolveSuper extends MiniPhaseTransform with IdentityDenotTransformer { th
 
   override def phaseName: String = "resolveSuper"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def runsAfter = Set(classOf[ElimByName], // verified empirically, need to figure out what the reason is.
                                classOf[AugmentScala2Traits])
 

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

@@ -24,6 +24,9 @@ class SeqLiterals extends MiniPhaseTransform {
   override def phaseName = "seqLiterals"
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher])
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
     case tpd: SeqLiteral => assert(tpd.isInstanceOf[JavaSeqLiteral])
     case _ =>

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

@@ -44,6 +44,9 @@ class VCInlineMethods extends MiniPhaseTransform with IdentityDenotTransformer {
 
   override def phaseName: String = "vcInlineMethods"
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   override def runsAfter: Set[Class[_ <: Phase]] =
     Set(classOf[ExtensionMethods], classOf[PatternMatcher], classOf[PhantomArgLift])
 

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

@@ -35,6 +35,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   private[localopt] var SeqFactoryClass: Symbol = null
   private[localopt] var CommutativePrimitiveOperations: Set[Symbol] = null
 
+  override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+    groupEndPhase
+
   /** The original intention is to run most optimizations both before and after erasure.
    *  Erasure creates new inefficiencies as well as new optimization opportunities.
    *