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

Author: sjrd

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

@@ -780,6 +780,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             val invokeStyle =
               if (sym.isStaticMember) InvokeStyle.Static
               else if (sym.is(Private) || sym.isClassConstructor) InvokeStyle.Special
+              else if (app.hasAttachment(BCodeHelpers.UseInvokeSpecial)) InvokeStyle.Special
               else InvokeStyle.Virtual
 
             if (invokeStyle.hasInstance) genLoadQualifier(fun)
@@ -1165,9 +1166,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       val isInterface = isEmittedInterface(receiverClass)
       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.is(JavaDefined)) {
+          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

@@ -82,6 +82,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
+  final def traitSuperAccessorName(sym: Symbol): String = {
+    val nameString = sym.javaSimpleName.toString
+    if (sym.name == nme.TRAIT_CONSTRUCTOR) nameString
+    else nameString + "$"
+  }
+
   // -----------------------------------------------------------------------------------------
   // finding the least upper bound in agreement with the bytecode verifier (given two internal names handed by ASM)
   // Background:
@@ -950,4 +956,10 @@ object BCodeHelpers {
     val Super   = new InvokeStyle(3) // InvokeSpecial (super calls)
   }
 
+  /** An attachment on Apply nodes indicating that it should be compiled with
+   *  `invokespecial` instead of `invokevirtual`. This is used for static
+   *  forwarders.
+   */
+  val UseInvokeSpecial = new dotc.util.Property.Key[Unit]
+
 }

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

@@ -14,9 +14,9 @@ import dotty.tools.dotc.CompilationUnit
 import dotty.tools.dotc.core.Annotations.Annotation
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.StdNames.str
+import dotty.tools.dotc.core.StdNames.{nme, str}
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.Types.{MethodType, Type}
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.report
 
@@ -496,7 +496,19 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         case ValDef(name, tpt, rhs) => () // fields are added in `genPlainClass()`, via `addClassFields()`
 
-        case dd: DefDef => genDefDef(dd)
+        case dd: DefDef =>
+          val sym = dd.symbol
+
+          def needsStaticImplMethod: Boolean =
+            claszSymbol.isInterface
+              && !dd.rhs.isEmpty
+              && !sym.isPrivate
+              && !sym.isStaticMember
+
+          if needsStaticImplMethod then
+            genStaticForwarderForDefDef(dd)
+
+          genDefDef(dd)
 
         case tree: Template =>
           val body =
@@ -537,6 +549,25 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
     } // end of method initJMethod
 
+    private def genStaticForwarderForDefDef(dd: DefDef): Unit =
+      val forwarderDef = makeStaticForwarder(dd, traitSuperAccessorName(dd.symbol))
+      genDefDef(forwarderDef)
+
+    private def makeStaticForwarder(dd: DefDef, name: String): DefDef =
+      val origSym = dd.symbol.asTerm
+      val info = origSym.info match
+        case mt: MethodType =>
+          MethodType(nme.SELF :: mt.paramNames, origSym.owner.typeRef :: mt.paramInfos, mt.resType)
+      val sym = origSym.copy(
+        name = name.toTermName,
+        flags = Method | JavaStatic,
+        info = info
+      )
+      tpd.DefDef(sym.asTerm, { paramss =>
+        val params = paramss.head
+        tpd.Apply(params.head.select(origSym), params.tail)
+          .withAttachment(BCodeHelpers.UseInvokeSpecial, ())
+      })
 
     def genDefDef(dd: DefDef): Unit = {
       val rhs = dd.rhs

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

@@ -110,7 +110,7 @@ class Compiler {
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
          new Instrumentation) ::     // Count closure allocations under -Yinstrument-closures
-    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