retronym
diff --git a/‎src/compiler/scala/tools/nsc/Global.scala
+11-2 b/‎src/compiler/scala/tools/nsc/Global.scala
+11-2
diff --git a/‎src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+1-1 b/‎src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+1-1
diff --git a/‎src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+1-1 b/‎src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+1-1
diff --git a/‎src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+28-11 b/‎src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+28-11
diff --git a/‎src/compiler/scala/tools/nsc/transform/Constructors.scala
+4-2 b/‎src/compiler/scala/tools/nsc/transform/Constructors.scala
+4-2
@@ -461,10 +461,18 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val runsRightAfter = None
   } with ExtensionMethods
 
+  // phaseName = "fields"
+  object fields extends {
+    val global: Global.this.type = Global.this
+    // somewhere between typers, before erasure (so we get bridges for getters) and pickler (separate compilation of trait with fields and subclass)
+    val runsAfter = List("extmethods")
+    val runsRightAfter = None
+  } with Fields
+
   // phaseName = "pickler"
   object pickler extends {
     val global: Global.this.type = Global.this
-    val runsAfter = List("extmethods")
+    val runsAfter = List("fields")
     val runsRightAfter = None
   } with Pickler
 
@@ -608,7 +616,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
    *  This implementation creates a description map at the same time.
    */
   protected def computeInternalPhases(): Unit = {
-    // Note: this fits -Xshow-phases into 80 column width, which it is
+    // Note: this fits -Xshow-phases into 80 column width, which is
     // desirable to preserve.
     val phs = List(
       syntaxAnalyzer          -> "parse source into ASTs, perform simple desugaring",
@@ -618,6 +626,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       patmat                  -> "translate match expressions",
       superAccessors          -> "add super accessors in traits and nested classes",
       extensionMethods        -> "add extension methods for inline classes",
+      fields                  -> "synthesize accessors and fields",
       pickler                 -> "serialize symbol tables",
       refChecks               -> "reference/override checking, translate nested objects",
       uncurry                 -> "uncurry, translate function values to anonymous classes",
 
@@ -161,7 +161,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
     def enclosingMethod(sym: Symbol): Option[Symbol] = {
       if (sym.isClass || sym == NoSymbol) None
-      else if (sym.isMethod) {
+      else if (sym.isMethod && !sym.isGetter) {
         if (doesNotExist(sym)) None else Some(sym)
       }
       else enclosingMethod(nextEnclosing(sym))
 
@@ -665,7 +665,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym))
         && !sym.enclClass.isInterface
         && !sym.isClassConstructor
-        && !sym.isMutable // lazy vals and vars both
+        && (!sym.isMutable || nme.isTraitSetterName(sym.name)) // lazy vals and vars and their setters cannot be final, but trait setters are
       )
 
     // Primitives are "abstract final" to prohibit instantiation
 
@@ -58,6 +58,9 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
   def needsImplMethod(sym: Symbol) = (
        sym.isMethod
     && isInterfaceMember(sym)
+       // SYNTHESIZE_IMPL_IN_SUBCLASS accessors are mixed in by the fields phase, but others should be treated as regulars methods
+       // (this will eventually include constant-typed getters, as they can be fully implemented in the interface)
+    && (!(sym hasFlag ACCESSOR) || sym.isLazy || !(sym hasFlag SYNTHESIZE_IMPL_IN_SUBCLASS))
     && (!sym.hasFlag(DEFERRED | SUPERACCESSOR) || (sym hasFlag lateDEFERRED))
   )
 
@@ -243,13 +246,25 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
   }
 
   private def isInterfaceTree(tree: Tree) = tree.isDef && isInterfaceMember(tree.symbol)
+  private def isMemoizedTraitGetter(tree: Tree) = (tree.symbol hasFlag SYNTHESIZE_IMPL_IN_SUBCLASS) && tree.symbol.isGetter && !tree.symbol.info.resultType.isInstanceOf[ConstantType]
 
-  private def deriveMemberForImplClass(tree: Tree): Tree  =
-    if (isInterfaceTree(tree)) if (needsImplMethod(tree.symbol)) implMethodDef(tree)            else EmptyTree
+  private def mkAssign(clazz: Symbol, assignSym: Symbol, rhs: Tree): Tree = {
+    val qual = Select(This(clazz), assignSym)
+    if (assignSym.isSetter) Apply(qual, List(rhs))
+    else Assign(qual, rhs)
+  }
+
+  private def deriveMemberForImplClass(clazz: Symbol, iface: Symbol, exprOwner: Symbol)(tree: Tree): Tree  =
+    if (isInterfaceTree(tree))
+      if (needsImplMethod(tree.symbol)) implMethodDef(tree)
+      else if (isMemoizedTraitGetter(tree)) mkAssign(clazz, tree.symbol.setterIn(iface), tree.asInstanceOf[DefDef].rhs.changeOwner(tree.symbol -> exprOwner))
+      else EmptyTree
     else tree
 
   private def deriveMemberForInterface(tree: Tree): Tree =
