Support trait fields in the post-implclass world

```
⚡ cat sandbox/test.scala
trait T {
  def m = v
  val v = 42
}

class C extends T

object Test {
  def main(args: Array[String]): Unit = {
    assert(new C().m == 42)
  }
}
/code/scala on topic/nuke-impl-classes*
⚡ qscalac -Xprint:fields,constructors,erasure,mixin sandbox/test.scala  && qscala Test
[[syntax trees at end of                    fields]] // test.scala
package <empty> {
  abstract <sub_synth> trait T extends scala.AnyRef {
    <accessor> <sub_synth> def T$_setter_$v_=(x$1: Int): Unit;
    def /*T*/$init$(): Unit = {
      ()
    };
    def m: Int = T.this.v;
    <stable> <accessor> <sub_synth> def v: Int = 42
  };
  <sub_synth> class C extends AnyRef with T {
    override <stable> <accessor> def v: Int = C.this.v;
    private[this] val v: Int = _;
    override <accessor> def T$_setter_$v_=(x$1: Int): Unit = C.this.v = x$1;
    def <init>(): C = {
      C.super.<init>();
      ()
    }
  };
  object Test extends scala.AnyRef {
    def <init>(): Test.type = {
      Test.super.<init>();
      ()
    };
    def main(args: Array[String]): Unit = scala.Predef.assert(new C().m.==(42))
  }
}

[[syntax trees at end of                   erasure]] // test.scala
package <empty> {
  abstract <sub_synth> trait T extends Object {
    <accessor> <defaultmethod> <sub_synth> def T$_setter_$v_=(x$1: Int): Unit;
    def /*T*/$init$(): Unit = {
      ()
    };
    <defaultmethod> def m(): Int = T.this.v();
    <stable> <accessor> <defaultmethod> <sub_synth> def v(): Int = 42
  };
  <sub_synth> class C extends Object with T {
    override <stable> <accessor> def v(): Int = C.this.v;
    private[this] val v: Int = _;
    override <accessor> def T$_setter_$v_=(x$1: Int): Unit = C.this.v = x$1;
    def <init>(): C = {
      C.super.<init>();
      C.super./*T*/$init$();
      ()
    }
  };
  <sub_synth> object Test extends Object {
    def <init>(): Test.type = {
      Test.super.<init>();
      ()
    };
    def main(args: Array[String]): Unit = scala.Predef.assert(new C().m().==(42))
  }
}

[[syntax trees at end of              constructors]] // test.scala
package <empty> {
  abstract <sub_synth> trait T extends Object {
    <accessor> <defaultmethod> <sub_synth> def T$_setter_$v_=(x$1: Int): Unit;
    <defaultmethod> def m(): Int = T.this.v();
    <stable> <accessor> <defaultmethod> <sub_synth> def v(): Int;
    def /*T*/$init$(): Unit = {
      T.this.T$_setter_$v_=(42);
      ()
    }
  };
  <sub_synth> class C extends Object with T {
    override <stable> <accessor> def v(): Int = C.this.v;
    private[this] val v: Int = _;
    override <accessor> def T$_setter_$v_=(x$1: Int): Unit = C.this.v = x$1;
    def <init>(): C = {
      C.super.<init>();
      C.super./*T*/$init$();
      ()
    }
  };
  <sub_synth> object Test extends Object {
    def main(args: Array[String]): Unit = scala.Predef.assert(new C().m().==(42));
    def <init>(): Test.type = {
      Test.super.<init>();
      ()
    }
  }
}

[[syntax trees at end of                     mixin]] // test.scala: tree is unchanged since constructors
/code/scala on topic/nuke-impl-classes*
⚡ javap -c -classpath . T C
Compiled from "test.scala"
public interface T {
  public abstract void T$_setter_$v_$eq(int);

  public int m();
    Code:
       0: aload_0
       1: invokeinterface #15,  1           // InterfaceMethod v:()I
       6: ireturn

  public abstract int v();

  public void $init$();
    Code:
       0: aload_0
       1: bipush        42
       3: invokeinterface #21,  2           // InterfaceMethod T$_setter_$v_$eq:(I)V
       8: return
}
Compiled from "test.scala"
public class C implements T {
  public int v();
    Code:
       0: aload_0
       1: getfield      #15                 // Field v:I
       4: ireturn

  public void T$_setter_$v_$eq(int);
    Code:
       0: aload_0
       1: iload_1
       2: putfield      #15                 // Field v:I
       5: return

  public C();
    Code:
       0: aload_0
       1: invokespecial #24                 // Method java/lang/Object."<init>":()V
       4: aload_0
       5: invokespecial #27                 // Method T.$init$:()V
       8: return
}
```

