Maintaining owners during transformations

The transformation framework needed to be changed so that contexts passed to
transformations have correct owner chains. These owner chins are demanded by
the Splitter phase.

Note: I eliminated the contexts array in TransformInfo because it interfered
with the owner computations. Generally, caching contexts with some phase is best
done in Contexts, because withPhase is also used heavily in othre code, not just in
Transformers.

New phase: Splitter

When it is complete, it will make sure that every term Ident and Select node
carries a symbol. Right now, all it does is coverting self reference idents to
"this"-nodes.

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -21,7 +21,7 @@ class Compiler {
     List(
       List(new FrontEnd),
       List(new LazyValsCreateCompanionObjects, new PatternMatcher),    //force separataion between lazyVals and LVCreateCO
-      List(new LazyValTranformContext().transformer, new TypeTestsCasts),
+      List(new LazyValTranformContext().transformer, new Splitter, new TypeTestsCasts),
       List(new Erasure),
       List(new UncurryTreeTransform)
     )

src/dotty/tools/dotc/core/Contexts.scala

@@ -277,6 +277,9 @@ object Contexts {
       newctx.asInstanceOf[FreshContext]
     }
 
+    final def withOwner(owner: Symbol): Context =
+      if (owner ne this.owner) fresh.setOwner(owner) else this
+
     final def withMode(mode: Mode): Context =
       if (mode != this.mode) fresh.setMode(mode) else this
 

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

@@ -48,8 +48,8 @@ object PostTyperTransformers {
       reorder0(stats)
     }
 
-    override def transformStats(trees: List[tpd.Tree], info: TransformerInfo, current: Int)(implicit ctx: Context): List[tpd.Tree] =
-      super.transformStats(reorder(trees)(ctx, info), info, current)
+    override def transformStats(trees: List[tpd.Tree], exprOwner: Symbol, info: TransformerInfo, current: Int)(implicit ctx: Context): List[tpd.Tree] =
+      super.transformStats(reorder(trees)(ctx, info), exprOwner, info, current)
 
     override def transform(tree: tpd.Tree, info: TransformerInfo, cur: Int)(implicit ctx: Context): tpd.Tree = tree match {
       case tree: Import => EmptyTree

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

@@ -0,0 +1,27 @@
+package dotty.tools.dotc
+package transform
+
+import TreeTransforms._
+import ast.Trees._
+import core.Contexts._
+import core.Types._
+
+/** This transform makes usre every identifier and select node
+ *  carries a symbol. To do this, certain qualifiers with a union type
+ *  have to be "splitted" with a type test.
+ *
+ *  For now, only self references are treated.
+ */
+class Splitter extends TreeTransform {
+  import ast.tpd._
+
+  override def name: String = "splitter"
+
+  /** Replace self referencing idents with ThisTypes. */
+  override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = tree.tpe match {
+    case ThisType(cls) =>
+      println(s"owner = ${ctx.owner}, context = ${ctx}")
+      This(cls) withPos tree.pos
+    case _ => tree
+  }
+}