Mixin fields with trait setters shouldn't be JVM final

Before:

```
scala> trait T { val foo = 24 }; class C extends T
defined trait T
defined class C

scala> :javap -private -c C
Compiled from "<console>"
public class $line3.$read$$iw$$iw$C implements $line3.$read$$iw$$iw$T {
  private final int foo;

  public int foo();
    Code:
       0: aload_0
       1: getfield      #21                 // Field foo:I
       4: ireturn

  public void $line3$$read$$iw$$iw$T$_setter_$foo_$eq(int);
    Code:
       0: aload_0
       1: iload_1
       2: putfield      #21                 // Field foo:I
       5: return

  public $line3.$read$$iw$$iw$C();
    Code:
       0: aload_0
       1: invokespecial #30                 // Method java/lang/Object."<init>":()V
       4: aload_0
       5: invokestatic  #34                 // InterfaceMethod $line3/$read$$iw$$iw$T.$init$:(L$line3/$read$$iw$$iw$T;)V
       8: return
}
```

The assignment to the final field `foo` has always contravened the JVM spec,
and this rule is enforced for any classfiles of format 53 and higher.

After this patch:

```
scala> trait T { val foo = 24 }; class C extends T
defined trait T
defined class C

scala> :javap -private -c C
Compiled from "<console>"
public class $line3.$read$$iw$$iw$C implements $line3.$read$$iw$$iw$T {
  private int foo;

  public int foo();
    Code:
       0: aload_0
       1: getfield      #21                 // Field foo:I
       4: ireturn

  public void $line3$$read$$iw$$iw$T$_setter_$foo_$eq(int);
    Code:
       0: aload_0
       1: iload_1
       2: putfield      #21                 // Field foo:I
       5: return

  public $line3.$read$$iw$$iw$C();
    Code:
       0: aload_0
       1: invokespecial #30                 // Method java/lang/Object."<init>":()V
       4: aload_0
       5: invokestatic  #34                 // InterfaceMethod $line3/$read$$iw$$iw$T.$init$:(L$line3/$read$$iw$$iw$T;)V
       8: getstatic     #40                 // Field scala/runtime/ScalaRunTime$.MODULE$:Lscala/runtime/ScalaRunTime$;
      11: invokevirtual #43                 // Method scala/runtime/ScalaRunTime$.releaseFence:()V
      14: return
}
```

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

@@ -756,11 +756,16 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
         if (isDelayedInitSubclass && remainingConstrStats.nonEmpty) delayedInitDefsAndConstrStats(defs, remainingConstrStats)
         else (Nil, remainingConstrStats)
 
+      val fence = if (clazz.primaryConstructor.hasAttachment[ConstructorNeedsFence.type]) {
+        val tree = localTyper.typedPos(clazz.primaryConstructor.pos)(gen.mkRuntimeCall(nme.releaseFence, Nil))
+        tree :: Nil
+      } else Nil
+
       // Assemble final constructor
       val primaryConstructor = deriveDefDef(primaryConstr)(_ => {
         treeCopy.Block(
           primaryConstrBody,
-          paramInits ::: constructorPrefix ::: uptoSuperStats ::: guardSpecializedInitializer(remainingConstrStatsDelayedInit),
+          paramInits ::: constructorPrefix ::: uptoSuperStats ::: guardSpecializedInitializer(remainingConstrStatsDelayedInit) ::: fence,
           primaryConstrBody.expr)
       })
 

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

@@ -422,12 +422,12 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 //        println(s"expanded modules for $clazz: $expandedModules")
 
         // afterOwnPhase, so traits receive trait setters for vals (needs to be at finest grain to avoid looping)
-        val synthInSubclass =
+        val synthInSubclass: List[Symbol] =
           clazz.mixinClasses.flatMap(mixin => afterOwnPhase(mixin.info).decls.toList.filter(accessorImplementedInSubclass))
 
         // mixin field accessors --
         // invariant: (accessorsMaybeNeedingImpl, mixedInAccessorAndFields).zipped.forall(case (acc, clone :: _) => `clone` is clone of `acc` case _ => true)
