Remove fruitless overrides of treeTransformPhase

Now the default phase of treeTransformPhase is phase.next, we
can remove all overrides that specify the same phase.

Author: odersky

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

@@ -26,7 +26,6 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo
 
   class Transform(captured: collection.Set[Symbol]) extends TreeTransform {
     def phase = thisTransform
-    override def treeTransformPhase = thisTransform.next
 
     private class CollectCaptured(implicit ctx: Context) extends EnclosingMethodTraverser {
       private val captured = mutable.HashSet[Symbol]()

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

@@ -31,8 +31,6 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
   override def phaseName: String = "constructors"
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure])
 
-  override def treeTransformPhase = thisTransform.next
-
   /** Symbols that are owned by either <local dummy> or a class field move into the
    *  primary constructor.
    */

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

@@ -51,8 +51,6 @@ class ElimByName extends MiniPhaseTransform with InfoTransformer { thisTransform
     // assumes idents and selects have symbols; interferes with splitter distribution
     // that's why it's "after group".
 
-  override def treeTransformPhase = thisTransformer.next
-
   /** The info of the tree's symbol at phase Nullarify (i.e. before transformation) */
   private def originalDenotation(tree: Tree)(implicit ctx: Context) =
     tree.symbol.denot(ctx.withPhase(thisTransformer))

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

@@ -43,7 +43,6 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf
     * before this phase starts
     */
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher])
-  override def treeTransformPhase = thisTransformer.next
 
   /** Add outer accessors if a class always needs an outer pointer */
   override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {

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

@@ -57,8 +57,6 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
       ref
   }
 
-  override def treeTransformPhase = thisTransformer.next
-
   protected def rewiredTarget(target: Symbol, derived: Symbol)(implicit ctx: Context): Symbol =
     if (isMethodWithExtension(target) &&
         target.owner.linkedClass == derived.owner) extensionMethod(target)

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

@@ -25,8 +25,6 @@ class Flatten extends MiniPhaseTransform with SymTransformer { thisTransform =>
     else ref
   }
 
-  override def treeTransformPhase = thisTransform.next
-
   private val liftedDefs = new mutable.ListBuffer[Tree]
 
   private def liftIfNested(tree: Tree)(implicit ctx: Context, info: TransformerInfo) =

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

@@ -43,7 +43,6 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform =>
   import ast.tpd._
 
   override def phaseName = "getters"
-  override def treeTransformPhase = thisTransform.next
 
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =

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

@@ -45,7 +45,6 @@ class InterceptedMethods extends MiniPhaseTransform { thisTransform =>
   import tpd._
 
   override def phaseName: String = "intercepted"
-  override def treeTransformPhase = thisTransform.next
 
   private var getClassMethods: Set[Symbol] = _
   private var poundPoundMethods: Set[Symbol] = _

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

@@ -45,7 +45,6 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
 
   class LambdaLifter extends TreeTransform {
     override def phase = thisTransform
-    override def treeTransformPhase = thisTransform.next
 
     private type SymSet = TreeSet[Symbol]
 

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

@@ -37,8 +37,6 @@ class LazyValsTransform extends MiniPhaseTransform with IdentityDenotTransformer
 
   override def phaseName: String = "LazyVals"
 
-  override def treeTransformPhase = this.next
-
     /** List of names of phases that should have finished processing of tree
       * before this phase starts processing same tree */
     // override def ensureAfter: Set[String] = Set("mixin")

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

@@ -19,7 +19,6 @@ class Literalize extends MiniPhaseTransform { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "literalize"
-  override def treeTransformPhase = thisTransform.next
 
   /** Note: Demanding idempotency instead of purity is strictly speaking too loose.
    *  Example

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

@@ -35,7 +35,6 @@ import Decorators._
   import ast.tpd._
 
   override def phaseName = "memoize"
-  override def treeTransformPhase = thisTransform.next
 
   /** Should to run after mixin so that fields get generated in the
    *  class that contains the concrete getter rather than the trait

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

@@ -67,7 +67,6 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "mixin"
-  override def treeTransformPhase = thisTransform.next
 
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure])
 

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

@@ -36,8 +36,6 @@ import scala.reflect.internal.util.Collections
 class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTransformer =>
   import dotty.tools.dotc.ast.tpd._
 
-  override def treeTransformPhase = thisTransformer.next
-
   override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref
 
   override def runsAfter = Set(classOf[ElimRepeated])

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

@@ -48,7 +48,6 @@ class PrivateToStatic extends MiniPhase with SymTransformer { thisTransform =>
 
   class Transform(thisParam: Symbol) extends TreeTransform {
     def phase = thisTransform
-    override def treeTransformPhase = thisTransform.next
 
     override def prepareForDefDef(tree: DefDef)(implicit ctx: Context) =
       if (shouldBeStatic(tree.symbol)) {

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

@@ -48,8 +48,6 @@ class ResolveSuper extends MiniPhaseTransform with IdentityDenotTransformer { th
 
   override def phaseName: String = "resolveSuper"
 
-  override def treeTransformPhase = thisTransform.next
-
   /** Returns the symbol that is accessed by a super-accessor in a mixin composition.
    *
    *  @param base       The class in which everything is mixed together

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

@@ -19,8 +19,6 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t
   import ast.tpd._
   override def phaseName = "restoreScopes"
 
-  override def treeTransformPhase = thisTransform.next
-
   override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo) = {
     val TypeDef(_, Template(constr, _, _, body)) = tree
     val restoredDecls = newScope

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

@@ -18,11 +18,10 @@ import Decorators._
  *  is called directly. The reason for this step is that JavaSeqLiterals, being arrays
  *  keep a precise type after erasure, whereas SeqLiterals only get the erased type `Seq`,
  */
-class SeqLiterals extends MiniPhaseTransform { thisTransformer =>
+class SeqLiterals extends MiniPhaseTransform {
   import ast.tpd._
 
   override def phaseName = "seqLiterals"
-  override def treeTransformPhase = thisTransformer.next
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher])
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {

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

@@ -16,7 +16,6 @@ class Splitter extends MiniPhaseTransform { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "splitter"
-  override def treeTransformPhase = thisTransform.next
 
   /** Replace self referencing idents with ThisTypes. */
   override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = tree.tpe match {

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

@@ -35,7 +35,6 @@ class SyntheticMethods extends MiniPhaseTransform with IdentityDenotTransformer
   import ast.tpd._
 
   override def phaseName = "synthetics"
-  override def treeTransformPhase = thisTransformer.next
 
   private var valueSymbols: List[Symbol] = _
   private var caseSymbols: List[Symbol] = _

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -745,7 +745,6 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer =>
 
   class Transform(currentLevel: RefChecks.OptLevelInfo = RefChecks.NoLevelInfo) extends TreeTransform {
     def phase = thisTransformer
-    override def treeTransformPhase = thisTransformer.next
 
     override def prepareForStats(trees: List[Tree])(implicit ctx: Context) = {
       // println(i"preparing for $trees%; %, owner = ${ctx.owner}")