Modify generation for nullable union types in generic signatures

Author: noti0na1

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

@@ -42,7 +42,7 @@ object NullOpsDecorator:
         }
         if tpStripped ne tpWiden then tpStripped else tp
 
-      if ctx.explicitNulls then strip(self) else self
+      strip(self)
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */

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

@@ -304,6 +304,12 @@ object GenericSignatures {
           builder.append(')')
           methodResultSig(rte)
 
+        case OrNull(tp1) if !tp1.derivesFrom(defn.AnyValClass) =>
+          // Special case for nullable union types whose underlying type is not a value class.
+          // For example, `T | Null` where `T` is a type parameter becomes `T` in the signature;
+          // `Int | Null` still becomes `Object`.
+          jsig1(tp1)
+
         case tp: AndType =>
           // Only intersections appearing as the upper-bound of a type parameter
           // can be preserved in generic signatures and those are already
@@ -455,15 +461,15 @@ object GenericSignatures {
       else x
   }
 
-  private def collectMethodParams(mtd: MethodOrPoly)(using Context): (List[TypeParamInfo], List[Type], Type) = 
+  private def collectMethodParams(mtd: MethodOrPoly)(using Context): (List[TypeParamInfo], List[Type], Type) =
     val tparams = ListBuffer.empty[TypeParamInfo]
     val vparams = ListBuffer.empty[Type]
 
     @tailrec def recur(tpe: Type): Type = tpe match
       case mtd: MethodType =>
         vparams ++= mtd.paramInfos.filterNot(_.hasAnnotation(defn.ErasedParamAnnot))
         recur(mtd.resType)
-      case PolyType(tps, tpe) => 
+      case PolyType(tps, tpe) =>
         tparams ++= tps
         recur(tpe)
       case _ =>

tests/generic-java-signatures/nullable-unions.check

@@ -0,0 +1,5 @@
+f1(A): A
+f2(A): A
+g1(T): T
+g2(T): T
+i(java.lang.Object): java.lang.Object

tests/generic-java-signatures/nullable-unions.scala

@@ -0,0 +1,21 @@
+class C[T]:
+  def f1[A](a: A | Null): A | Null = ???
+  def f2[A](a: A): A = ???
+  def g1(a: T | Null): T | Null = ???
+  def g2(a: T): T = ???
+  def i(a: Int | Null): Int | Null = ???
+
+object Test:
+
+  def printGenericSignature(m: java.lang.reflect.Method): Unit =
+    val tpe = m.getGenericParameterTypes().map(_.getTypeName).mkString(", ")
+    val ret = m.getGenericReturnType().getTypeName
+    println(s"${m.getName}($tpe): $ret")
+    
+  def main(args: Array[String]): Unit =
+    val c = classOf[C[_]]
+    printGenericSignature(c.getDeclaredMethod("f1", classOf[Object]))
+    printGenericSignature(c.getDeclaredMethod("f2", classOf[Object]))
+    printGenericSignature(c.getDeclaredMethod("g1", classOf[Object]))
+    printGenericSignature(c.getDeclaredMethod("g2", classOf[Object]))
+    printGenericSignature(c.getDeclaredMethod("i", classOf[Object]))