Add Java Compatible Mode

Author: noti0na1

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -168,6 +168,7 @@ class ScalaSettings extends Settings.SettingGroup {
   // Extremely experimental language features
   val YnoKindPolymorphism: Setting[Boolean] = BooleanSetting("-Yno-kind-polymorphism", "Disable kind polymorphism.")
   val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
+  val YexplicitNullsJavaCompatible: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls-java", "explicit-nulls-java")
   val YerasedTerms: Setting[Boolean] = BooleanSetting("-Yerased-terms", "Allows the use of erased terms.")
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ycheck-init", "Check initialization of objects")
 

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

@@ -451,6 +451,8 @@ object Contexts {
     /** Is the explicit nulls option set? */
     def explicitNulls: Boolean = base.settings.YexplicitNulls.value
 
+    def explicitNullsJavaCompatible: Boolean = base.settings.YexplicitNullsJavaCompatible.value
+
     protected def init(outer: Context, origin: Context): this.type = {
       util.Stats.record("Context.fresh")
       _outer = outer

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

@@ -730,10 +730,14 @@ object Types {
         go(l).meet(go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
 
       def goOr(tp: OrType) = tp match {
-        case OrNull(tp1) if config.Feature.enabled(nme.unsafeNulls) =>
+        case OrNull(tp1) if ctx.explicitNullsJavaCompatible || config.Feature.enabled(nme.unsafeNulls) =>
           // Selecting `name` from a type `T | Null` is like selecting `name` from `T`, if
           // unsafeNulls is enabled. This can throw at runtime, but we trade soundness for usability.
-          tp1.findMember(name, pre.stripNull, required, excluded)
+          val d = tp1.findMember(name, pre.stripNull, required, excluded)
+          if config.Feature.enabled(nme.unsafeNulls) ||
+            (ctx.explicitNullsJavaCompatible && d.symbol.is(JavaDefined))
+          then d
+          else go(tp.join)
         case _ =>
           // we need to keep the invariant that `pre <: tp`. Branch `union-types-narrow-prefix`
           // achieved that by narrowing `pre` to each alternative, but it led to merge errors in

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

@@ -889,7 +889,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)
+            val argsCtx =
+              if ctx.explicitNulls && ctx.explicitNullsJavaCompatible then
+                if funRef.symbol.is(JavaDefined) then
+                  ctx.addMode(Mode.UnsafeNullConversion)
+                else
+                  ctx.retractMode(Mode.UnsafeNullConversion)
+              else ctx
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)(using argsCtx)
             convertNewGenericArray(
               postProcessByNameArgs(funRef, app).computeNullable())
           case _ =>

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

@@ -3470,12 +3470,11 @@ class Typer extends Namer
         }
       }
 
-      def tryUnsafeNullConver(fail: => Tree): Tree =
+      def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
         // If explicitNulls and unsafeNulls are enabled, and
-        if ctx.explicitNulls && config.Feature.enabled(nme.unsafeNulls) &&
-          tree.tpe.isUnsafeConvertable(pt) then {
-            tree.cast(pt)
-          }
+        if ctx.mode.is(Mode.UnsafeNullConversion) && pt.isValueType &&
+          tree.tpe.isUnsafeConvertable(pt)
+        then tree.cast(pt)
         else fail
 
       def cannotFind(failure: SearchFailure) =
@@ -3488,21 +3487,31 @@ class Typer extends Namer
           tree
         else recover(failure.reason)
 
-      if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
-        if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
-          ctx.error(em"the result of an implicit conversion must be more specific than $pt", tree.sourcePos)
-        val searchCtx = if config.Feature.enabled(nme.unsafeNulls)
-          then ctx.addMode(Mode.UnsafeNullConversion)
-          else ctx
-        tree.tpe match {
-          case OrNull(tpe1) if ctx.explicitNulls && config.Feature.enabled(nme.unsafeNulls) =>
-            searchTree(tree.cast(tpe1)) { _ =>
-              searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))(using searchCtx)
-            }(using searchCtx)
-          case _ =>
-            searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))(using searchCtx)
-        }
-      else tryUnsafeNullConver(recover(NoMatchingImplicits))
+      def process(using Context): Tree = {
+        if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
+          if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
+            ctx.error(em"the result of an implicit conversion must be more specific than $pt", tree.sourcePos)
+          tree.tpe match {
+            case OrNull(tpe1) if ctx.explicitNulls && config.Feature.enabled(nme.unsafeNulls) =>
+              searchTree(tree.cast(tpe1)) { _ =>
+                searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
+              }
+            case _ =>
+              searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
+          }
+        else tryUnsafeNullConver(recover(NoMatchingImplicits))
+      }
+
+      val javaCompatibleCall = ctx.explicitNullsJavaCompatible && (tree match {
+        case Apply(_, _) => tree.symbol.is(JavaDefined)
+        case _ => false
+      })
+      val searchCtx =
+        if ctx.explicitNulls && (javaCompatibleCall || config.Feature.enabled(nme.unsafeNulls)) then
+          ctx.addMode(Mode.UnsafeNullConversion)
+        else ctx
+
+      process(using searchCtx)
     }
 
     def adaptType(tp: Type): Tree = {