Fix unary function call

Author: noti0na1

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

@@ -3,6 +3,7 @@ package core
 
 import Annotations._
 import Contexts._
+import Flags._
 import Symbols._
 import Types._
 
@@ -71,10 +72,36 @@ object NullOpsDecorator:
 
   import ast.tpd._
 
-  extension (self: Tree)
+  extension (tree: Tree)
+
     // cast the type of the tree to a non-nullable type
-    def castToNonNullable(using Context): Tree = self.typeOpt match {
-      case OrNull(tp) => self.cast(tp)
-      case _ => self
-    }
+    def castToNonNullable(using Context): Tree = tree.typeOpt match
+      case OrNull(tp) => tree.cast(tp)
+      case _          => tree
+
+    def tryToCastToCanEqualNull(using Context): Tree =
+      val sym = tree.symbol
+      val tp = tree.tpe
+
+      if !ctx.mode.is(Mode.UnsafeJavaReturn)
+        || !sym.is(JavaDefined)
+        || sym.is(Package)
+        || !sym.isTerm
+        || tp.isError then
+        return tree
+
+      tree match
+        case _: Apply if sym.is(Method) && !sym.isConstructor =>
+          val tp2 = tp.replaceOrNull
+          if tp ne tp2 then
+            tree.cast(tp2)
+          else tree
+        case _: Select if !sym.is(Method) =>
+          val tpw = tp.widen
+          val tp2 = tpw.replaceOrNull
+          if tpw ne tp2 then
+            tree.cast(tp2)
+          else tree
+        case _ => tree
+
 end NullOpsDecorator

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

@@ -909,19 +909,7 @@ trait Applications extends Compatibility {
       def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
         methPart(fun1).tpe match {
           case funRef: TermRef =>
-            var app = ApplyTo(tree, fun1, funRef, proto, pt)
-            if ctx.mode.is(Mode.UnsafeJavaReturn) then
-              // When UnsafeJavaReturn is enabled and the applied function is Java defined,
-              // we replece `| Null` with `@CanEqualNull` in the return type.
-              val funSym = fun1.symbol
-              if funSym.is(JavaDefined)
-                && funSym.isTerm
-                && funSym.is(Method)
-                && !funSym.isConstructor then
-                val rtp1 = app.tpe
-                val rtp2 = rtp1.replaceOrNull
-                if rtp1 ne rtp2 then
-                  app = app.cast(rtp2)
+            val app = ApplyTo(tree, fun1, funRef, proto, pt).tryToCastToCanEqualNull
             convertNewGenericArray(
               widenEnumCase(
                 postProcessByNameArgs(funRef, app).computeNullable(),

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

@@ -646,18 +646,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     def typeSelectOnTerm(using Context): Tree =
       val qual = typedExpr(tree.qualifier, shallowSelectionProto(tree.name, pt, this))
-      var sel = typedSelect(tree, pt, qual).withSpan(tree.span).computeNullable()
-      if ctx.mode.is(Mode.UnsafeJavaReturn) && pt != AssignProto then
-        // When UnsafeJavaReturn is enabled and the selected member is Java defined,
-        // we replece `| Null` with `@CanEqualNull` in its type
-        // if it is not at left hand side of assignments.
-        val sym = sel.symbol
-        if sym.is(JavaDefined) && sym.isTerm && !sym.is(Method) then
-          val stp1 = sel.tpe.widen
-          val stp2 = stp1.replaceOrNull
-          if stp1 ne stp2 then
-            sel = sel.cast(stp2)
-      sel
+      val sel = typedSelect(tree, pt, qual).withSpan(tree.span).computeNullable()
+      if pt != AssignProto then sel.tryToCastToCanEqualNull else sel
 
     def javaSelectOnType(qual: Tree)(using Context) =
       // semantic name conversion for `O$` in java code
@@ -3690,7 +3680,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           }
         simplify(typed(etaExpand(tree, wtp, arity), pt), pt, locked)
       else if (wtp.paramInfos.isEmpty && isAutoApplied(tree.symbol))
-        readaptSimplified(tpd.Apply(tree, Nil))
+        val app = tpd.Apply(tree, Nil).tryToCastToCanEqualNull
+        readaptSimplified(app)
       else if (wtp.isImplicitMethod)
         err.typeMismatch(tree, pt)
       else

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

@@ -0,0 +1,4 @@
+import scala.language.unsafeJavaReturn
+
+val s = "foo"
+val methods: Array[java.lang.reflect.Method] = s.getClass.getMethods