Move the trait super call encoding logic to the back-end.

Author: sjrd

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -768,6 +768,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             val invokeStyle =
               if (sym.isStaticMember) InvokeStyle.Static
               else if (sym.isPrivate || sym.isClassConstructor) InvokeStyle.Special
+              else if (useInvokeSpecial(app)) InvokeStyle.Special
               else InvokeStyle.Virtual
 
             if (invokeStyle.hasInstance) genLoadQualifier(fun)
@@ -1183,9 +1184,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       val isInterface = receiverClass.isEmittedInterface
       import InvokeStyle._
       if (style == Super) {
-        // DOTTY: this differ from how super-calls in traits are handled in the scalac backend,
-        // this is intentional but could change in the future, see https://github.com/lampepfl/dotty/issues/5928
-        bc.invokespecial(receiverName, jname, mdescr, isInterface)
+        if (isInterface && !method.isJavaDefined) {
+          val args = new Array[BType](bmType.argumentTypes.length + 1)
+          val ownerBType = toTypeKind(method.owner.info)
+          bmType.argumentTypes.copyToArray(args, 1)
+          val staticDesc = MethodBType(ownerBType :: bmType.argumentTypes, bmType.returnType).descriptor
+          val staticName = traitSuperAccessorName(method)
+          bc.invokestatic(receiverName, staticName, staticDesc, isInterface)
+        } else {
+          bc.invokespecial(receiverName, jname, mdescr, isInterface)
+        }
       } else {
         val opc = style match {
           case Static => Opcodes.INVOKESTATIC

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

@@ -47,6 +47,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
+  final def traitSuperAccessorName(sym: Symbol): String = {
+    val nameString = sym.javaSimpleName.toString
+    if (sym.isMixinConstructor) nameString
+    else nameString + "$"
+  }
+
   // -----------------------------------------------------------------------------------------
   // finding the least upper bound in agreement with the bytecode verifier (given two internal names handed by ASM)
   // Background:

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -498,7 +498,19 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         case ValDef(mods, name, tpt, rhs) => () // fields are added in `genPlainClass()`, via `addClassFields()`
 
-        case dd @ DefDef(_, _, _, _, _, _) => genDefDef(dd.asInstanceOf[DefDef])
+        case dd @ DefDef(_, _, _, _, _, rhs) =>
+          val sym = dd.symbol
+
+          def needsStaticImplMethod: Boolean =
+            claszSymbol.isInterface
+              && !rhs.isEmpty
+              && !sym.isPrivate
+              && !sym.isStaticMember
+
+          if needsStaticImplMethod then
+            genStaticForwarderForDefDef(dd)
+
+          genDefDef(dd)
 
         case Template(_, _, body) => body foreach gen
 
@@ -535,6 +547,12 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
     } // end of method initJMethod
 
+    def genStaticForwarderForDefDef(dd: DefDef): Unit = dd match {
+      case DefDef(_, _, _, vparamss, _, _) =>
+
+      val forwarderDef = makeStaticForwarder(dd, traitSuperAccessorName(dd.symbol))
+      genDefDef(forwarderDef)
+    }
 
     def genDefDef(dd: DefDef): Unit = dd match {
       case DefDef(_, _, _, vparamss, _, rhs) =>

compiler/src/dotty/tools/backend/jvm/BackendInterface.scala

@@ -113,6 +113,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
   val nme_This: Name
   val nme_EMPTY_PACKAGE_NAME: Name
   val nme_CONSTRUCTOR: Name
+  val nme_TRAIT_CONSTRUCTOR: Name
   val nme_WILDCARD: Name
   val nme_THIS: Name
   val nme_PACKAGE: Name
@@ -144,6 +145,9 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
   def emitAnnotations(fw: asm.FieldVisitor, annotations: List[Annotation], bcodeStore: BCodeHelpers)(innerClasesStore: bcodeStore.BCInnerClassGen): Unit
   def emitParamAnnotations(jmethod: asm.MethodVisitor, pannotss: List[List[Annotation]], bcodeStore: BCodeHelpers)(innerClasesStore: bcodeStore.BCInnerClassGen): Unit
 
+  def makeStaticForwarder(dd: DefDef, name: String): DefDef
+  def useInvokeSpecial(apply: Apply): Boolean
+
   /* means of getting class symbols from compiler */
   def requiredClass[T: ClassTag]: Symbol
   def requiredModule[T: ClassTag]: Symbol
@@ -485,6 +489,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def isInterface: Boolean
     def isGetter: Boolean
     def isSetter: Boolean
+    def isMixinConstructor: Boolean = name == nme_TRAIT_CONSTRUCTOR
     def isGetClass: Boolean
     def isJavaDefined: Boolean
     def isDeferred: Boolean

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -99,6 +99,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val nme_This: Name = StdNames.nme.This
   val nme_EMPTY_PACKAGE_NAME: Name = StdNames.nme.EMPTY_PACKAGE
   val nme_CONSTRUCTOR: Name = StdNames.nme.CONSTRUCTOR
+  val nme_TRAIT_CONSTRUCTOR: Name = StdNames.nme.TRAIT_CONSTRUCTOR
   val nme_WILDCARD: Name = StdNames.nme.WILDCARD
   val nme_THIS: Name = StdNames.nme.THIS
   val nme_PACKAGE: Name = StdNames.nme.PACKAGE
@@ -365,6 +366,24 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def getAnnotPickle(jclassName: String, sym: Symbol): Option[Annotation] = None
 
+  def makeStaticForwarder(dd: DefDef, name: String): DefDef =
+    val origSym = dd.symbol.asTerm
+    val info = origSym.tpe match
+      case mt: MethodType =>
+        MethodType(nme.SELF :: mt.paramNames, origSym.owner.typeRef :: mt.paramInfos, mt.resType)
+    val sym = origSym.copy(
+      name = name.toTermName,
+      flags = Flags.Method | Flags.JavaStatic,
+      info = info
+    )
+    tpd.DefDef(sym.asTerm, { paramss =>
+      val params = paramss.head
+      tpd.Apply(params.head.select(origSym), params.tail)
+        .withAttachment(DottyBackendInterface.UseInvokeSpecial, ())
+    })
+
+  def useInvokeSpecial(apply: Apply): Boolean =
+    apply.hasAttachment(DottyBackendInterface.UseInvokeSpecial)
 
   def getRequiredClass(fullname: String): Symbol = ctx.requiredClass(fullname)
 
@@ -1210,4 +1229,10 @@ object DottyBackendInterface {
     Flags.Specialized | Flags.Lifted | Flags.Protected | Flags.JavaStatic |
     Flags.Private | Flags.Macro
   }
+
+  /** An attachment on Apply nodes indicating that it should be compiled with
+   *  `invokespecial` instead of `invokevirtual`. This is used for static
+   *  forwarders.
+   */
+  private val UseInvokeSpecial = new util.Property.Key[Unit]
 }

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

@@ -110,7 +110,7 @@ class Compiler {
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
          new Instrumentation,        // Count closure allocations under -Yinstrument-closures
          new GetClass) ::            // Rewrites getClass calls on primitive types.
-    List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to
+    List(//new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to
          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