Support Scala 2.12 mixins

Adapt to either 2.11 or 2.12 scheme.

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -75,7 +75,7 @@ class Compiler {
            new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods
            new Getters,             // Replace non-private vals and vars with getter defs (fields are added later)
            new ElimByName,          // Expand by-name parameter references
-           new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
+           new AugmentScala2Traits, // Expand traits defined in Scala 2.x to simulate old-style rewritings
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
            new Simplify,            // Perform local optimizations, simplified versions of what linker does.
            new PrimitiveForwarders, // Add forwarders to trait methods that have a mismatch between generic and primitives
@@ -87,15 +87,15 @@ class Compiler {
            new Mixin,               // Expand trait fields and trait initializers
            new LazyVals,            // Expand lazy vals
            new Memoize,             // Add private fields to getters and setters
-           new LinkScala2ImplClasses, // Forward calls to the implementation classes of traits defined by Scala 2.11
            new NonLocalReturns,     // Expand non-local returns
            new CapturedVars,        // Represent vars captured by closures as heap objects
            new Constructors,        // Collect initialization code in primary constructors
                                     // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
            new FunctionalInterfaces, // Rewrites closures to implement @specialized types of Functions.
            new GetClass,            // Rewrites getClass calls on primitive types.
            new Simplify),           // Perform local optimizations, simplified versions of what linker does.
-      List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
+      List(new LinkScala2ImplClasses, // Forward calls to the implementation classes of traits defined by Scala 2.11
+           new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers
            new Flatten,             // Lift all inner classes to package scope

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -399,6 +399,9 @@ object Flags {
   /** A module variable (Scala 2.x only) */
   final val Scala2ModuleVar = termFlag(57, "<modulevar>")
 
+  /** A Scala 2.12 trait that has been augmented with static members */
+  final val Scala_2_12_Augmented = typeFlag(57, "<scala12augmented")
+
   /** A definition that's initialized before the super call (Scala 2.x only) */
   final val Scala2PreSuper = termFlag(58, "<presuper>")
 

compiler/src/dotty/tools/dotc/core/NameKinds.scala

@@ -359,6 +359,7 @@ object NameKinds {
   val ExtMethName = new SuffixNameKind(EXTMETH, "$extension")
   val ModuleVarName = new SuffixNameKind(OBJECTVAR, "$module")
   val ModuleClassName = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
+  val ImplMethName = new SuffixNameKind(IMPLMETH, "$")
 
   /** A name together with a signature. Used in Tasty trees. */
   object SignedName extends NameKind(63) {

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -256,7 +256,9 @@ object TastyFormat {
   final val OBJECTCLASS = 40
 
   final val SIGNED = 63
+  
   final val firstInternalTag = 64
+  final val IMPLMETH = 64
 
   // AST tags
 

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

@@ -16,46 +16,84 @@ import NameOps._
 import Phases._
 import ast.untpd
 import ast.Trees._
+import NameKinds.ImplMethName
 import collection.mutable
 
 /** Rewrite calls
  *
  *    super[M].f(args)
  *
- *  where M is a Scala2 trait implemented by the current class to
+ *  where M is a Scala 2.11 trait implemented by the current class to
  *
  *    M$class.f(this, args)
  *
  *  provided the implementation class M$class defines a corresponding function `f`.
+ *  If M is a Scala 2.12 or newer trait, rewrite to
+ *
+ *    M.f(this, args)
+ *
+ *  where f is a static member of M.
  */
-class LinkScala2ImplClasses extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
+class LinkScala2ImplClasses extends MiniPhase with IdentityDenotTransformer { thisTransform =>
   import ast.tpd._
 
   override def phaseName: String = "linkScala2ImplClasses"
+  override def changesMembers = true
+  val treeTransform = new Transform
+
+  override def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set(classOf[Mixin])
+    // Adds as a side effect static members to traits which can confuse Mixin,
+    // that's why it is runsAfterGroupOf
 
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Mixin])
-
-  override def transformApply(app: Apply)(implicit ctx: Context, info: TransformerInfo) = {
-    def currentClass = ctx.owner.enclosingClass.asClass
-    app match {
-      case Apply(sel @ Select(Super(_, _), _), args)
-      if sel.symbol.owner.is(Scala2xTrait) && currentClass.mixins.contains(sel.symbol.owner) =>
-        val impl = implMethod(sel.symbol)
-        if (impl.exists) Apply(ref(impl), This(currentClass) :: args).withPos(app.pos)
-        else app // could have been an abstract method in a trait linked to from a super constructor
-      case _ =>
-        app
+  class Transform extends TreeTransform {
+    def phase = thisTransform
+
+    /** Copy definitions from implementation class to trait itself */
+    private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = {
+      def newImpl(sym: TermSymbol): Symbol = sym.copy(
+        owner = mixin,
+        name = if (sym.isConstructor) sym.name else ImplMethName(sym.name)
+      )
+      for (sym <- mixin.implClass.info.decls)
+        newImpl(sym.asTerm).enteredAfter(thisTransform)
     }
-  }
 
-  private def implMethod(meth: Symbol)(implicit ctx: Context): Symbol = {
-    val implInfo = meth.owner.implClass.info
-    if (meth.isConstructor)
-      implInfo.decl(nme.TRAIT_CONSTRUCTOR).symbol
-    else
-      implInfo.decl(meth.name)
-      .suchThat(c => FullParameterization.memberSignature(c.info) == meth.signature)
-      .symbol
+    override def prepareForTemplate(impl: Template)(implicit ctx: Context) = {
+      val cls = impl.symbol.owner.asClass
+      for (mixin <- cls.mixins)
+        if (mixin.is(Scala_2_12_Trait, butNot = Scala_2_12_Augmented)) {
+          augmentScala_2_12_Trait(mixin)
+          mixin.setFlag(Scala_2_12_Augmented)
+        }
+      this
+    }
+
+    override def transformApply(app: Apply)(implicit ctx: Context, info: TransformerInfo) = {
+      def currentClass = ctx.owner.enclosingClass.asClass
+      app match {
+        case Apply(sel @ Select(Super(_, _), _), args)
+        if sel.symbol.owner.is(Scala2xTrait) && currentClass.mixins.contains(sel.symbol.owner) =>
+          val impl = implMethod(sel.symbol)
+          if (impl.exists) Apply(ref(impl), This(currentClass) :: args).withPos(app.pos)
+          else app // could have been an abstract method in a trait linked to from a super constructor
+        case _ =>
+          app
+      }
+    }
+
+    private def implMethod(meth: Symbol)(implicit ctx: Context): Symbol = {
+      val (implInfo, implName) = 
+        if (meth.owner.is(Scala_2_12_Trait)) 
+          (meth.owner.info, ImplMethName(meth.name.asTermName))
+        else 
+          (meth.owner.implClass.info, meth.name)
+      if (meth.isConstructor)
+        implInfo.decl(nme.TRAIT_CONSTRUCTOR).symbol
+      else
+        implInfo.decl(implName)
+          .suchThat(c => FullParameterization.memberSignature(c.info) == meth.signature)
+          .symbol
+    }
   }
 
   private val Scala2xTrait = allOf(Scala2x, Trait)