First pass of reverting to the trait encoding of Scala 2.

sjrd · sjrd · commit 90070e2e9131 · 2020-07-22T10:23:31.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -86,7 +86,7 @@ class Compiler {
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
          new CollectNullableFields,  // Collect fields that can be nulled out after use in lazy initialization
          new ElimOuterSelect,        // Expand outer selections
-         new AugmentScala2Traits,    // Augments Scala2 traits with additional members needed for mixin composition.
+         //new AugmentScala2Traits,    // Augments Scala2 traits with additional members needed for mixin composition.
          new ResolveSuper,           // Implement super accessors
          new FunctionXXLForwarders,  // Add forwarders for FunctionXXL apply method
          new ParamForwarding,        // Add forwarders for aliases of superclass parameters
diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -205,6 +205,16 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
                 owner = constr.symbol).installAfter(thisPhase)
               constrStats += intoConstr(stat, sym)
             }
+          case stat @ DefDef(name, _, _, tpt, _)
+              if stat.symbol.isGetter && stat.symbol.owner.is(Trait) && !stat.symbol.is(Lazy) =>
+            val sym = stat.symbol
+            assert(isRetained(sym), sym)
+            if (!stat.rhs.isEmpty && !isWildcardArg(stat.rhs))
+              val setter =
+                if (sym.setter.exists) sym.setter
+                else sym.accessorNamed(Mixin.traitSetterName(sym.asTerm))
+              constrStats += Apply(ref(setter), intoConstr(stat.rhs, sym).withSpan(stat.span) :: Nil)
+            clsStats += cpy.DefDef(stat)(rhs = EmptyTree)
           case DefDef(nme.CONSTRUCTOR, _, ((outerParam @ ValDef(nme.OUTER, _, _)) :: _) :: Nil, _, _) =>
             clsStats += mapOuter(outerParam.symbol).transform(stat)
           case _: DefTree =>
diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
@@ -10,21 +10,25 @@ import Symbols._
 import Types._
 import Decorators._
 import DenotTransformers._
+import Names._
 import StdNames._
+import SymDenotations._
 import ast.Trees._
 import NameKinds.ImplMethName
 
 /** Rewrite calls
  *
  *    super[M].f(args)
  *
- *  where M is a Scala 2.x trait implemented by the current class to
+ *  where M is a trait implemented by the current class to
  *
  *    M.f$(this, args)
  *
  *  where f$ is a static member of M.
+ *
+ *  Also generates said static members, as forwarders to the normal methods.
  */
