WIP: dotty-style trait fields

namers

wip

Author: adriaanm

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

@@ -597,21 +597,32 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     def intoConstructor(oldowner: Symbol, tree: Tree) =
       intoConstructorTransformer transform tree.changeOwner(oldowner -> constr.symbol)
 
-    private def assignmentIntoCtor(assignSym: Symbol, stat: ValOrDefDef): Unit = {
-      val rhs1 = intoConstructor(assignSym, stat.rhs)
+    private def assignmentIntoCtor(stat: ValOrDefDef): Unit = {
+      val rhs1 = intoConstructor(stat.symbol, stat.rhs)
 
       // Should tree be moved in front of super constructor call?
       // (I.e., is it derived from an early definition?)
       val constrBufPart =
         if (stat.mods hasFlag PRESUPER | PARAMACCESSOR) constrPrefixBuf
         else constrStatBuf
 
+      val assignSym =
+        if (stat.symbol.isGetter) stat.symbol.asInstanceOf[MethodSymbol].referenced //setterIn(clazz, hasExpandedName = false) // not yet expanded -- see Mixin
+        else stat.symbol
+
+      assert(assignSym ne NoSymbol, stat)
+
       constrBufPart += mkAssign(assignSym, rhs1)
     }
 
+    // TODO: we probably can't emit an Assign tree after typers, need to Apply the setter
     // 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) }
+      localTyper.typedPos(to.pos) {
+        val qual = Select(This(clazz), to)
+        if (to.isSetter) Apply(qual, List(from))
+        else Assign(qual, from)
+      }
 
     // Create code to copy parameter to parameter accessor field.
     // If parameter is $outer, check that it is not null so that we NPE
@@ -665,6 +676,12 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     // Triage all template definitions to go into defBuf/auxConstructorBuf, constrStatBuf, or constrPrefixBuf.
     for (stat <- stats) stat match {
       case dd@ DefDef(_,_,_,_,_,rhs) =>
+        // We can't mark as deferred from the start, as it will be implemented automatically in the subclass
+        // it should be marked deferred in bytecode, though
+        if (inTrait && stat.symbol.isAccessor) {
+          stat.symbol setFlag DEFERRED
+        }
+
         // methods with constant result type get literals as their body
         // all methods except the primary constructor go into template
         stat.symbol.tpe match {
@@ -673,13 +690,14 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           case _ =>
             if (stat.symbol.isPrimaryConstructor) ()
             else if (stat.symbol.isConstructor) auxConstructorBuf += stat
-            else if (inTrait && stat.symbol.isAccessor) {
-              assignmentIntoCtor(stat)
+            // a concrete getter's RHS is treated like a ValDef (the actual field isn't emitted until Mixin augments the class that inherits the trait)
+            else if (inTrait && stat.symbol.isGetter && (rhs ne EmptyTree)) {
+              assignmentIntoCtor(dd)
               defBuf += deriveDefDef(dd)(_ => EmptyTree)
             }
             else defBuf += stat
         }
-      case ValDef(mods, _, _, rhs) if !mods.hasStaticFlag =>
+      case vd@ ValDef(mods, _, _, rhs) if !mods.hasStaticFlag =>
         // val defs with constant right-hand sides are eliminated.
         // for all other val defs, an empty valdef goes into the template and
         // the initializer goes as an assignment into the constructor
@@ -688,7 +706,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         // Lazy vals don't get the assignment in the constructor.
         if (!stat.symbol.tpe.isInstanceOf[ConstantType]) { // TODO: MethodSynthesis should no longer emit ValDefs with ConstantTypes
           if (rhs != EmptyTree && !stat.symbol.isLazy) {
-            assignmentIntoCtor(stat.symbol, stat)
+            assignmentIntoCtor(vd)
           }
           defBuf += deriveValDef(stat)(_ => EmptyTree)
         }

src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala

@@ -134,6 +134,7 @@ trait MethodSynthesis {
       ImplicitClassWrapper(tree).createAndEnterSymbol()
     }
 
+    // TODO: see standardAccessors
     def enterGetterSetter(tree: ValDef) {
       val ValDef(mods, name, _, _) = tree
       if (nme.isSetterName(name))
@@ -149,8 +150,11 @@ trait MethodSynthesis {
           val getter = Getter(tree)
           val getterSym = getter.createAndEnterSymbol()
           // Create the setter if necessary.
-          if (getter.needsSetter)
-            Setter(tree).createAndEnterSymbol()
+          if (getter.needsSetter) {
+            val setterSym = Setter(tree).createAndEnterSymbol()
+            getterSym.referenced = setterSym
+            setterSym.referenced = getterSym
+          }
 
           // Create a field if the getter requires storage, otherwise,
           // the getter's abstract and the tree gets the getter's symbol.
@@ -224,9 +228,12 @@ trait MethodSynthesis {
       }
 
     def standardAccessors(vd: ValDef): List[DerivedFromValDef] =
-      if (vd.mods.isMutable && !vd.mods.isLazy) List(Getter(vd), Setter(vd))
-      else if (vd.mods.isLazy) List(LazyValGetter(vd))
-      else List(Getter(vd))
+      if (vd.mods.isLazy) List(LazyValGetter(vd))
+      else {
+        val getter = Getter(vd)
+        if (getter.needsSetter) List(getter, Setter(vd))
+        else List(getter)
+      }
 
     def beanAccessors(vd: ValDef): List[DerivedFromValDef] = {
       val setter = if (vd.mods.isMutable) List(BeanSetter(vd)) else Nil
@@ -264,7 +271,10 @@ trait MethodSynthesis {
       def completer(sym: Symbol): Type
 
       /** The derived symbol. It is assumed that this symbol already exists and has been
-       *  entered in the parent scope when derivedSym is called */
+        * entered in the parent scope when derivedSym is called
+        * this derived symbol business is super shady -- we're creating them,
+        * so why do we need to look them up with setterIn/getterIn??
+        */
       def derivedSym: Symbol
 
       /** The definition tree of the derived symbol. */
@@ -310,14 +320,14 @@ trait MethodSynthesis {
       //   - concrete vals in traits don't yield a field here either (their getter's RHS has the initial value)
       //     Constructors will move the assignment to the constructor, abstracting over the field using the field setter,
       //     and Mixin will add a field to the class that mixes in the trait, implementing the accessors in terms of it
-      def noFieldHere = nothingToMemoize || derivedSym.owner.isTrait
-      protected def nothingToMemoize = isDeferred || typeNeedsNoStorage(basisSym.tpe)
+      def noFieldHere = nothingToMemoize || owner.isTrait
+      protected def nothingToMemoize = isDeferred || typeNeedsNoStorage(basisSym.tpe.resultType)
 
       def isSetter   = false
       def isDeferred = mods.isDeferred
       def keepClean  = false  // whether annotations whose definitions are not meta-annotated should be kept.
       def validate() { }
-      def createAndEnterSymbol(): Symbol = {
+      def createAndEnterSymbol(): MethodSymbol = {
         val sym = owner.newMethod(name, tree.pos.focus, derivedMods.flags)
         setPrivateWithin(tree, sym)
         enterInScope(sym)
@@ -336,14 +346,22 @@ trait MethodSynthesis {
       }
     }
     sealed trait DerivedGetter extends DerivedFromValDef {
-      def needsSetter = mods.isMutable || (derivedSym.owner.isTrait && !nothingToMemoize)
+      // A getter obviously must be accompanied by a setter if the ValDef is mutable.
+      // We also need a setter for any val/var defined in a trait,
+      // since an interface in Java can't define a field,
+      // so we shall set the initial value indirectly in the trait's init method using the trait setter,
+      // which will be implemented in the class
+      def needsSetter = mods.isMutable || (owner.isTrait && !nothingToMemoize)
     }
     sealed trait DerivedSetter extends DerivedFromValDef {
       override def isSetter = true
       private def setterParam = derivedSym.paramss match {
         case (p :: Nil) :: _  => p
         case _                => NoSymbol
       }
+      // TODO: when is `derivedSym.isOverloaded`??? is it always an error?
+      // `noFieldHere` does not imply DEFERRED (ask isDeferred if you must know)
+      // we automatically implement trait setters (where !isDeferred) in the subclass
       private def setterRhs =
         if (noFieldHere || derivedSym.isOverloaded) EmptyTree
         else Assign(fieldSelection, Ident(setterParam))
@@ -456,7 +474,7 @@ trait MethodSynthesis {
       def flagsMask  = SetterFlags
       def flagsExtra = ACCESSOR
 
-      override def derivedSym = basisSym.setterIn(enclClass)
+      override def derivedSym = basisSym.setterIn(enclClass, hasExpandedName = false)
     }
     case class Field(tree: ValDef) extends DerivedFromValDef {
       def name       = tree.localName
@@ -467,12 +485,8 @@ trait MethodSynthesis {
       // generated for a class parameter (PARAMACCESSOR).
       override def keepClean = !mods.isParamAccessor
 
-      override def derivedSym =
-        if (noFieldHere) NoSymbol
-        else super.derivedSym
-
       override def derivedTree = (
-        if (derivedSym eq NoSymbol) EmptyTree
+        if (noFieldHere) EmptyTree
         else if (mods.isLazy) copyValDef(tree)(mods = mods | flagsExtra, name = this.name, rhs = EmptyTree).setPos(tree.pos.focus)
         else copyValDef(tree)(mods = mods | flagsExtra, name = this.name)
       )
@@ -515,7 +529,7 @@ trait MethodSynthesis {
           )
         }
       }
-      override def createAndEnterSymbol(): Symbol = enterSyntheticSym(derivedTree)
+      override def createAndEnterSymbol(): MethodSymbol = enterSyntheticSym(derivedTree).asInstanceOf[MethodSymbol]
     }
     case class BooleanBeanGetter(tree: ValDef) extends BeanAccessor("is") with AnyBeanGetter { }
     case class BeanGetter(tree: ValDef) extends BeanAccessor("get") with AnyBeanGetter { }