wip

Author: sjrd

compiler/src/dotty/tools/dotc/transform/Mixin.scala

@@ -13,6 +13,7 @@ import Decorators._
 import DenotTransformers._
 import StdNames._
 import NameKinds._
+import NameOps._
 import ast.Trees._
 import collection.mutable
 
@@ -145,32 +146,38 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     }
   }.asTerm
 
+  private def wasOneOf(sym: Symbol, flags: FlagSet)(implicit ctx: Context): Boolean =
+    ctx.atPhase(thisPhase) { sym.isOneOf(flags) }
+
+  private def needsTraitSetter(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.isGetter && !wasOneOf(sym, DeferredOrLazy | ParamAccessor) && !sym.setter.exists
+      && !sym.info.resultType.isInstanceOf[ConstantType]
+
+  private def traitSetter(getter: TermSymbol)(implicit ctx: Context): Symbol =
+    getter.copy(
+      name = getter.ensureNotPrivate.name
+        .expandedName(getter.owner, TraitSetterName)
+        .asTermName.setterName,
+      flags = Method | Accessor | Deferred,
+      info = MethodType(getter.info.resultType :: Nil, defn.UnitType))
+
   override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
     val cls = impl.symbol.owner.asClass
     val ops = new MixinOps(cls, thisPhase)
     import ops._
 
     def traitDefs(stats: List[Tree]): List[Tree] = {
-      val initBuf = new mutable.ListBuffer[Tree]
-      stats.flatMap({
-        case stat: DefDef if stat.symbol.isGetter && !stat.rhs.isEmpty && !stat.symbol.is(Lazy) =>
-          // make initializer that has all effects of previous getter,
-          // replace getter rhs with empty tree.
-          val vsym = stat.symbol
-          val isym = initializer(vsym)
-          val rhs = Block(
-            initBuf.toList.map(_.changeOwnerAfter(impl.symbol, isym, thisPhase)),
-            stat.rhs.changeOwnerAfter(vsym, isym, thisPhase).wildcardToDefault)
-          initBuf.clear()
-          cpy.DefDef(stat)(rhs = EmptyTree) :: DefDef(isym, rhs) :: Nil
+      stats.flatMap {
+        case stat: DefDef if needsTraitSetter(stat.symbol) =>
+          // add a trait setter for this getter
+          val vsym = stat.symbol.asTerm
+          val ssym = traitSetter(vsym).asTerm.enteredAfter(thisPhase)
+          stat :: DefDef(ssym, EmptyTree) :: Nil
         case stat: DefDef if stat.symbol.isSetter =>
           cpy.DefDef(stat)(rhs = EmptyTree) :: Nil
-        case stat: DefTree =>
-          stat :: Nil
         case stat =>
-          initBuf += stat
-          Nil
-      }) ++ initBuf
+          stat :: Nil
+      }
     }
 
     /** Map constructor call to a pair of a supercall and a list of arguments
@@ -205,9 +212,6 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil
     }
 
-    def wasOneOf(sym: Symbol, flags: FlagSet) =
-      ctx.atPhase(thisPhase) { sym.isOneOf(flags) }
-
     def traitInits(mixin: ClassSymbol): List[Tree] = {
       var argNum = 0
       def nextArgument() = initArgs.get(mixin) match {
@@ -227,33 +231,28 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       }
 
       for (getter <- mixin.info.decls.toList if getter.isGetter && !wasOneOf(getter, Deferred)) yield {
-        val isScala2x = mixin.is(Scala2x)
-        def default = Underscore(getter.info.resultType)
-        def initial = transformFollowing(superRef(initializer(getter)).appliedToNone)
-
         if (isCurrent(getter) || getter.name.is(ExpandedName)) {
           val rhs =
             if (wasOneOf(getter, ParamAccessor))
               nextArgument()
-            else if (isScala2x)
-              if (getter.is(Lazy, butNot = Module))
-                initial
-              else if (getter.is(Module))
-                New(getter.info.resultType, List(This(cls)))
-              else
-                Underscore(getter.info.resultType)
+            else if (getter.is(Lazy, butNot = Module))
+              transformFollowing(superRef(getter).appliedToNone)
+            else if (getter.is(Module))
+              New(getter.info.resultType, List(This(cls)))
             else
-              initial
+              Underscore(getter.info.resultType)
           // transformFollowing call is needed to make memoize & lazy vals run
           transformFollowing(DefDef(mkForwarderSym(getter.asTerm), rhs))
         }
-        else if (isScala2x || wasOneOf(getter, ParamAccessor | Lazy)) EmptyTree
-        else initial
+        else EmptyTree
       }
     }
 
     def setters(mixin: ClassSymbol): List[Tree] =
-      for (setter <- mixin.info.decls.filter(setr => setr.isSetter && !wasOneOf(setr, Deferred)))
+      val mixinSetters = mixin.info.decls.filter { sym =>
+        sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName))
+      }
+      for (setter <- mixinSetters)
       yield transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span)))
 
     def mixinForwarders(mixin: ClassSymbol): List[Tree] =