-class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+class LinkScala2Impls extends MiniPhase with SymTransformer { thisPhase =>
   import ast.tpd._
 
   override def phaseName: String = "linkScala2Impls"
@@ -34,47 +38,77 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
     // Adds as a side effect static members to traits which can confuse Mixin,
     // that's why it is runsAfterGroupOf
 
-  private def addStaticForwarders(mixin: ClassSymbol)(using Context): Unit = {
-    val ops = new MixinOps(mixin, thisPhase)
-    import ops._
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if sym.is(Trait) && !ctx.settings.scalajs.value then
+      val mixin = sym.asClass.classSymbol
+      val ops = new MixinOps(mixin, thisPhase)
+      import ops._
 
-    def newImpl(meth: TermSymbol): Symbol = {
-      def staticInfo(tp: Type) = tp match {
-        case mt: MethodType =>
-          MethodType(nme.SELF :: mt.paramNames, mixin.typeRef :: mt.paramInfos, mt.resType)
-      }
-      val mold =
-        if (meth.isConstructor)
-          meth.copySymDenotation(
-            name = nme.TRAIT_CONSTRUCTOR,
-            info = MethodType(Nil, defn.UnitType))
-        else meth.ensureNotPrivate
-      meth.copy(
-        owner = mixin,
-        name = if (meth.isConstructor) mold.name.asTermName else ImplMethName(mold.name.asTermName),
-        flags = Method | JavaStatic,
-        info = staticInfo(mold.info)
-      )
-    }
-    for (sym <- mixin.info.decls)
-      if (needsMixinForwarder(sym) || sym.isConstructor || sym.isGetter && sym.is(Lazy) || sym.is(Method, butNot = Deferred))
-        newImpl(sym.asTerm).enteredAfter(thisPhase)
-    // The trait is now fully augmented so the flag isn't needed anymore.
-    mixin.resetFlag(Scala2xPartiallyAugmented)
-  }
+      def newImpl(meth: TermSymbol): Symbol =
+        def staticInfo(tp: Type) = tp match
+          case mt: MethodType =>
+            MethodType(nme.SELF :: mt.paramNames, mixin.typeRef :: mt.paramInfos, mt.resType)
+        val mold = meth.ensureNotPrivate
+        meth.copy(
+          owner = mixin,
+          name = staticForwarderName(mold.name.asTermName),
+          flags = Method | JavaStatic,
+          info = staticInfo(mold.info)
+        )
 
-  override def prepareForTemplate(impl: Template)(using Context): Context = {
-    val cls = impl.symbol.owner.asClass
-    for (mixin <- cls.mixins if (mixin.is(Scala2xPartiallyAugmented)))
-      addStaticForwarders(mixin)
-    ctx
-  }
+      val classInfo = sym.asClass.classInfo
+      val decls1 = classInfo.decls.cloneScope
+      var modified: Boolean = false
+      for (meth <- classInfo.decls)
+        if needsStaticForwarder(meth) then
+          decls1.enter(newImpl(meth.asTerm))
+          modified = true
+      if modified then
+        sym.copySymDenotation(
+          info = classInfo.derivedClassInfo(decls = decls1))
+      else
+        sym
+    else
+      sym
+  end transformSym
+
+  private def needsStaticForwarder(sym: Symbol)(using Context): Boolean =
+    sym.is(Method, butNot = Deferred)
+
+  private def staticForwarderName(name: TermName)(using Context): TermName =
+    if name == nme.TRAIT_CONSTRUCTOR then name
+    else ImplMethName(name)
+
+  override def transformTemplate(impl: Template)(using Context): Tree =
+    val sym = impl.symbol.owner.asClass
+    if sym.is(Trait) && !ctx.settings.scalajs.value then
+      val newConstr :: newBody = (impl.constr :: impl.body).flatMap {
+        case stat: DefDef if needsStaticForwarder(stat.symbol) =>
+          val meth = stat.symbol
+          val staticForwarderDef = DefDef(implMethod(meth).asTerm, { paramss =>
+            val params = paramss.head
+            /* FIXME This is wrong. We are emitting a virtual call to `meth`,
+             * but we must instead emit an `invokespecial` so that it is not
+             * virtual. However, I don't know how to represent an invokevirtual
+             * call on a non-`this` receiver. My best attempt is the following,
+             * but that throws an exception when type-assigning the Super node:
+             */
+            //Apply(Super(params.head, sym.name.asTypeName, sym).select(meth), params.tail)
+            Apply(params.head.select(meth), params.tail)
+          })
+          stat :: transformFollowing(staticForwarderDef) :: Nil
+        case stat =>
+          stat :: Nil
+      }
+      cpy.Template(impl)(constr = newConstr.asInstanceOf[DefDef], body = newBody)
+    else
+      impl
 
   override def transformApply(app: Apply)(using Context): Tree = {
     def currentClass = ctx.owner.enclosingClass.asClass
     app match {
       case Apply(sel @ Select(Super(_, _), _), args)
-      if sel.symbol.owner.is(Scala2x) && currentClass.mixins.contains(sel.symbol.owner) && !ctx.settings.scalajs.value =>
+      if sel.symbol.owner.is(Trait) && currentClass.mixins.contains(sel.symbol.owner) && !ctx.settings.scalajs.value =>
         val impl = implMethod(sel.symbol)
         if (impl.exists) Apply(ref(impl), This(currentClass) :: args).withSpan(app.span)
         else app // could have been an abstract method in a trait linked to from a super constructor
@@ -83,19 +117,13 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
     }
   }
 
-  /** The 2.12 implementation method of a super call or implementation class target */
-  private def implMethod(meth: Symbol)(using Context): Symbol = {
-    val implName = ImplMethName(meth.name.asTermName)
+  /** The implementation method of a super call or implementation class target */
+  private def implMethod(meth: Symbol)(using Context): Symbol =
     val cls = meth.owner
-    if (cls.isAllOf(Scala2xTrait))
-      if (meth.isConstructor)
-        cls.info.decl(nme.TRAIT_CONSTRUCTOR).symbol
-      else
-        cls.info.decl(implName)
-          .suchThat(c => FullParameterization.memberSignature(c.info) == meth.signature)
-          .symbol
-    else throw new AssertionError(i"no impl method for $meth")
-  }
-
-  private val Scala2xTrait = Scala2x | Trait
+    if meth.name == nme.TRAIT_CONSTRUCTOR then
+      cls.info.decl(nme.TRAIT_CONSTRUCTOR).suchThat(_.is(JavaStatic)).symbol
+    else
+      cls.info.decl(staticForwarderName(meth.name.asTermName))
+        .suchThat(c => FullParameterization.memberSignature(c.info) == meth.signature)
+        .symbol
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
@@ -13,12 +13,19 @@ import Types._
 import Decorators._
 import DenotTransformers._
 import StdNames._
+import Names._
 import NameKinds._
+import NameOps._
 import ast.Trees._
 import collection.mutable
 
 object Mixin {
   val name: String = "mixin"
+
+  def traitSetterName(getter: TermSymbol)(using Context): TermName =
+    getter.ensureNotPrivate.name
+      .expandedName(getter.owner, TraitSetterName)
+      .asTermName.setterName
 }
 
 /** This phase performs the following transformations:
@@ -127,12 +134,27 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
         else sym.copySymDenotation(initFlags = sym.flags &~ ParamAccessor | Deferred)
       sym1.ensureNotPrivate
     }
-    else if (sym.isConstructor && (sym.owner.is(Trait, butNot = Scala2x) || (sym.owner.isAllOf(Trait | Scala2x) && ctx.settings.scalajs.value)))
+    else if (sym.isConstructor && sym.owner.is(Trait))
       sym.copySymDenotation(
         name = nme.TRAIT_CONSTRUCTOR,
         info = MethodType(Nil, sym.info.resultType))
+    else if sym.is(Trait) then
+      val classInfo = sym.asClass.classInfo
+      val decls1 = classInfo.decls.cloneScope
+      var modified: Boolean = false
+      for (getter <- classInfo.decls)
+        if needsTraitSetter(getter) then
+          val setter = makeTraitSetter(getter.asTerm)
+          decls1.enter(setter)
+          modified = true
+      if modified then
+        sym.copySymDenotation(
+          info = classInfo.derivedClassInfo(decls = decls1))
+      else
+        sym
     else
       sym
+  end transformSym
 
   private def initializer(sym: Symbol)(using Context): TermSymbol = {
     if (sym.is(Lazy)) sym
@@ -149,32 +171,34 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     }
   }.asTerm
 
+  private def wasOneOf(sym: Symbol, flags: FlagSet)(using Context): Boolean =
+    atPhase(thisPhase) { sym.isOneOf(flags) }
+
+  private def needsTraitSetter(sym: Symbol)(using Context): Boolean =
+    sym.isGetter && !wasOneOf(sym, DeferredOrLazy | ParamAccessor) && !sym.setter.exists
+      && !sym.info.resultType.isInstanceOf[ConstantType]
+
+  private def makeTraitSetter(getter: TermSymbol)(using Context): Symbol =
+    getter.copy(
+      name = Mixin.traitSetterName(getter),
+      flags = Method | Accessor | Deferred,
+      info = MethodType(getter.info.resultType :: Nil, defn.UnitType))
+
   override def transformTemplate(impl: Template)(using 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
+          stat :: DefDef(stat.symbol.traitSetter.asTerm, 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 triple of a supercall, and if the target
@@ -221,9 +245,6 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           //println(i"synth super call ${baseCls.primaryConstructor}: ${baseCls.primaryConstructor.info}")
           transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil
 
-    def wasOneOf(sym: Symbol, flags: FlagSet) =
-      atPhase(thisPhase) { sym.isOneOf(flags) }
-
     def traitInits(mixin: ClassSymbol): List[Tree] = {
       val argsIt = superCallsAndArgs.get(mixin) match
         case Some((_, _, args)) => args.iterator
@@ -241,33 +262,28 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           EmptyTree
 
       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] =
diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -34,7 +34,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def phaseName: String = ResolveSuper.name
 
   override def runsAfter: Set[String] = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
-                               AugmentScala2Traits.name,
+                               //AugmentScala2Traits.name,
                                PruneErasedDefs.name) // Erased decls make `isCurrent` work incorrectly
 
   override def changesMembers: Boolean = true // the phase adds super accessors
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -152,6 +152,10 @@ class SymUtils(val self: Symbol) extends AnyVal {
     if (self.isSetter) self
     else accessorNamed(self.asTerm.name.setterName)
 
+  def traitSetter(using Context): Symbol =
+    if (self.name.is(TraitSetterName)) self
+    else accessorNamed(Mixin.traitSetterName(self.asTerm))
+
   def field(using Context): Symbol = {
     val thisName = self.name.asTermName
     val fieldName =
