Fix generic signature for type params bounded by primitive

Author: dwijnand

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

@@ -5,16 +5,19 @@ package transform
 import core.Annotations._
 import core.Contexts._
 import core.Phases._
+import core.Decorators.*
 import core.Definitions
 import core.Flags._
 import core.Names.Name
 import core.Symbols._
 import core.TypeApplications.{EtaExpansion, TypeParamInfo}
-import core.TypeErasure.{erasedGlb, erasure, isGenericArrayElement}
+import core.TypeErasure.{erasedGlb, erasure, fullErasure, isGenericArrayElement}
 import core.Types._
 import core.classfile.ClassfileConstants
 import SymUtils._
 import TypeUtils._
+import config.Printers.transforms
+import reporting.trace
 import java.lang.StringBuilder
 
 import scala.collection.mutable.ListBuffer
@@ -130,15 +133,17 @@ object GenericSignatures {
           else
             Right(parent))
 
-    def paramSig(param: LambdaParam): Unit = {
-      builder.append(sanitizeName(param.paramName))
+    def paramSig(param: TypeParamInfo): Unit = {
+      builder.append(sanitizeName(param.paramName.lastPart))
       boundsSig(hiBounds(param.paramInfo.bounds))
     }
 
-    def polyParamSig(tparams: List[LambdaParam]): Unit =
-      if (tparams.nonEmpty) {
+    def polyParamSig(tparams: List[TypeParamInfo]): Unit =
+      // remove type parameters that are upper-bounded by primitive types (including via a value class)
+      val tparams1 = tparams.filter(p => !fullErasure(p.paramInfo.bounds.hi).isPrimitiveValueType)
+      if (tparams1.nonEmpty) {
         builder.append('<')
-        tparams.foreach(paramSig)
+        tparams1.foreach(paramSig)
         builder.append('>')
       }
 
@@ -236,7 +241,11 @@ object GenericSignatures {
       tp match {
 
         case ref @ TypeParamRef(_: PolyType, _) =>
-          typeParamSig(ref.paramName.lastPart)
+          val erasedUnderlying = fullErasure(ref.underlying.bounds.hi)
+          // don't emit type param name if the param is upper-bounded by a primitive type (including via a value class)
+          if erasedUnderlying.isPrimitiveValueType then
+            jsig(erasedUnderlying, toplevel, primitiveOK)
+          else typeParamSig(ref.paramName.lastPart)
 
         case defn.ArrayOf(elemtp) =>
           if (isGenericArrayElement(elemtp, isScala2 = false))
@@ -263,11 +272,11 @@ object GenericSignatures {
           else if (sym == defn.NullClass)
             builder.append("Lscala/runtime/Null$;")
           else if (sym.isPrimitiveValueClass)
-            if (!primitiveOK) jsig(defn.ObjectType)
+            if (!primitiveOK) ()
             else if (sym == defn.UnitClass) jsig(defn.BoxedUnitClass.typeRef)
             else builder.append(defn.typeTag(sym.info))
           else if (ValueClasses.isDerivedValueClass(sym)) {
-            val erasedUnderlying = core.TypeErasure.fullErasure(tp)
+            val erasedUnderlying = fullErasure(tp)
             if (erasedUnderlying.isPrimitiveValueType && !primitiveOK)
               classSig(sym, pre, args)
             else
@@ -334,15 +343,6 @@ object GenericSignatures {
           jsig(repr, primitiveOK = primitiveOK)
 
         case ci: ClassInfo =>
-          def polyParamSig(tparams: List[TypeParamInfo]): Unit =
-            if (tparams.nonEmpty) {
-              builder.append('<')
-              tparams.foreach { tp =>
-                builder.append(sanitizeName(tp.paramName.lastPart))
-                boundsSig(hiBounds(tp.paramInfo.bounds))
-              }
-              builder.append('>')
-            }
           val tParams = tp.typeParams
           if (toplevel) polyParamSig(tParams)
           superSig(ci.typeSymbol, ci.parents)

tests/generic-java-signatures/i15385/Lib.scala

@@ -0,0 +1,14 @@
+class Loc(val idx: Int) extends AnyVal
+
+class Foo:
+  def testNoParam[A <: Int]: A = 1.asInstanceOf[A] // ()I
+  def testSingleParam[A <: Int](a: A): A = 2.asInstanceOf[A] // (I)I
+  def testOtherReturn[A <: Int](a: A): String = "3" // (I)Ljava/lang/String;
+  def testNoErasure[A <: String](a: A): A = "4".asInstanceOf[A] // (Ljava/lang/String;)Ljava/lang/String;
+  def testMultiParam[A <: Int, B <: String](a: A, b: B): A = 5.asInstanceOf[A] // (ILjava/lang/String;)I
+
+  def testVCNoParam[A <: Loc]: A = Loc(1).asInstanceOf[A]
+  def testVCSingleParam[A <: Loc](a: A): A = Loc(2).asInstanceOf[A]
+  def testVCOtherReturn[A <: Loc](a: A): String = "3"
+  def testVCNoErasure[A <: String](a: A): A = "4".asInstanceOf[A]
+  def testVCMultiParam[A <: Loc, B <: String](a: A, b: B): A = Loc(5).asInstanceOf[A]

tests/generic-java-signatures/i15385/Test.java

@@ -0,0 +1,16 @@
+public class Test {
+    public static void main(String[] args) throws Exception {
+        Foo foo = new Foo();
+        System.out.println(foo.testNoParam());
+        System.out.println(foo.testSingleParam(2));
+        System.out.println(foo.testOtherReturn(3));
+        System.out.println(foo.testNoErasure("4"));
+        System.out.println(foo.testMultiParam(5, "5"));
+
+        System.out.println(foo.testVCNoParam());
+        System.out.println(foo.testVCSingleParam(2));
+        System.out.println(foo.testVCOtherReturn(3));
+        System.out.println(foo.testVCNoErasure("4"));
+        System.out.println(foo.testVCMultiParam(5, "5"));
+    }
+}