-    if (isInterfaceTree(tree)) if (needsImplMethod(tree.symbol)) DefDef(tree.symbol, EmptyTree) else tree
+    if (isInterfaceTree(tree))
+      if (needsImplMethod(tree.symbol) || isMemoizedTraitGetter(tree)) DefDef(tree.symbol, EmptyTree) // TODO: use deriveDefDef(tree)(_ => EmptyTree) ?
+      else tree
     else EmptyTree
 
   private def ifaceTemplate(templ: Template): Template =
@@ -282,20 +297,22 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
     if (treeInfo.firstConstructor(stats) != EmptyTree) stats
     else DefDef(clazz.primaryConstructor, Block(List(), Literal(Constant(())))) :: stats
 
-  private def implTemplate(clazz: Symbol, templ: Template): Template = atPos(templ.pos) {
-    val templ1 = (
-      Template(templ.parents, noSelfType, addMixinConstructorDef(clazz, templ.body map deriveMemberForImplClass))
-        setSymbol clazz.newLocalDummy(templ.pos)
-    )
-    templ1.changeOwner(templ.symbol.owner -> clazz, templ.symbol -> templ1.symbol)
-    templ1
+  private def implTemplate(clazz: Symbol, iface: ClassDef): Template = atPos(iface.impl.pos) {
+    val templ     = iface.impl
+    val exprOwner = clazz.newLocalDummy(templ.pos)
+    val derivedImplClassMembers = templ.body map deriveMemberForImplClass(clazz, iface.symbol, exprOwner)
+    val templWithMixedinMembers = Template(templ.parents, noSelfType, addMixinConstructorDef(clazz, derivedImplClassMembers))
+
+    templWithMixedinMembers setSymbol exprOwner
+    templWithMixedinMembers changeOwner (templ.symbol.owner -> clazz, templ.symbol -> exprOwner)
+    templWithMixedinMembers
   }
 
   def implClassDefs(trees: List[Tree]): List[Tree] = {
     trees collect {
       case cd: ClassDef if cd.symbol.needsImplClass =>
         val clazz = implClass(cd.symbol).initialize
-        ClassDef(clazz, implTemplate(clazz, cd.impl))
+        ClassDef(clazz, implTemplate(clazz, cd))
     }
   }
 
 
@@ -631,7 +631,9 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           // The primary constructor is dealt with separately (we're massaging it here).
           case _: DefDef if statSym.isPrimaryConstructor => ()
           case _: DefDef if statSym.isConstructor => auxConstructorBuf += stat
-          case _: DefDef => defBuf += stat
+          case stat: DefDef =>
+              defBuf += stat
+
 
           // If a val needs a field, an empty valdef goes into the template.
           // Except for lazy and ConstantTyped vals, the field is initialized by an assignment in:
@@ -641,7 +643,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           case ValDef(mods, _, _, rhs) =>
             if (rhs ne EmptyTree) {
               val emitField = memoizeValue(statSym)
-              moveEffectToCtor(mods, rhs, if (emitField) statSym else NoSymbol)
+              moveEffectToCtor(mods, rhs, if (emitField) statSym else NoSymbol) // TODO: ever NoSymbol?
               if (emitField) defBuf += deriveValDef(stat)(_ => EmptyTree)
             } else defBuf += stat
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {`
`161`	`161`
`162`	`162`	`def enclosingMethod(sym: Symbol): Option[Symbol] = {`
`163`	`163`	`if (sym.isClass \|\| sym == NoSymbol) None`
`164`		`- else if (sym.isMethod) {`
	`164`	`+ else if (sym.isMethod && !sym.isGetter) {`
`165`	`165`	`if (doesNotExist(sym)) None else Some(sym)`
`166`	`166`	`}`
`167`	`167`	`else enclosingMethod(nextEnclosing(sym))`
Original file line number	Diff line number	Diff line change
`@@ -665,7 +665,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {`
`665`	`665`	`(((sym.rawflags & symtab.Flags.FINAL) != 0) \|\| isTopLevelModuleClass(sym))`
`666`	`666`	`&& !sym.enclClass.isInterface`
`667`	`667`	`&& !sym.isClassConstructor`
`668`		`- && !sym.isMutable // lazy vals and vars both`
	`668`	`+ && (!sym.isMutable \|\| nme.isTraitSetterName(sym.name)) // lazy vals and vars and their setters cannot be final, but trait setters are`
`669`	`669`	`)`
`670`	`670`
`671`	`671`	`// Primitives are "abstract final" to prohibit instantiation`