Add unsafeJavaReturn

Author: noti0na1

compiler/src/dotty/tools/dotc/Run.scala

@@ -365,8 +365,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       .setTyper(new Typer)
       .addMode(Mode.ImplicitsEnabled)
       .setTyperState(ctx.typerState.fresh(ctx.reporter))
-    if ctx.settings.YexplicitNulls.value && !Feature.enabledBySetting(nme.unsafeNulls) then
-      start = start.addMode(Mode.SafeNulls)
+    if ctx.settings.YexplicitNulls.value then
+      if !Feature.enabledBySetting(nme.unsafeNulls) then
+        start = start.addMode(Mode.SafeNulls)
+      if Feature.enabledBySetting(nme.unsafeJavaReturn) then
+        start = start.addMode(Mode.UnsafeJavaReturn)
     ctx.initialize()(using start) // re-initialize the base context with start
 
     // `this` must be unchecked for safe initialization because by being passed to setRun during

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

@@ -642,12 +642,19 @@ object Contexts {
     def setProfiler(profiler: Profiler): this.type = updateStore(profilerLoc, profiler)
     def setNotNullInfos(notNullInfos: List[NotNullInfo]): this.type = updateStore(notNullInfosLoc, notNullInfos)
     def setImportInfo(importInfo: ImportInfo): this.type =
-      importInfo.mentionsFeature(nme.unsafeNulls) match
-        case Some(true) =>
-          setMode(this.mode &~ Mode.SafeNulls)
-        case Some(false) if ctx.settings.YexplicitNulls.value =>
-          setMode(this.mode | Mode.SafeNulls)
-        case _ =>
+      if ctx.settings.YexplicitNulls.value then
+        importInfo.mentionsFeature(nme.unsafeNulls) match
+          case Some(true) =>
+            setMode(this.mode &~ Mode.SafeNulls)
+          case Some(false)  =>
+            setMode(this.mode | Mode.SafeNulls)
+          case _ =>
+        importInfo.mentionsFeature(nme.unsafeJavaReturn) match
+          case Some(true) =>
+            setMode(this.mode | Mode.UnsafeJavaReturn)
+          case Some(false) =>
+            setMode(this.mode &~ Mode.UnsafeJavaReturn)
+          case _ =>
       updateStore(importInfoLoc, importInfo)
     def setTypeAssigner(typeAssigner: TypeAssigner): this.type = updateStore(typeAssignerLoc, typeAssigner)
 

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

@@ -989,6 +989,7 @@ class Definitions {
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
   @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
   @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
+  @tu lazy val CanEqualNullAnnot: ClassSymbol = requiredClass("scala.annotation.CanEqualNull")
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 

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

@@ -129,4 +129,6 @@ object Mode {
    *  Type `Null` becomes a subtype of non-primitive value types in TypeComparer.
    */
   val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
+
+  val UnsafeJavaReturn: Mode = newMode(31, "UnsafeJavaReturn")
 }

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

@@ -1,7 +1,9 @@
 package dotty.tools.dotc
 package core
 
+import Annotations._
 import Contexts._
+import Symbols._
 import Types._
 
 /** Defines operations on nullable types and tree. */
@@ -42,6 +44,18 @@ object NullOpsDecorator:
       if ctx.explicitNulls then strip(self) else self
     }
 
+    def replaceOrNull(using Context): Type =
+      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 _ => 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

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

@@ -612,6 +612,7 @@ object StdNames {
     val unapplySeq: N           = "unapplySeq"
     val unbox: N                = "unbox"
     val universe: N             = "universe"
+    val unsafeJavaReturn: N     = "unsafeJavaReturn"
     val unsafeNulls: N          = "unsafeNulls"
     val update: N               = "update"
     val updateDynamic: N        = "updateDynamic"

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

@@ -25,6 +25,7 @@ import reporting._
 import transform.TypeUtils._
 import transform.SymUtils._
 import Nullables._
+import NullOpsDecorator._
 import config.Feature
 
 import collection.mutable
@@ -908,7 +909,14 @@ trait Applications extends Compatibility {
       def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
         methPart(fun1).tpe match {
           case funRef: TermRef =>
-            val app = ApplyTo(tree, fun1, funRef, proto, pt)
+            var app = ApplyTo(tree, fun1, funRef, proto, pt)
+            if ctx.mode.is(Mode.UnsafeJavaReturn) then
+              val funSym = fun1.symbol
+              if funSym.is(JavaDefined) && !funSym.isConstructor then
+                val rtp1 = app.tpe
+                val rtp2 = rtp1.replaceOrNull
+                if rtp1 ne rtp2 then
+                  app = app.cast(rtp2)
             convertNewGenericArray(
               widenEnumCase(
                 postProcessByNameArgs(funRef, app).computeNullable(),

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

@@ -148,7 +148,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           }
 
     /** Is an `CanEqual[cls1, cls2]` instance assumed for predefined classes `cls1`, cls2`? */
-    def canComparePredefinedClasses(cls1: ClassSymbol, cls2: ClassSymbol): Boolean =
+    def canComparePredefinedClasses(cls1: ClassSymbol, cls2: ClassSymbol)(using Context): Boolean =
 
       def cmpWithBoxed(cls1: ClassSymbol, cls2: ClassSymbol) =
         cls2 == defn.NothingClass
@@ -173,7 +173,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         // val x: String = null.asInstanceOf[String]
         // if (x == null) {} // error: x is non-nullable
         // if (x.asInstanceOf[String|Null] == null) {} // ok
-        cls1 == defn.NullClass && cls1 == cls2
+        if cls1 == defn.NullClass then cls1 == cls2
+        else cls1 == defn.NothingClass || cls2 == defn.NothingClass
       else if cls1 == defn.NullClass then
         cls1 == cls2 || cls2.derivesFrom(defn.ObjectClass)
       else if cls2 == defn.NullClass then
@@ -187,9 +188,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       *  interpret.
       */
     def canComparePredefined(tp1: Type, tp2: Type) =
+      val checkCtx = if ctx.explicitNulls
+        && (tp1.hasAnnotation(defn.CanEqualNullAnnot) || tp2.hasAnnotation(defn.CanEqualNullAnnot))
+        then ctx.retractMode(Mode.SafeNulls) else ctx
       tp1.classSymbols.exists(cls1 =>
         tp2.classSymbols.exists(cls2 =>
-          canComparePredefinedClasses(cls1, cls2)))
+          canComparePredefinedClasses(cls1, cls2)(using checkCtx)))
 
     formal.argTypes match
       case args @ (arg1 :: arg2 :: Nil) =>

library/src/scala/annotation/CanEqualNull.scala

@@ -0,0 +1,3 @@
+package scala.annotation
+
+final class CanEqualNull extends StaticAnnotation

library/src/scala/runtime/stdLibPatches/language.scala

@@ -128,6 +128,9 @@ object language:
   @compileTimeOnly("`unsafeNulls` can only be used at compile time in import statements")
   object unsafeNulls
 
+  @compileTimeOnly("`unsafeJavaReturn` can only be used at compile time in import statements")
+  object unsafeJavaReturn
+
   @compileTimeOnly("`future` can only be used at compile time in import statements")
   object future