Add comment

Author: noti0na1

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

@@ -44,18 +44,24 @@ object NullOpsDecorator:
       if ctx.explicitNulls then strip(self) else self
     }
 
+    /** Strips `|Null` from the return type of a Java method,
+     *  replacing it with a `@CanEqualNull` annotation
+     */
     def replaceOrNull(using Context): Type =
+      // Since this method should only be called on types from Java,
+      // handling these cases is enough.
       def recur(tp: Type): Type = tp match
         case tp @ OrType(lhs, rhs) if rhs.isNullType =>
           AnnotatedType(recur(lhs), Annotation(defn.CanEqualNullAnnot))
         case tp: AndOrType =>
           tp.derivedAndOrType(recur(tp.tp1), recur(tp.tp2))
         case tp @ AppliedType(tycon, targs) =>
           tp.derivedAppliedType(tycon, targs.map(recur))
+        case mptp: MethodOrPoly =>
+          mptp.derivedLambdaType(resType = recur(mptp.resType))
         case _ => tp
       if ctx.explicitNulls then recur(self) else self
 
-
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
     def isNullableUnion(using Context): Boolean = {
       val stripped = self.stripNull

tests/explicit-nulls/unsafe-java-common/java-chain/J.java

@@ -0,0 +1,7 @@
+class J1 {
+  J2 getJ2() { return new J2(); }
+}
+
+class J2 {
+  J1 getJ1() { return new J1(); }
+}

tests/explicit-nulls/unsafe-java-common/java-chain/S.scala

@@ -0,0 +1,4 @@
+class S {
+  val j: J2 = new J2()
+  j.getJ1().getJ2().getJ1().getJ2().getJ1().getJ2() // error
+}

tests/explicit-nulls/unsafe-java-common/java-class/J.java

@@ -0,0 +1,42 @@
+import java.util.List;
+
+public class JC {
+
+  public int a;
+
+  public String b;
+
+  public String[] c;
+
+  public int f1() {
+    return 0;
+  }
+
+  public int[] f2() {
+    return null;
+  }
+
+  public String g1() {
+    return null;
+  }
+
+  public List<String> g2() {
+    return null;
+  }
+
+  public String[] g3() {
+    return null;
+  }
+
+  public <T> T h1() {
+    return null;
+  }
+
+  public <T> List<T> h2() {
+    return null;
+  }
+
+  public <T> T[] h3() {
+    return null;
+  }
+}

tests/explicit-nulls/unsafe-java-common/java-class/S.scala

@@ -0,0 +1,41 @@
+import scala.language.unsafeJavaReturn
+import java.{util => ju}
+
+class S {
+
+  def test[T <: AnyRef](jc: JC) = {
+    // val a: Int = jc.a
+
+    // val b = jc.b // it returns String @CanEqualNull
+    // val b2: String = b
+    // val b3: String = jc.b
+    // val bb = jc.b == null // it's ok to compare String @CanEqualNull with Null
+    // val btl = jc.b.trim().length() // String @CanEqualNull is just String, unsafe selecting
+
+    // val c = jc.c
+    // val cl = c.length
+    // val c2: Array[String] = c
+    val c3: Array[String] = jc.c
+    // val c4: Array[Int] = c.map(_.length())
+
+    // val f1: Int = jc.f1()
+    // val f2: Array[Int] = jc.f2()
+    // val f2n = jc.f2() == null
+
+    // val g1: String = jc.g1()
+    // val g1n = jc.g1() == null
+    // val g1tl = jc.g1().trim().length()
+
+    // val g2h: ju.List[String] = jc.g2()
+
+    // val g3: Array[String] = jc.g3()
+    // val g3n = jc.g3() == null
+    // val g3m: Array[Boolean] = jc.g3().map(_ == null)
+
+    // val h1: T = jc.h1[T]()
+
+    // val h2: ju.List[T] = jc.h2()
+
+    // val h3: Array[T] = jc.h3()
+  }
+}