-        val mixedInAccessorAndFields = synthInSubclass.map{ member =>
+        val mixedInAccessorAndFields: List[List[Symbol]] = synthInSubclass.map{ member =>
           def cloneAccessor() = {
             val clonedAccessor = (member cloneSymbol clazz) setPos clazz.pos
             setMixedinAccessorFlags(member, clonedAccessor)
@@ -659,9 +659,20 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
         // trait val/var setter mixed into class
         else fieldAccess(setter) match {
           case NoSymbol => EmptyTree
-          case fieldSel => afterOwnPhase { // the assign only type checks after our phase (assignment to val)
-            mkAccessor(setter)(Assign(Select(This(clazz), fieldSel), castHack(Ident(setter.firstParam), fieldSel.info)))
-          }
+          case fieldSel =>
+            if (!fieldSel.hasFlag(MUTABLE)) {
+              // If the field is mutable, it won't be final, so we can write to it in a setter.
+              // If it's not, we still need to initialize it, and make sure it's safely published.
+              // Since initialization is performed (lexically) outside of the constructor (in the trait setter),
+              // we have to make the field mutable starting with classfile format 53
+              // (it was never allowed, but the verifier enforces this now).
+              fieldSel.setFlag(MUTABLE)
+              fieldSel.owner.primaryConstructor.updateAttachment(ConstructorNeedsFence)
+            }
+
+            afterOwnPhase { // the assign only type checks after our phase (assignment to val)
+              mkAccessor(setter)(Assign(Select(This(clazz), fieldSel), castHack(Ident(setter.firstParam), fieldSel.info)))
+            }
         }
 
       def moduleAccessorBody(module: Symbol): Tree =

src/reflect/scala/reflect/internal/StdAttachments.scala

@@ -107,4 +107,6 @@ trait StdAttachments {
   case object KnownDirectSubclassesCalled extends PlainAttachment
 
   class QualTypeSymAttachment(val sym: Symbol)
+
+  case object ConstructorNeedsFence extends PlainAttachment
 }

src/reflect/scala/reflect/internal/StdNames.scala

@@ -778,6 +778,7 @@ trait StdNames {
     val productPrefix: NameType        = "productPrefix"
     val raw_ : NameType                = "raw"
     val readResolve: NameType          = "readResolve"
+    val releaseFence: NameType         = "releaseFence"
     val reify : NameType               = "reify"
     val reificationSupport : NameType  = "reificationSupport"
     val rootMirror : NameType          = "rootMirror"

src/reflect/scala/reflect/runtime/JavaUniverseForce.scala

@@ -51,6 +51,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     this.UseInvokeSpecial
     this.TypeParamVarargsAttachment
     this.KnownDirectSubclassesCalled
+    this.ConstructorNeedsFence
     this.noPrint
     this.typeDebug
     // inaccessible: this.posAssigner

test/files/run/lazy-locals-2.scala

@@ -281,8 +281,8 @@ object Test {
       lzyComputeMethods == expComputeMethods,
       s"wrong lzycompute methods. expected:\n$expComputeMethods\nfound:\n$lzyComputeMethods")
 
-    val fields = c.getClass.getDeclaredFields.toList.sortBy(_.getName).map(_.toString)
-    val expFields = List(
+    val fields: List[String] = c.getClass.getDeclaredFields.toList.sortBy(_.getName).map(_.toString)
+    val expFields = List[String](
       "private volatile byte C.bitmap$0",
       "private int C.lvl1",
       "private java.lang.String C.lvl2",
@@ -305,9 +305,22 @@ object Test {
     d.run()
 
     val dFields = d.getClass.getDeclaredFields.toList.sortBy(_.getName).map(_.toString)
-    assert(
-      dFields == expFields.map(_.replaceAll(" C.", " D.")),
-      s"wrong fields. expected:\n$expFields\nfound:\n$fields")
+    val expDFields = List[String](
+      "private volatile byte D.bitmap$0",
+      "private int D.lvl1",
+      "private java.lang.String D.lvl2",
+      "private scala.runtime.BoxedUnit D.lvl3",
+      "private int D.t1",
+      "private java.lang.String D.t2",
+      "private scala.runtime.BoxedUnit D.t3",
+      "private int D.vl1",
+      "private java.lang.String D.vl2",
+      "private scala.runtime.BoxedUnit D.vl3",
+      "private int D.vr1",
+      "private java.lang.String D.vr2",
+      "private scala.runtime.BoxedUnit D.vr3")
+    assert(dFields == expDFields,
+      s"wrong fields. expected:\n$expDFields\nfound:\n$dFields")
 
 
     val d1 = new D1

test/files/run/t10075b.check

@@ -45,9 +45,9 @@
 @RetainedAnnotation() public int TMix.lzyValGetterAnnotation()
  private int TMix.lzyValGetterAnnotation$lzycompute()
 @RetainedAnnotation() public int TMix.method()
-@RetainedAnnotation() private final int TMix.valFieldAnnotation
+@RetainedAnnotation() private int TMix.valFieldAnnotation
  public int TMix.valFieldAnnotation()
- private final int TMix.valGetterAnnotation
+ private int TMix.valGetterAnnotation
 @RetainedAnnotation() public int TMix.valGetterAnnotation()
 @RetainedAnnotation() private int TMix.varFieldAnnotation
  public int TMix.varFieldAnnotation()