fields phase

Author: adriaanm

src/compiler/scala/tools/nsc/Global.scala

@@ -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",

src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala

@@ -162,7 +162,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))

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -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

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

@@ -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))
     }
   }
 

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

@@ -359,7 +359,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       }
 
       log("merging: " + originalStats.mkString("\n") + "\nwith\n" + specializedStats.mkString("\n"))
-      val res = for (s <- originalStats; stat = s.duplicate) yield {
+      for (s <- originalStats; stat = s.duplicate) yield {
         log("merge: looking at " + stat)
         val stat1 = stat match {
           case Assign(sel @ Select(This(_), field), _) =>
@@ -389,9 +389,8 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         } else
           stat1
       }
-      if (specBuf.nonEmpty)
-        println("residual specialized constructor statements: " + specBuf)
-      res
+//      if (specBuf.nonEmpty)
+//        println("residual specialized constructor statements: " + specBuf)
     }
 
     /* Add an 'if' around the statements coming after the super constructor. This
@@ -591,7 +590,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           case ValDef(mods, name, _, _) if mods hasFlag PRESUPER =>
             // stat is the constructor-local definition of the field value
             val fields = presupers filter (_.getterName == name)
-            assert(fields.length == 1)
+            assert(fields.length == 1, s"expected exactly one field by name $name in $presupers of $clazz's early initializers")
             val to = fields.head.symbol
 
             if (memoizeValue(to)) constrStatBuf += mkAssign(to, Ident(stat.symbol))
@@ -607,9 +606,9 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         // it goes before the superclass constructor call, otherwise it goes after.
         // A lazy val's effect is not moved to the constructor, as it is delayed.
         // Returns `true` when a `ValDef` is needed.
-        def moveEffectToCtor(mods: Modifiers, rhs: Tree, memoized: Boolean): Unit = {
+        def moveEffectToCtor(mods: Modifiers, rhs: Tree, assignSym: Symbol): Unit = {
           val initializingRhs =
-            if (!memoized || statSym.isLazy) EmptyTree // not memoized, or effect delayed (for lazy val)
+            if ((assignSym eq NoSymbol) || statSym.isLazy) EmptyTree // not memoized, or effect delayed (for lazy val)
             else if (!mods.hasStaticFlag) intoConstructor(statSym, primaryConstr.symbol)(rhs)
             else rhs
 
@@ -619,7 +618,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
               else if (mods hasFlag PRESUPER | PARAMACCESSOR) constrPrefixBuf
               else constrStatBuf
 
-            initPhase += mkAssign(statSym, initializingRhs)
+            initPhase += mkAssign(assignSym, initializingRhs)
           }
         }
 
@@ -632,18 +631,21 @@ 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:
           //   - the class initializer (static),
           //   - the constructor, before the super call (early initialized or a parameter accessor),
           //   - the constructor, after the super call (regular val).
           case ValDef(mods, _, _, rhs) =>
-            val emitField = memoizeValue(statSym)
-            moveEffectToCtor(mods, rhs, emitField)
-
-            if (emitField) defBuf += deriveValDef(stat)(_ => EmptyTree)
+            if (rhs ne EmptyTree) {
+              val emitField = memoizeValue(statSym)
+              moveEffectToCtor(mods, rhs, statSym)
+              if (emitField) defBuf += deriveValDef(stat)(_ => EmptyTree)
+            } else defBuf += stat
 
           // all other statements go into the constructor
           case _ => constrStatBuf += intoConstructor(impl.symbol, primaryConstr.symbol)(stat)