Merge pull request #286 from dotty-staging/change/defaultphase

Change/defaultphase

29 files changed, 29 insertions, 166 deletions

diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index 6824cc36c..805b7660c 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -77,7 +77,10 @@ object Contexts {
 
     /** The current context */
     private[this] var _period: Period = _
-    protected def period_=(period: Period) = _period = period
+    protected def period_=(period: Period) = {
+      assert(period.firstPhaseId == period.lastPhaseId, period)
+      _period = period
+    }
     def period: Period = _period
 
     /** The scope nesting level */
@@ -193,7 +196,7 @@ object Contexts {
     /** This context at given phase.
      *  This method will always return a phase period equal to phaseId, thus will never return squashed phases
      */
-    final def withPhase(phaseId: PhaseId): Context = {
+    final def withPhase(phaseId: PhaseId): Context =
       if (this.phaseId == phaseId) this
       else if (phasedCtx.phaseId == phaseId) phasedCtx
       else if (phasedCtxs != null && phasedCtxs(phaseId) != null) phasedCtxs(phaseId)
@@ -206,7 +209,6 @@ object Contexts {
         }
         ctx1
       }
-    }
 
     final def withPhase(phase: Phase): Context =
       withPhase(phase.id)
diff --git a/src/dotty/tools/dotc/core/Phases.scala b/src/dotty/tools/dotc/core/Phases.scala
index ffe2ddbea..5777c0f5b 100644
--- a/src/dotty/tools/dotc/core/Phases.scala
+++ b/src/dotty/tools/dotc/core/Phases.scala
@@ -170,7 +170,7 @@ object Phases {
     private val patmatCache = new PhaseCache(classOf[PatternMatcher])
     private val flattenCache = new PhaseCache(classOf[Flatten])
     private val explicitOuterCache = new PhaseCache(classOf[ExplicitOuter])
-    private val gettersSettersCache = new PhaseCache(classOf[GettersSetters])
+    private val gettersCache = new PhaseCache(classOf[Getters])
 
     def typerPhase = typerCache.phase
     def refchecksPhase = refChecksCache.phase
@@ -178,7 +178,7 @@ object Phases {
     def patmatPhase = patmatCache.phase
     def flattenPhase = flattenCache.phase
     def explicitOuterPhase = explicitOuterCache.phase
-    def gettersSettersPhase = gettersSettersCache.phase
+    def gettersPhase = gettersCache.phase
 
     def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
   }
@@ -194,7 +194,7 @@ object Phases {
 
     def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
       units.map { unit =>
-        val unitCtx = ctx.fresh.setPhase(this).setCompilationUnit(unit)
+        val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
         run(unitCtx)
         unitCtx.compilationUnit
       }
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index 83fb2c134..9be75c11a 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -396,15 +396,16 @@ object Symbols {
      *  that starts being valid after `phase`.
      *  @pre  Symbol is a class member
      */
-    def enteredAfter(phase: DenotTransformer)(implicit ctx: Context): this.type = {
-      val nextCtx = ctx.withPhase(phase.next)
-      if (this.owner.is(Package)) {
-        denot.validFor |= InitialPeriod
-        if (this is Module) this.moduleClass.validFor |= InitialPeriod
+    def enteredAfter(phase: DenotTransformer)(implicit ctx: Context): this.type =
+      if (ctx.phaseId != phase.next.id) enteredAfter(phase)(ctx.withPhase(phase.next))
+      else {
+        if (this.owner.is(Package)) {
+          denot.validFor |= InitialPeriod
+          if (this is Module) this.moduleClass.validFor |= InitialPeriod
+        }
+        else this.owner.asClass.ensureFreshScopeAfter(phase)
+        entered
       }
-      else this.owner.asClass.ensureFreshScopeAfter(phase)(nextCtx)
-      entered(nextCtx)
-    }
 
     /** This symbol, if it exists, otherwise the result of evaluating `that` */
     def orElse(that: => Symbol)(implicit ctx: Context) =
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index a7f50c369..42af31553 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -792,7 +792,7 @@ class TypeComparer(initctx: Context) extends DotClass {
             tp2.info match {
               case tp2i: TermRef =>
                 isSubType(tp1, tp2i)
-              case ExprType(tp2i: TermRef) if (ctx.phase.id > ctx.gettersSettersPhase.id) =>
+              case ExprType(tp2i: TermRef) if (ctx.phase.id > ctx.gettersPhase.id) =>
                 isSubType(tp1, tp2i)
               case _ =>
                 false
diff --git a/src/dotty/tools/dotc/transform/CapturedVars.scala b/src/dotty/tools/dotc/transform/CapturedVars.scala
index 14bb4a738..e923c94de 100644
--- a/src/dotty/tools/dotc/transform/CapturedVars.scala
+++ b/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]()
diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index 2e8196ff0..1df4df1e4 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/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.
    */
diff --git a/src/dotty/tools/dotc/transform/ElimByName.scala b/src/dotty/tools/dotc/transform/ElimByName.scala
index cb5fdbbf0..e06eb0602 100644
--- a/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/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))
diff --git a/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index 0810f7d9c..ba74de0a3 100644
--- a/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/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 {
diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index 7606a08a3..2ff43c55b 100644
--- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/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)
diff --git a/src/dotty/tools/dotc/transform/FirstTransform.scala b/src/dotty/tools/dotc/transform/FirstTransform.scala
index 42ace148a..56d28cd4d 100644
--- a/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -35,7 +35,6 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
 
   override def phaseName = "firstTransform"
 
-
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
diff --git a/src/dotty/tools/dotc/transform/Flatten.scala b/src/dotty/tools/dotc/transform/Flatten.scala
index dceefc0bc..ff3f06c68 100644
--- a/src/dotty/tools/dotc/transform/Flatten.scala
+++ b/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) =
diff --git a/src/dotty/tools/dotc/transform/Getters.scala b/src/dotty/tools/dotc/transform/Getters.scala
index 4ea9d2c6b..e018a45cc 100644
--- a/src/dotty/tools/dotc/transform/Getters.scala
+++ b/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 =
diff --git a/src/dotty/tools/dotc/transform/GettersSetters.scala b/src/dotty/tools/dotc/transform/GettersSetters.scala
deleted file mode 100644
index bbe5740ff..000000000
--- a/src/dotty/tools/dotc/transform/GettersSetters.scala
+++ /dev/null
@@ -1,117 +0,0 @@
-package dotty.tools.dotc
-package transform
-
-import core._
-import DenotTransformers.SymTransformer
-import Phases.Phase
-import Contexts.Context
-import SymDenotations.SymDenotation
-import Types._
-import Symbols._
-import SymUtils._
-import Constants._
-import ast.Trees._
-import TreeTransforms._
-import NameOps._
-import Flags._
-import Decorators._
-
-/** Performs the following rewritings on fields of classes, where `x_L` is the "local name" of `x`:
- *
- *    val x: T = e
- *      -->  private val x_L: T = e
- *           <stable> def x: T = x_L
- *
- *    var x: T = e
- *    def x_=(y: T) = ()
- *      -->  private var x_L: T = e
- *           def x: T = x_L
- *           def x_=(x: T): Unit = x_L = x                            (if in class or trait)
- *
- *    lazy val x: T = e
- *      --> def x: T = e
- *
- *    val x: T
- *      -->  <stable> def x: T
- *
- *    var x: T
- *      -->  def x: T
- *
- *  Omitted from the rewritings are
- *
- *   - private[this] fields in non-trait classes
- *   - fields generated for static modules (TODO: needed?)
- *   - parameters, static fields, and fields coming from Java
- *
- *  Furthermore, assignements to mutable vars are replaced by setter calls
- *
- *     p.x = e
- *      -->  p.x_=(e)
- */
- class GettersSetters extends MiniPhaseTransform with SymTransformer { thisTransform =>
-  import ast.tpd._
-
-  override def phaseName = "gettersSetters"
-
-  override def treeTransformPhase = thisTransform.next
-
-  override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
-    def noGetterNeeded =
-      d.is(NoGetterNeeded) ||
-      d.initial.asInstanceOf[SymDenotation].is(PrivateLocal) && !d.owner.is(Trait) ||
-      d.is(Module) && d.isStatic ||
-      d.isSelfSym
-    if (d.isTerm && d.owner.isClass && d.info.isValueType && !noGetterNeeded) {
-      val maybeStable = if (d.isStable) Stable else EmptyFlags
-      //if (d.name.toString == "_") println(i"make accessor $d in ${d.owner} ${d.symbol.id}")
-      d.copySymDenotation(
-        initFlags = d.flags | maybeStable | AccessorCreationFlags,
-        info = ExprType(d.info))
-    }
-    else d
-  }
-  private val NoGetterNeeded = Method | Param | JavaDefined | JavaStatic
-  private val NoFieldNeeded  = Lazy | Deferred | ParamAccessor
-
-  override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    if (tree.symbol is Method) {
-      val getter = tree.symbol.asTerm
-      assert(getter is Accessor)
-      if (getter is NoFieldNeeded)
-        DefDef(getter, tree.rhs)
-      else {
-        val inTrait = getter.owner.is(Trait)
-        val field = ctx.newSymbol(
-          owner = ctx.owner,
-          name = getter.name.fieldName,
-          flags = Private | (getter.flags & Mutable),
-          info = getter.info.resultType).enteredAfter(thisTransform)
-        assert(tree.rhs.tpe.exists, tree.show)
-        val fieldDef =
-          cpy.ValDef(tree)(
-            name = field.name,
-            rhs = tree.rhs.changeOwner(getter, field).ensureConforms(field.info.widen)
-          ).withType(field.valRef)
-        val rhs = ref(field)
-        assert(rhs.hasType)
-        val getterDef = DefDef(getter, rhs.ensureConforms(getter.info.widen))
-        Thicket(fieldDef, getterDef)
-      }
-    }
-    else tree
-  }
-
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree =
-    if (tree.symbol.isSetter && !tree.symbol.is(Deferred | ParamAccessor | JavaDefined)) {
-      val Literal(Constant(())) = tree.rhs
-      assert(tree.symbol.field.exists, i"no field for ${tree.symbol.showLocated}")
-      val initializer = Assign(ref(tree.symbol.field), ref(tree.vparamss.head.head.symbol))
-      assert(initializer.hasType)
-      cpy.DefDef(tree)(rhs = initializer)
-    }
-    else tree
-
-  override def transformAssign(tree: Assign)(implicit ctx: Context, info: TransformerInfo): Tree =
-    if (tree.lhs.symbol is Method) tree.lhs.becomes(tree.rhs)
-    else tree
-}
\ No newline at end of file
diff --git a/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
index c4f5d4dac..e1c4dbe75 100644
--- a/src/dotty/tools/dotc/transform/InterceptedMethods.scala
+++ b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
@@ -40,7 +40,7 @@ import StdNames._
   *     using the most precise overload available
   * - `x.getClass` for getClass in primitives becomes `x.getClass` with getClass in class Object.
   */
-class InterceptedMethods extends MiniPhaseTransform {
+class InterceptedMethods extends MiniPhaseTransform { thisTransform =>
 
   import tpd._
 
diff --git a/src/dotty/tools/dotc/transform/LambdaLift.scala b/src/dotty/tools/dotc/transform/LambdaLift.scala
index 944dac208..512e19838 100644
--- a/src/dotty/tools/dotc/transform/LambdaLift.scala
+++ b/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]
 
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 8b430aae9..7b6135dc0 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/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")
diff --git a/src/dotty/tools/dotc/transform/Literalize.scala b/src/dotty/tools/dotc/transform/Literalize.scala
index 79f0dd493..99b4b173b 100644
--- a/src/dotty/tools/dotc/transform/Literalize.scala
+++ b/src/dotty/tools/dotc/transform/Literalize.scala
@@ -15,7 +15,7 @@ import ast.Trees._
  *  The constant types are eliminated by erasure, so we need to keep
  *  the info about constantness in the trees.
  */
-class Literalize extends MiniPhaseTransform {
+class Literalize extends MiniPhaseTransform { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "literalize"
diff --git a/src/dotty/tools/dotc/transform/Memoize.scala b/src/dotty/tools/dotc/transform/Memoize.scala
index 17a84484a..439efa8b4 100644
--- a/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/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
diff --git a/src/dotty/tools/dotc/transform/Mixin.scala b/src/dotty/tools/dotc/transform/Mixin.scala
index a96e5f1f5..230763fae 100644
--- a/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/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])
 
diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 9be8e5e19..bebe996b9 100644
--- a/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/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])
diff --git a/src/dotty/tools/dotc/transform/PrivateToStatic.scala b/src/dotty/tools/dotc/transform/PrivateToStatic.scala
index 15697e655..e38aa27f0 100644
--- a/src/dotty/tools/dotc/transform/PrivateToStatic.scala
+++ b/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)) {
diff --git a/src/dotty/tools/dotc/transform/ResolveSuper.scala b/src/dotty/tools/dotc/transform/ResolveSuper.scala
index 6b1b55b0a..9f952f6de 100644
--- a/src/dotty/tools/dotc/transform/ResolveSuper.scala
+++ b/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
diff --git a/src/dotty/tools/dotc/transform/RestoreScopes.scala b/src/dotty/tools/dotc/transform/RestoreScopes.scala
index e133ae2f2..9cd147d99 100644
--- a/src/dotty/tools/dotc/transform/RestoreScopes.scala
+++ b/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
diff --git a/src/dotty/tools/dotc/transform/SeqLiterals.scala b/src/dotty/tools/dotc/transform/SeqLiterals.scala
index 021516454..6e29d7e09 100644
--- a/src/dotty/tools/dotc/transform/SeqLiterals.scala
+++ b/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 {
diff --git a/src/dotty/tools/dotc/transform/Splitter.scala b/src/dotty/tools/dotc/transform/Splitter.scala
index 823485af9..0a1e1b238 100644
--- a/src/dotty/tools/dotc/transform/Splitter.scala
+++ b/src/dotty/tools/dotc/transform/Splitter.scala
@@ -12,7 +12,7 @@ import Contexts._, Types._, Decorators._, Denotations._, Symbols._, SymDenotatio
  *
  *  For now, only self references are treated.
  */
-class Splitter extends MiniPhaseTransform {
+class Splitter extends MiniPhaseTransform { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "splitter"
diff --git a/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
index 4e10b4aaf..c9920a3b6 100644
--- a/src/dotty/tools/dotc/transform/SyntheticMethods.scala
+++ b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
@@ -170,7 +170,7 @@ class SyntheticMethods extends MiniPhaseTransform with IdentityDenotTransformer
   override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) =
     if (ctx.owner.is(Case) || isDerivedValueClass(ctx.owner))
       cpy.Template(impl)(
-        body = impl.body ++ syntheticMethods(ctx.owner.asClass)(ctx.withPhase(thisTransformer.next)))
+        body = impl.body ++ syntheticMethods(ctx.owner.asClass))
     else
       impl
 }
diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala
index 57f1336ed..f4e95830d 100644
--- a/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/src/dotty/tools/dotc/transform/TailRec.scala
@@ -62,13 +62,14 @@ import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, MiniPhaseTran
  *             self recursive functions, that's why it's renamed to tailrec
  *             </p>
  */
-class TailRec extends MiniPhaseTransform with DenotTransformer with FullParameterization {
+class TailRec extends MiniPhaseTransform with DenotTransformer with FullParameterization { thisTransform =>
 
   import dotty.tools.dotc.ast.tpd._
 
   override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref
 
   override def phaseName: String = "tailrec"
+  override def treeTransformPhase = thisTransform // TODO Make sure tailrec runs at next phase.
 
   final val labelPrefix = "tailLabel"
   final val labelFlags = Flags.Synthetic | Flags.Label
diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index 4dba26870..814d7bf31 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -59,7 +59,7 @@ object TreeTransforms {
 
     def phase: MiniPhase
 
-    def treeTransformPhase: Phase = phase
+    def treeTransformPhase: Phase = phase.next
 
     /** id of this treeTransform in group */
     var idx: Int = _
@@ -177,6 +177,8 @@ object TreeTransforms {
   trait AnnotationTransformer extends MiniPhaseTransform with InfoTransformer {
 
     val annotationTransformer = mkTreeTransformer
+    override final def treeTransformPhase = this
+      // need to run at own phase because otherwise we get ahead of ourselves in transforming denotations
 
     override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = {
       val info1 = transformInfo(ref.info, ref.symbol)
@@ -1236,7 +1238,7 @@ object TreeTransforms {
     final private[TreeTransforms] def goStats(trees: List[Tree], cur: Int)(implicit ctx: Context, info: TransformerInfo): List[Tree] = {
       if (cur < info.transformers.length) {
         val trans = info.transformers(cur)
-        val stats = trans.transformStats(trees)
+        val stats = trans.transformStats(trees)(ctx.withPhase(trans.treeTransformPhase), info)
         goStats(stats, info.nx.nxTransStats(cur + 1))
       } else trees
     }
diff --git a/src/dotty/tools/dotc/typer/RefChecks.scala b/src/dotty/tools/dotc/typer/RefChecks.scala
index bf0f75c96..e2855c8f6 100644
--- a/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/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}")