minimal working init calls

test/files/trait-defaults/fields compiles and runs:
x
y
z
abstract
public
protected
abstract protected
private
private[this]
abstract
public
protected
abstract protected
private
private[this]
abstract
public
protected
abstract protected
private
private[this]

Author: adriaanm

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -397,6 +397,32 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
   //  TODO in namers: if(sym.owner.isTrait && sym.isSetter && !sym.isDeferred) sym.addAnnotation(TraitSetterAnnotationClass)
 
+    /** Add calls to supermixin constructors
+      *    `super[mix].$init$()`
+      *  to tree, which is assumed to be the body of a constructor of class clazz.
+      */
+    private def addMixinConstructorCalls(clazz: Symbol)(tree: Tree): Tree = {
+      def mixinConstructorCall(`trait`: Symbol): Tree = typedPos(tree.pos) {
+        Apply(Select(This(clazz), `trait`.primaryConstructor), List())
+      }
+      val mixinConstructorCalls = clazz.mixinClasses.filter(_.isTrait).map(mixinConstructorCall).reverse
+      tree match {
+          // TODO???
+//        case Block(Nil, expr) =>
+//          // AnyVal constructor - have to provide a real body so the
+//          // jvm doesn't throw a VerifyError. But we can't add the
+//          // body until now, because the typer knows that Any has no
+//          // constructor and won't accept a call to super.init.
+//          assert((clazz isSubClass AnyValClass) || clazz.info.parents.isEmpty, clazz)
+//          Block(List(Apply(gen.mkSuperInitCall, Nil)), expr)
+
+        case Block(stats, expr) =>
+          // needs `hasSymbolField` check because `supercall` could be a block (named / default args)
+          val (presuper, supercall :: rest) = stats span (t => t.hasSymbolWhich(_ hasFlag PRESUPER))
+          treeCopy.Block(tree, presuper ::: (supercall :: mixinConstructorCalls ::: rest), expr)
+      }
+    }
+
     /** The first transform; called in a pre-order traversal at phase mixin
       * (that is, every node is processed before its children).
       *
@@ -405,13 +431,18 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
     private def preTransform(tree: Tree): Tree = {
       val sym = tree.symbol
       tree match {
+        case DefDef(_,_,_,_,_,_) if sym.isClassConstructor && sym.isPrimaryConstructor && sym.owner != ArrayClass =>
+          deriveDefDef(tree)(addMixinConstructorCalls(sym.owner))
+
         case Template(parents, self, body) if doImplementTraitMembers(currentOwner) =>
           localTyper = erasure.newTyper(rootContext.make(tree, currentOwner))
           exitingMixin(currentOwner.owner.info)//todo: needed?
 
           implementTraitMembers(currentOwner, unit)
 
           tree
+
+
         case _ =>
           tree
       }
@@ -964,12 +995,13 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
             // add superaccessors
             addDefDef(sym)
           }
-          else {
-            // add forwarders
-            assert(sym.alias != NoSymbol, sym)
-            // debuglog("New forwarder: " + sym.defString + " => " + sym.alias.defString)
-            if (!sym.isMacro) addDefDef(sym, Apply(staticRef(sym.alias), gen.mkAttributedThis(clazz) :: sym.paramss.head.map(Ident)))
-          }
+          // TODO: override methods to encode linearization order
+//          else {
+//            // add forwarders
+//            assert(sym.alias != NoSymbol, sym)
+//            // debuglog("New forwarder: " + sym.defString + " => " + sym.alias.defString)
+//            if (!sym.isMacro) addDefDef(sym, Apply(staticRef(sym.alias), gen.mkAttributedThis(clazz) :: sym.paramss.head.map(Ident)))
+//          }
         }
       }
       stats1 = add(stats1, newDefs.toList)

src/reflect/scala/reflect/internal/Symbols.scala

@@ -3265,7 +3265,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     override def existentialBound = GenPolyType(this.typeParams, TypeBounds.upper(this.classBound))
 
-    def primaryConstructorName = if (this hasFlag TRAIT | IMPLCLASS) nme.MIXIN_CONSTRUCTOR else nme.CONSTRUCTOR
+    def primaryConstructorName = if (this hasFlag TRAIT) nme.MIXIN_CONSTRUCTOR else nme.CONSTRUCTOR
 
     override def primaryConstructor = {
       val c = info decl primaryConstructorName

test/files/trait-defaults/fields.scala

@@ -1,10 +1,18 @@
+trait Empty {
+  println("a")
+}
+
+class CE extends Empty
+
 trait T {
   val abs: String
   protected val protabs: String
   val pub = "public"
   protected val prot = "protected"
   private val privvy = "private"
   private[this] val privateThis = "private[this]"
+  // TODO:
+  // final val const = "const"
 
   trait Nested { println(abs + privateThis) }
 
@@ -36,9 +44,18 @@ trait T {
   }
 }
 
-class C extends T {
+class C extends AnyRef with T {
+  println("x")
   val abs = "abstract"
+  println("y")
   val protabs = "abstract protected"
+  final val const = "const"
+  println("z")
 }
 
-object Test extends C with App
+object Test extends C {
+  def main(args: Array[String]): Unit = {
+  NO
+  new NT{}
+  new NC
+}}