Emit Java generic signatures for mixin forwarders.

This is a forward port of
scala/scala@6fc2202
In Scala 2 that commit was reverting a commit that had stopped
emitting Java generic signatures. In dotc we never had that logic
before, so this is new code.

Author: sjrd

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

@@ -31,6 +31,7 @@ import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.core.TypeErasure
 import dotty.tools.dotc.transform.GenericSignatures
 import dotty.tools.dotc.transform.ElimErasedValueType
+import dotty.tools.dotc.transform.Mixin
 import dotty.tools.io.AbstractFile
 import dotty.tools.dotc.report
 
@@ -395,12 +396,20 @@ trait BCodeHelpers extends BCodeIdiomatic {
      */
     def getGenericSignature(sym: Symbol, owner: Symbol): String = {
       atPhase(erasurePhase) {
-        val memberTpe =
+        def computeMemberTpe(): Type =
           if (sym.is(Method)) sym.denot.info
           else if sym.denot.validFor.phaseId > erasurePhase.id && sym.isField && sym.getter.exists then
             // Memoization field of getter entered after erasure, see run/i17069 for an example
             sym.getter.denot.info.resultType
           else owner.denot.thisType.memberInfo(sym)
+
+        val memberTpe = if sym.is(MixedIn) then
+          mixinPhase.asInstanceOf[Mixin].mixinForwarderGenericInfos.get(sym) match
+            case Some(genericInfo) => genericInfo
+            case none              => computeMemberTpe()
+        else
+          computeMemberTpe()
+
         getGenericSignatureHelper(sym, owner, memberTpe).orNull
       }
     }

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

@@ -239,6 +239,7 @@ object Phases {
     private var myErasurePhase: Phase = uninitialized
     private var myElimErasedValueTypePhase: Phase = uninitialized
     private var myLambdaLiftPhase: Phase = uninitialized
+    private var myMixinPhase: Phase = uninitialized
     private var myCountOuterAccessesPhase: Phase = uninitialized
     private var myFlattenPhase: Phase = uninitialized
     private var myGenBCodePhase: Phase = uninitialized
@@ -266,6 +267,7 @@ object Phases {
     final def gettersPhase: Phase = myGettersPhase
     final def erasurePhase: Phase = myErasurePhase
     final def elimErasedValueTypePhase: Phase = myElimErasedValueTypePhase
+    final def mixinPhase: Phase = myMixinPhase
     final def lambdaLiftPhase: Phase = myLambdaLiftPhase
     final def countOuterAccessesPhase = myCountOuterAccessesPhase
     final def flattenPhase: Phase = myFlattenPhase
@@ -295,6 +297,7 @@ object Phases {
       myErasurePhase = phaseOfClass(classOf[Erasure])
       myElimErasedValueTypePhase = phaseOfClass(classOf[ElimErasedValueType])
       myPatmatPhase = phaseOfClass(classOf[PatternMatcher])
+      myMixinPhase = phaseOfClass(classOf[Mixin])
       myLambdaLiftPhase = phaseOfClass(classOf[LambdaLift])
       myCountOuterAccessesPhase = phaseOfClass(classOf[CountOuterAccesses])
       myFlattenPhase = phaseOfClass(classOf[Flatten])
@@ -551,6 +554,7 @@ object Phases {
   def gettersPhase(using Context): Phase                = ctx.base.gettersPhase
   def erasurePhase(using Context): Phase                = ctx.base.erasurePhase
   def elimErasedValueTypePhase(using Context): Phase    = ctx.base.elimErasedValueTypePhase
+  def mixinPhase(using Context): Phase                  = ctx.base.mixinPhase
   def lambdaLiftPhase(using Context): Phase             = ctx.base.lambdaLiftPhase
   def flattenPhase(using Context): Phase                = ctx.base.flattenPhase
   def genBCodePhase(using Context): Phase               = ctx.base.genBCodePhase

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

@@ -16,6 +16,7 @@ import StdNames.*
 import Names.*
 import NameKinds.*
 import NameOps.*
+import Phases.erasurePhase
 import ast.Trees.*
 
 import dotty.tools.dotc.transform.sjs.JSSymUtils.isJSType
@@ -115,6 +116,15 @@ object Mixin {
 class Mixin extends MiniPhase with SymTransformer { thisPhase =>
   import ast.tpd.*
 
+  /** Infos before erasure of the generated mixin forwarders.
+   *
+   *  These will be used to generate Java generic signatures of the mixin
+   *  forwarders. Normally we use the types before erasure; we cannot do that
+   *  for mixin forwarders since they are created after erasure, and therefore
+   *  their type history does not have anything recorded for before erasure.
+   */
+  val mixinForwarderGenericInfos = MutableSymbolMap[Type]()
+
   override def phaseName: String = Mixin.name
 
   override def description: String = Mixin.description
@@ -306,8 +316,25 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       for (meth <- mixin.info.decls.toList if needsMixinForwarder(meth))
       yield {
         util.Stats.record("mixin forwarders")
-        transformFollowing(DefDef(mkForwarderSym(meth.asTerm, extraFlags = MixedIn), forwarderRhsFn(meth)))
+        transformFollowing(DefDef(mkMixinForwarderSym(meth.asTerm), forwarderRhsFn(meth)))
+      }
+
+    def mkMixinForwarderSym(target: TermSymbol): TermSymbol =
+      val sym = mkForwarderSym(target, extraFlags = MixedIn)
+      val (infoBeforeErasure, isDifferentThanInfoNow) = atPhase(erasurePhase) {
+        val beforeErasure = cls.thisType.memberInfo(target)
+        (beforeErasure, !(beforeErasure =:= sym.info))
       }
+      if isDifferentThanInfoNow then
+        // The info before erasure would not have been the same as the info now.
+        // We want to store it for the backend to compute the generic Java signature.
+        // However, we must still avoid doing that if erasing that signature would
+        // not give the same erased type. If it doesn't, we'll just give a completely
+        // incorrect Java signature. (This could be improved by generating dedicated
+        // bridges, but we don't go that far; scalac doesn't either.)
+        if TypeErasure.transformInfo(target, infoBeforeErasure) =:= sym.info then
+          mixinForwarderGenericInfos(sym) = infoBeforeErasure
+      sym
 
     cpy.Template(impl)(
       constr =

tests/pos/11484/A_2.java

@@ -0,0 +1 @@
+public class A_2 extends C<String> { }

tests/pos/11484/C_1.scala

@@ -0,0 +1,6 @@
+class B[A]
+sealed trait T[A] {
+  def overloaded(that: List[T[A]]): T[A] = that.head
+  def overloaded(that: List[B[A]]): B[A] = that.head
+}
+abstract class C[A] extends T[A]

tests/pos/11512/A_2.java

@@ -0,0 +1 @@
+public class A_2 extends C { }

tests/pos/11512/C_1.scala

@@ -0,0 +1,7 @@
+trait T { this: U =>
+  def m: Int
+}
+trait U {
+  def m: Int = ???
+}
+abstract class C extends U with T

tests/pos/mixin-generic-extended-by-java/ExtensionId_1.scala

@@ -0,0 +1,18 @@
+trait Extension
+
+class ClassicActorSystemProvider
+
+/**
+ * Identifies an Extension
+ * Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used,
+ * otherwise you'll get the same extension loaded multiple times.
+ */
+trait ExtensionId[T <: Extension] {
+
+  def get(system: ClassicActorSystemProvider): T = ???
+}
+
+/**
+ * Java API for ExtensionId
+ */
+abstract class AbstractExtensionId[T <: Extension] extends ExtensionId[T]

tests/pos/mixin-generic-extended-by-java/JavaExtension_2.java

@@ -0,0 +1,8 @@
+
+public class JavaExtension_2 {
+  static class TestExtensionId extends AbstractExtensionId<TestExtension> {
+  }
+
+  static class TestExtension implements Extension {
+  }
+}

tests/run/t7932.check

@@ -1,5 +1,5 @@
-public Category C.category()
-public Category C.category1()
+public Category<java.lang.Object> C.category()
+public Category<scala.Tuple2> C.category1()
 public abstract Category<?> M2.category3()
 public abstract Category<java.lang.Object> M2.category2()
 public default Category<F> M1.category()