Author: retronym

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

@@ -73,7 +73,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
 
     override def transform(tree: Tree): Tree = {
       tree match {
-        case cd @ ClassDef(mods0, name0, tparams0, impl0) if !cd.symbol.isInterface && !isPrimitiveValueClass(cd.symbol) =>
+        case cd @ ClassDef(mods0, name0, tparams0, impl0) if !isPrimitiveValueClass(cd.symbol) =>
           if(cd.symbol eq AnyValClass) {
             cd
           }
@@ -456,7 +456,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
 
     // find and dissect primary constructor
     private val (primaryConstr, _primaryConstrParams, primaryConstrBody) = stats collectFirst {
-      case dd@DefDef(_, _, _, vps :: Nil, _, rhs: Block) if dd.symbol.isPrimaryConstructor => (dd, vps map (_.symbol), rhs)
+      case dd@DefDef(_, _, _, vps :: Nil, _, rhs: Block) if dd.symbol.isPrimaryConstructor || dd.symbol.isMixinConstructor => (dd, vps map (_.symbol), rhs)
     } getOrElse {
       abort("no constructor in template: impl = " + impl)
     }
@@ -545,10 +545,14 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     }
 
     // Create an assignment to class field `to` with rhs `from`
-    def mkAssign(to: Symbol, from: Tree): Tree =
-      localTyper.typedPos(to.pos) {
-        Assign(Select(This(clazz), to), from)
-      }
+    def mkAssign(to: Symbol, from: Tree): Tree = {
+      val tree = if (to.owner.isTrait) {
+        val setter = to.setterIn(to.owner)
+        gen.mkMethodCall(This(to.owner), setter, Nil, from :: Nil)
+      } else Assign(Select(This(clazz), to), from)
+
+      localTyper.typedPos(to.pos)(tree)
+    }
 
     // Create code to copy parameter to parameter accessor field.
     // If parameter is $outer, check that it is not null so that we NPE
@@ -629,8 +633,12 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           // Triage methods -- they all end up in the template --
           // regular ones go to `defBuf`, secondary contructors go to `auxConstructorBuf`.
           // The primary constructor is dealt with separately (we're massaging it here).
-          case _: DefDef if statSym.isPrimaryConstructor => ()
+          case _: DefDef if statSym.isPrimaryConstructor || statSym.isMixinConstructor => ()
           case _: DefDef if statSym.isConstructor => auxConstructorBuf += stat
+          case stat: DefDef if stat.symbol.owner.isTrait && stat.symbol.hasAllFlags(STABLE | ACCESSOR) && stat.rhs != EmptyTree =>
+            val emitField = memoizeValue(statSym)
+            moveEffectToCtor(stat.mods, stat.rhs, if (emitField) statSym else NoSymbol) // TODO: ever NoSymbol?
+            defBuf += deriveDefDef(stat)(_ => EmptyTree)
           case stat: DefDef =>
               defBuf += stat
 

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

@@ -433,7 +433,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
 
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] =
-      if (!currentOwner.isClass || currentOwner.isPackageClass || currentOwner.isInterface) super.transformStats(stats, exprOwner)
+      if (!currentOwner.isClass || currentOwner.isPackageClass || currentOwner.hasFlag(INTERFACE)) super.transformStats(stats, exprOwner)
       else afterOwnPhase {
         fieldsAndAccessors(exprOwner) ++ (stats flatMap transformStat(exprOwner)) // TODO use thicket encoding of multi-tree transformStat?
       }