New Mixin scheme.

Split into two phases, ResolveSuper before Erasure and Mixin after. Likewise GettersSetters
is split into Getters and Memoize.

All tests pass, except two tests fail when compiled twice. Will investigate next why.

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -50,10 +50,12 @@ class Compiler {
            new Splitter),
       List(new ElimByName,
            new InterceptedMethods,
-           new Literalize),
-      List(new Mixin),
-      List(new GettersSetters),
+           new Literalize,
+           new Getters),
+      List(new ResolveSuper),
       List(new Erasure),
+      List(new Mixin),
+      List(new Memoize),
       List(new CapturedVars,
            new Constructors),
       List(new LambdaLift,

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

@@ -0,0 +1,67 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Contexts.Context
+import SymDenotations.SymDenotation
+import Types._
+import Symbols._
+import SymUtils._
+import Constants._
+import TreeTransforms._
+import Flags._
+import Decorators._
+
+/** Performs the following rewritings for fields of a class:
+ *
+ *    <mods> val x: T = e
+ *      -->  <mods> <stable> def x: T = e
+ *    <mods> var x: T = e
+ *      -->  <mods> def x: T = e
+ *
+ *    <mods> val x: T
+ *      -->  <mods> <stable> def x: T
+ *
+ *    <mods> var x: T
+ *      -->  <mods> 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 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 =
+      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
+      d.copySymDenotation(
+        initFlags = d.flags | maybeStable | AccessorCreationFlags,
+        info = ExprType(d.info))
+    }
+    else d
+  }
+  private val NoGetterNeeded = Method | Param | JavaDefined | JavaStatic
+
+  override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree =
+    if (tree.symbol is Method) DefDef(tree.symbol.asTerm, tree.rhs) 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
+}

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

@@ -0,0 +1,68 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers._
+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._
+
+/** Provides the implementations of all getters and setters, introducing
+ *  fields to hold the value accessed by them.
+ *  TODO: Make LazyVals a part of this phase?
+ *
+ *    <accessor> <stable> <mods> def x(): T = e
+ *      -->  private val x: T = e
+ *           <accessor> <stable> <mods> def x(): T = x
+ *
+ *    <accessor> <mods> def x(): T = e
+ *      -->  private var x: T = e
+ *           <accessor> <mods> def x(): T = x
+ *
+ *    <accessor> <mods> def x_=(y: T): Unit = ()
+ *      --> <accessor> <mods> def x_=(y: T): Unit = x = y
+ */
+ class Memoize extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName = "memoize"
+  override def treeTransformPhase = thisTransform.next
+
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val sym = tree.symbol
+    if (sym.is(Accessor, butNot = NoFieldNeeded))
+      if (sym.isGetter) {
+        val maybeMutable = if (sym is Stable) EmptyFlags else Mutable
+        println(i"add field for $sym")
+        val field = ctx.newSymbol(
+          owner = ctx.owner,
+          name = sym.name.asTermName.fieldName,
+          flags = Private | maybeMutable,
+          info = sym.info.resultType,
+          coord = tree.pos).enteredAfter(thisTransform)
+        var fieldInit = tree.rhs.changeOwner(sym, field)
+        val fieldDef = ValDef(field, fieldInit)
+        val getterDef = cpy.DefDef(tree)(rhs = ref(field))
+        Thicket(fieldDef, getterDef)
+      }
+      else if (sym.isSetter) {
+        val Literal(Constant(())) = tree.rhs
+        assert(sym.field.exists, i"no field for ${sym.showLocated} in ${sym.owner.info.decls.toList.map{_.showDcl}}%; %")
+        val initializer = Assign(ref(sym.field), ref(tree.vparamss.head.head.symbol))
+        cpy.DefDef(tree)(rhs = initializer)
+      }
+      else tree // curiously, some accessors from Scala2 have ' ' suffixes. They count as
+                // neither getters nor setters
+    else tree
+  }
+  private val NoFieldNeeded  = Lazy | Deferred | ParamAccessor
+}