Nuke trait implementation classes

  - Leave the members in the trait instead (these will be emitted as
    default methods in the interface)
  - Add the trait mixin constructor to the interface, rather than
    the impl class
  - Change the invocation of the mixin constructor to use an
    invokespecial. This is encoded with the AST:
    `Apply(Select(Super(_, _), mixinConstructor)))`

This compiles a simple example:

```
trait T {
  def m = 42
}

class C extends T

object Test {
  def main(args: Array[String]): Unit = {
    assert(new C().m == 42)
  }
}
```

To:

```
Compiled from "test.scala"
public interface T {
  public void $init$();
    Code:
       0: return

  public int m();
    Code:
       0: bipush        42
       2: ireturn
}
Compiled from "test.scala"
public class C implements T {
  public C();
    Code:
       0: aload_0
       1: invokespecial #14                 // Method java/lang/Object."<init>":()V
       4: aload_0
       5: invokespecial #17                 // Method T.$init$:()V
       8: return
}
```

We need to re-enable the "trait forwarder" method in `C`. Although
in this example we can rely on Java's method binding rules to call
the right `T.m`, in the general case when we have diamond inheritance
we need to encode Scala's linearization rules. Adriaan explained this
in some detail here:

  https://groups.google.com/forum/#!topic/scala-internals/KnxCpSryrSM

For now I'm just starting with the happy path of public defs.
Fields, non-public members, will also need a good helping of finesse.
And modules, lazies.

Author: retronym

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

@@ -211,8 +211,8 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
 
   def transformMixinInfo(tp: Type): Type = tp match {
     case ClassInfoType(parents, decls, clazz) if clazz.isPackageClass || !clazz.isJavaDefined =>
-      if (clazz.needsImplClass)
-        implClass(clazz setFlag lateINTERFACE) // generate an impl class
+//      if (clazz.needsImplClass)
+//        implClass(clazz setFlag lateINTERFACE) // generate an impl class
 
       val parents1 = parents match {
         case Nil      => Nil
@@ -223,10 +223,13 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
       }
       val decls1 = scopeTransform(clazz)(
         decls filter (sym =>
-          if (clazz.isInterface) isInterfaceMember(sym)
+          if (clazz.isInterface) {
+            isInterfaceMember(sym) && { sym.setFlag(Flags.JAVA_DEFAULTMETHOD); true }
+          }
           else sym.isClass || sym.isTerm
         )
       )
+      if (clazz.isTrait) decls1.enter(decls enter (clazz.newMethod(nme.MIXIN_CONSTRUCTOR, clazz.pos, Flags.PROTECTED | Flags.ARTIFACT) setInfo MethodType(Nil, UnitTpe)))
       ClassInfoType(parents1, decls1, clazz)
     case _ =>
       tp
@@ -321,13 +324,13 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
    *  to tree, which is assumed to be the body of a constructor of class clazz.
    */
   private def addMixinConstructorCalls(tree: Tree, clazz: Symbol): Tree = {
-    def mixinConstructorCall(impl: Symbol): Tree = atPos(tree.pos) {
-      Apply(Select(This(clazz), impl.primaryConstructor), List())
+    def mixinConstructorCall(mc: Symbol): Tree = atPos(tree.pos) {
+      Apply(Select(Super(clazz, tpnme.EMPTY), mc.primaryConstructor), List())
     }
     val mixinConstructorCalls: List[Tree] = {
       for (mc <- clazz.mixinClasses.reverse
-           if mc.hasFlag(lateINTERFACE))
-      yield mixinConstructorCall(implClass(mc))
+           if mc.isTrait)
+      yield mixinConstructorCall(mc)
     }
     tree match {
       case Block(Nil, expr) =>
@@ -352,36 +355,36 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
     override def transform(tree: Tree): Tree = {
       val sym = tree.symbol
       val tree1 = tree match {
-        case ClassDef(mods, _, _, impl) if sym.needsImplClass =>
-          implClass(sym).initialize // to force lateDEFERRED flags
-          copyClassDef(tree)(mods = mods | INTERFACE, impl = ifaceTemplate(impl))
+//        case ClassDef(mods, _, _, impl) if sym.needsImplClass =>
+//          implClass(sym).initialize // to force lateDEFERRED flags
+//          copyClassDef(tree)(mods = mods | INTERFACE, impl = ifaceTemplate(impl))
         case DefDef(_,_,_,_,_,_) if sym.isClassConstructor && sym.isPrimaryConstructor && sym.owner != ArrayClass =>
           deriveDefDef(tree)(addMixinConstructorCalls(_, sym.owner)) // (3)
         case Template(parents, self, body) =>
           val parents1 = sym.owner.info.parents map (t => TypeTree(t) setPos tree.pos)
           treeCopy.Template(tree, parents1, noSelfType, body)
-        case This(_) if sym.needsImplClass =>
-          val impl = implClass(sym)
-          var owner = currentOwner
-          while (owner != sym && owner != impl) owner = owner.owner;
-          if (owner == impl) This(impl) setPos tree.pos
-          else tree
-        //TODO what about this commented out code?
-/* !!!
-        case Super(qual, mix) =>
-          val mix1 = mix
-            if (mix == tpnme.EMPTY) mix
-            else {
-              val ps = enteringErasure {
-                sym.info.parents dropWhile (p => p.symbol.name != mix)
-              }
-              assert(!ps.isEmpty, tree);
-              if (ps.head.symbol.needsImplClass) implClass(ps.head.symbol).name
-              else mix
-            }
-          if (sym.needsImplClass) Super(implClass(sym), mix1) setPos tree.pos
-          else treeCopy.Super(tree, qual, mix1)
-*/
+//        case This(_) if sym.needsImplClass =>
+//          val impl = implClass(sym)
+//          var owner = currentOwner
+//          while (owner != sym && owner != impl) owner = owner.owner;
+//          if (owner == impl) This(impl) setPos tree.pos
+//          else tree
+//        //TODO what about this commented out code?
+///* !!!
+//        case Super(qual, mix) =>
+//          val mix1 = mix
+//            if (mix == tpnme.EMPTY) mix
+//            else {
+//              val ps = enteringErasure {
+//                sym.info.parents dropWhile (p => p.symbol.name != mix)
+//              }
+//              assert(!ps.isEmpty, tree);
+//              if (ps.head.symbol.needsImplClass) implClass(ps.head.symbol).name
+//              else mix
+//            }
+//          if (sym.needsImplClass) Super(implClass(sym), mix1) setPos tree.pos
+//          else treeCopy.Super(tree, qual, mix1)
+//*/
         case _ =>
           tree
       }

src/reflect/scala/reflect/internal/HasFlags.scala

@@ -99,7 +99,7 @@ trait HasFlags {
   def isFinal               = hasFlag(FINAL)
   def isArtifact            = hasFlag(ARTIFACT)
   def isImplicit            = hasFlag(IMPLICIT)
-  def isInterface           = hasFlag(INTERFACE)
+  def isInterface           = hasFlag(INTERFACE) || isTrait
   def isJavaDefined         = hasFlag(JAVA)
   def isLabel               = hasAllFlags(LABEL | METHOD) && !hasAccessorFlag
   def isLazy                = hasFlag(LAZY)