Transform/captured vars

src/dotty/tools/dotc/Compiler.scala

@@ -6,7 +6,7 @@ import Contexts._
 import Periods._
 import Symbols._
 import Scopes._
-import typer.{FrontEnd, Typer, Mode, ImportInfo}
+import typer.{FrontEnd, Typer, Mode, ImportInfo, RefChecks}
 import reporting.ConsoleReporter
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform._
@@ -16,25 +16,55 @@ import dotty.tools.dotc.core.Denotations.SingleDenotation
 
 class Compiler {
 
+  /** Meta-ordering constraint:
+   *
+   *  DenotTransformers that change the signature of  their denotation's info must go
+   *  after erasure. The reason is that denotations are permanently referred to by
+   *  TermRefs which contain a signature. If the signature of a symbol would change,
+   *  all refs to it would become outdated - they could not be dereferenced in the
+   *  new phase.
+   *
+   *  As an example, addGetters would change a field
+   *
+   *     val x: T
+   *
+   *  to a method
+   *
+   *     def x: T
+   *
+   *  but this would affect the signature of `x` (goes from NotAMethod to a method
+   *  signature). So we can't do this before erasure.
+   *
+   *  After erasure, signature changing denot-transformers are OK because erasure
+   *  will make sure that only term refs with fixed SymDenotations survive beyond it. This
+   *  is possible because:
+   *
+   *   - splitter has run, so every ident or select refers to a unique symbol
+   *   - after erasure, asSeenFrom is the identity, so every reference has a
+   *     plain SymDenotation, as opposed to a UniqueRefDenotation.
+   */
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
-      List(new Companions),
+      List(new FirstTransform,
+           new SyntheticMethods),
       List(new SuperAccessors),
-      // pickling and refchecks goes here
-      List(new ElimRepeated, new ElimLocals),
+      // pickling goes here
+      List(new RefChecks,
+           new ElimRepeated,
+           new ElimLocals),
       List(new ExtensionMethods),
       List(new TailRec),
       List(new PatternMatcher,
-           new LazyValTranformContext().transformer,
+           new ExplicitOuter,
+           // new LazyValTranformContext().transformer, // disabled, awaiting fixes
            new Splitter),
-      List(new Nullarify,
+      List(new ElimByName,
            new TypeTestsCasts,
            new InterceptedMethods,
            new Literalize),
       List(new Erasure),
-      List(new UncurryTreeTransform
-        /* , new Constructors */)
+      List(new CapturedVars)
     )
 
   var runId = 1

src/dotty/tools/dotc/ElimLocals.scala

@@ -6,12 +6,12 @@ import DenotTransformers.SymTransformer
 import Phases.Phase
 import Contexts.Context
 import SymDenotations.SymDenotation
-import TreeTransforms.TreeTransform
+import TreeTransforms.MiniPhaseTransform
 import Flags.Local
 
 /** Widens all private[this] and protected[this] qualifiers to just private/protected */
-class ElimLocals extends TreeTransform with SymTransformer { thisTransformer =>
-  override def name = "elimlocals"
+class ElimLocals extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+  override def phaseName = "elimLocals"
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context) =
     dropLocal(ref)

src/dotty/tools/dotc/Flatten.scala

@@ -0,0 +1,15 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Phases.Phase
+import Contexts.Context
+import SymDenotations.SymDenotation
+import TreeTransforms.MiniPhaseTransform
+
+class Flatten extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+  override def phaseName = "flatten"
+
+  def transformSym(ref: SymDenotation)(implicit ctx: Context) = ???
+}

src/dotty/tools/dotc/Run.scala

@@ -37,17 +37,18 @@ class Run(comp: Compiler)(implicit ctx: Context) {
       val phasesToRun = ctx.allPhases.init
         .takeWhile(!stoppedBefore(_))
         .filterNot(ctx.settings.Yskip.value.containsPhase(_))
-      for (phase <- phasesToRun) {
+      for (phase <- phasesToRun)
         if (!ctx.reporter.hasErrors) {
           phase.runOn(units)
           def foreachUnit(op: Context => Unit)(implicit ctx: Context): Unit =
             for (unit <- units) op(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
           if (ctx.settings.Xprint.value.containsPhase(phase))
             foreachUnit(printTree)
-          if (ctx.settings.Ycheck.value.containsPhase(phase) && !ctx.reporter.hasErrors)
-            foreachUnit(TreeChecker.check)
+          if (ctx.settings.Ycheck.value.containsPhase(phase) && !ctx.reporter.hasErrors) {
+            assert(phase.isCheckable, s"phase $phase is not checkable")
+            foreachUnit(TreeChecker.check(phasesToRun, _))
+          }
         }
-      }
     }
   }