Modify rule for nullable union types in generic signatures (#24129)

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/core/Types.scala

@@ -1451,7 +1451,7 @@ object Types extends TypeUtils {
      *  then the top-level union isn't widened. This is needed so that type inference can infer nullable types.
      */
     def widenUnion(using Context): Type = widen match
-      case tp: OrType =>
+      case tp: OrType if ctx.explicitNulls =>
         val tp1 = tp.stripNull(stripFlexibleTypes = false)
         if tp1 ne tp then
           val tp1Widen = tp1.widenUnionWithoutNull

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 _ =>

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -176,7 +176,7 @@ trait TypeAssigner {
     val qualType = qual.tpe.widenIfUnstable
     def kind = if tree.isType then "type" else "value"
     val foundWithoutNull = qualType match
-      case OrNull(qualType1) if qualType1 <:< defn.ObjectType =>
+      case OrNull(qualType1) if ctx.explicitNulls && qualType1 <:< defn.ObjectType =>
         val name = tree.name
         val pre = maybeSkolemizePrefix(qualType1, name)
         reallyExists(qualType1.findMember(name, pre))

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -588,11 +588,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    */
   def toNotNullTermRef(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match
     case ref: TermRef
-    if pt != LhsProto && // Ensure it is not the lhs of Assign
-    ctx.notNullInfos.impliesNotNull(ref) &&
-    // If a reference is in the context, it is already trackable at the point we add it.
-    // Hence, we don't use isTracked in the next line, because checking use out of order is enough.
-    !ref.usedOutOfOrder =>
+    if ctx.explicitNulls
+      && pt != LhsProto // Ensure it is not the lhs of Assign
+      && ctx.notNullInfos.impliesNotNull(ref)
+      // If a reference is in the context, it is already trackable at the point we add it.
+      // Hence, we don't use isTracked in the next line, because checking use out of order is enough.
+      && !ref.usedOutOfOrder =>
       ref match
         case OrNull(tpnn) => tree.cast(AndType(ref, tpnn))
         case _            => tree
@@ -2228,7 +2229,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         given Context = caseCtx
         val case1 = typedCase(cas, sel, wideSelType, tpe)
         caseCtx = Nullables.afterPatternContext(sel, case1.pat)
-        if !alreadyStripped && Nullables.matchesNull(case1) then
+        if ctx.explicitNulls && !alreadyStripped && Nullables.matchesNull(case1) then
           wideSelType = wideSelType.stripNull()
           alreadyStripped = true
         case1
@@ -2261,7 +2262,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       given Context = caseCtx
       val case1 = typedCase(cas, sel, wideSelType, pt)
       caseCtx = Nullables.afterPatternContext(sel, case1.pat)
-      if !alreadyStripped && Nullables.matchesNull(case1) then
+      if ctx.explicitNulls && !alreadyStripped && Nullables.matchesNull(case1) then
         wideSelType = wideSelType.stripNull()
         alreadyStripped = true
       case1

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]))