Fix bugs in the PR

Author: noti0na1

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

@@ -6,6 +6,7 @@ import Contexts._
 import Flags._
 import Symbols._
 import Types._
+import transform.SymUtils._
 
 /** Defines operations on nullable types and tree. */
 object NullOpsDecorator:
@@ -80,23 +81,26 @@ object NullOpsDecorator:
       case _          => tree
 
     def tryToCastToCanEqualNull(using Context): Tree =
+      // return the tree directly if not at Typer phase
+      if !(ctx.explicitNulls && ctx.phase.isTyper) then return tree
+
       val sym = tree.symbol
       val tp = tree.tpe
 
       if !ctx.mode.is(Mode.UnsafeJavaReturn)
         || !sym.is(JavaDefined)
-        || sym.is(Package)
+        || sym.isNoValue
         || !sym.isTerm
         || tp.isError then
         return tree
 
       tree match
-        case _: Apply if sym.is(Method) && !sym.isConstructor =>
+        case _: Apply if sym.is(Method) =>
           val tp2 = tp.replaceOrNull
           if tp ne tp2 then
             tree.cast(tp2)
           else tree
-        case _: Select if !sym.is(Method) =>
+        case _: Select | _: Ident if !sym.is(Method) =>
           val tpw = tp.widen
           val tp2 = tpw.replaceOrNull
           if tpw ne tp2 then

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

@@ -547,7 +547,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           ref(ownType).withSpan(tree.span)
         case _ =>
           tree.withType(ownType)
-      val tree2 = toNotNullTermRef(tree1, pt)
+      val tree2 = toNotNullTermRef(tree1, pt).tryToCastToCanEqualNull
       checkLegalValue(tree2, pt)
       tree2
 

tests/explicit-nulls/unsafe-java/JavaStatic.scala

@@ -0,0 +1,14 @@
+import language.unsafeJavaReturn
+
+import java.math.MathContext, MathContext._
+
+val x: MathContext = DECIMAL32
+val y: MathContext = MathContext.DECIMAL32
+
+import java.io.File
+
+val s: String = File.separator
+import java.time.ZoneId
+
+val zids: java.util.Set[String] = ZoneId.getAvailableZoneIds
+val zarr: Array[String] = ZoneId.getAvailableZoneIds.toArray(Array.empty[String | Null])

tests/explicit-nulls/unsafe-java/UnaryCall.scala

@@ -1,4 +1,11 @@
 import scala.language.unsafeJavaReturn
 
-val s = "foo"
-val methods: Array[java.lang.reflect.Method] = s.getClass.getMethods
+import java.lang.reflect.Method
+
+def getMethods(f: String): List[Method] =
+  val clazz = Class.forName(f)
+  val methods = clazz.getMethods
+  if methods == null then List()
+  else methods.toList
+
+def getClass(o: AnyRef): Class[?] = o.getClass

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

@@ -4,4 +4,4 @@ class J1 {
 
 class J2 {
   J1 getJ1() { return new J1(); }
-}
+}

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

@@ -1,4 +1,6 @@
-class S {
+import scala.language.unsafeJavaReturn
+
+def f = {
   val j: J2 = new J2()
-  j.getJ1().getJ2().getJ1().getJ2().getJ1().getJ2() // error
+  j.getJ1().getJ2().getJ1().getJ2().getJ1().getJ2()
 }

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

@@ -1,6 +1,6 @@
 import java.util.List;
 
-public class JC {
+public class J {
 
   public int a;
 
@@ -39,4 +39,4 @@ public <T> List<T> h2() {
   public <T> T[] h3() {
     return null;
   }
-}
+}

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

@@ -3,53 +3,50 @@ import scala.language.unsafeJavaReturn
 import scala.annotation.CanEqualNull
 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 @CanEqualNull = jc.b
-    val b4: 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 @CanEqualNull] @CanEqualNull = jc.c
-    val c4: Array[String] = jc.c
-    val cml: Array[Int] = c.map(_.length())
-
-    val f1: Int = jc.f1()
-
-    val f21: Array[Int] @CanEqualNull = jc.f2()
-    val f22: Array[Int] = jc.f2()
-    val f2n = jc.f2() == null
-
-    val g11: String @CanEqualNull = jc.g1()
-    val g12: String = jc.g1()
-    val g1n = jc.g1() == null
-    val g1tl = jc.g1().trim().length()
-
-    val g21: ju.List[String] @CanEqualNull = jc.g2()
-    val g22: ju.List[String] = jc.g2()
-
-    val g31: Array[String @CanEqualNull] @CanEqualNull = jc.g3()
-    val g32: Array[String] = jc.g3()
-    val g3n = jc.g3() == null
-    val g3m: Array[Boolean] = jc.g3().map(_ == null)
-
-    val h11: T @CanEqualNull = jc.h1[T]()
-    val h12: T = jc.h1[T]()
-    val h1n = jc.h1[T]() == null
-
-    val h21: ju.List[T] @CanEqualNull = jc.h2[T]()
-    val h22: ju.List[T] = jc.h2[T]()
-
-    val h31: Array[T @CanEqualNull] @CanEqualNull = jc.h3[T]()
-    val h32: Array[T] = jc.h3[T]()
-    val h3m = jc.h3[T]().map(_ == null)
-  }
-}
+def test[T <: AnyRef](j: J) = {
+  val a: Int = j.a
+
+  val b = j.b // it returns String @CanEqualNull
+  val b2: String = b
+  val b3: String @CanEqualNull = j.b
+  val b4: String = j.b
+  val bb = j.b == null // it's ok to compare String @CanEqualNull with Null
+  val btl = j.b.trim().length() // String @CanEqualNull is just String, unsafe selecting
+
+  val c = j.c
+  val cl = c.length
+  val c2: Array[String] = c
+  val c3: Array[String @CanEqualNull] @CanEqualNull = j.c
+  val c4: Array[String] = j.c
+  val cml: Array[Int] = c.map(_.length())
+
+  val f1: Int = j.f1()
+
+  val f21: Array[Int] @CanEqualNull = j.f2()
+  val f22: Array[Int] = j.f2()
+  val f2n = j.f2() == null
+
+  val g11: String @CanEqualNull = j.g1()
+  val g12: String = j.g1()
+  val g1n = j.g1() == null
+  val g1tl = j.g1().trim().length()
+
+  val g21: ju.List[String] @CanEqualNull = j.g2()
+  val g22: ju.List[String] = j.g2()
+
+  val g31: Array[String @CanEqualNull] @CanEqualNull = j.g3()
+  val g32: Array[String] = j.g3()
+  val g3n = j.g3() == null
+  val g3m: Array[Boolean] = j.g3().map(_ == null)
+
+  val h11: T @CanEqualNull = j.h1[T]()
+  val h12: T = j.h1[T]()
+  val h1n = j.h1[T]() == null
+
+  val h21: ju.List[T] @CanEqualNull = j.h2[T]()
+  val h22: ju.List[T] = j.h2[T]()
+
+  val h31: Array[T @CanEqualNull] @CanEqualNull = j.h3[T]()
+  val h32: Array[T] = j.h3[T]()
+  val h3m = j.h3[T]().map(_ == null)
+}