Seperate Java Compatible part

Author: noti0na1

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

@@ -170,7 +170,6 @@ 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

@@ -478,8 +478,6 @@ object Contexts {
     /** Is the explicit nulls option set? */
     def explicitNulls: Boolean = base.settings.YexplicitNulls.value
 
-    def explicitNullsJavaCompatible: Boolean = base.settings.YexplicitNullsJavaCompatible.value
-
     /** Initialize all context fields, except typerState, which has to be set separately
      *  @param  outer   The outer context
      *  @param  origin  The context from which fields are copied

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

@@ -114,6 +114,4 @@ object Mode {
   val QuotedPattern: Mode = newMode(25, "QuotedPattern")
 
   val UnsafeNullConversion: Mode = newMode(26, "UnsafeNullConversion")
-
-  val UnsafeNullConversionJava: Mode = newMode(27, "UnsafeNullConversionJava")
 }

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

@@ -739,13 +739,11 @@ object Types {
         go(l).meet(go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
 
       def goOr(tp: OrType) = tp match {
-        case OrNull(tp1) if ctx.explicitNullsJavaCompatible || config.Feature.enabled(nme.unsafeNulls) =>
+        case OrNull(tp1) if 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.
           val d = tp1.findMember(name, pre.stripNull, required, excluded)
-          if config.Feature.enabled(nme.unsafeNulls) ||
-            (ctx.explicitNullsJavaCompatible && d.symbol.is(JavaDefined))
-          then d
+          if config.Feature.enabled(nme.unsafeNulls) then d
           else go(tp.join)
         case _ =>
           // we need to keep the invariant that `pre <: tp`. Branch `union-types-narrow-prefix`

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

@@ -889,14 +889,7 @@ trait Applications extends Compatibility {
       def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
         methPart(fun1).tpe match {
           case funRef: TermRef =>
-            val argsCtx =
-              if ctx.explicitNulls && ctx.explicitNullsJavaCompatible then
-                if funRef.symbol.is(JavaDefined) then
-                  ctx.addMode(Mode.UnsafeNullConversionJava)
-                else
-                  ctx.retractMode(Mode.UnsafeNullConversionJava)
-              else ctx
-            val app = ApplyTo(tree, fun1, funRef, proto, pt)(using argsCtx)
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)
             convertNewGenericArray(
               postProcessByNameArgs(funRef, app).computeNullable())
           case _ =>

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

@@ -364,23 +364,16 @@ object ProtoTypes {
     /** Type single argument and remember the unadapted result in `myTypedArg`.
      *  used to avoid repeated typings of trees when backtracking.
      */
-    def typedArg(arg: untpd.Tree, formal: Type)(using Context): Tree = {
+     def typedArg(arg: untpd.Tree, formal: Type)(using Context): Tree = {
       val wideFormal = formal.widenExpr
-      val javaCallUnsafeNull = ctx.mode.is(Mode.UnsafeNullConversionJava)
       val argCtx =
         if wideFormal eq formal then ctx
         else ctx.withNotNullInfos(ctx.notNullInfos.retractMutables)
-      val adaptCtx = if javaCallUnsafeNull then ctx.addMode(Mode.UnsafeNullConversion) else ctx
       val locked = ctx.typerState.ownedVars
-      val targ = if javaCallUnsafeNull then
-        cacheTypedArg(arg,
-          typer.typedUnadaptedWithBlock(_, wideFormal, locked)(using argCtx.retractMode(Mode.UnsafeNullConversionJava)),
-          force = true)
-      else
-        cacheTypedArg(arg,
-          typer.typedUnadapted(_, wideFormal, locked)(using argCtx),
-          force = true)
-      typer.adapt(targ, wideFormal, locked)(using adaptCtx)
+      val targ = cacheTypedArg(arg,
+        typer.typedUnadapted(_, wideFormal, locked)(using argCtx),
+        force = true)
+      typer.adapt(targ, wideFormal, locked)
     }
 
     /** The type of the argument `arg`, or `NoType` if `arg` has not been typed before

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

@@ -3567,13 +3567,8 @@ class Typer extends Namer
           tree
         else recover(failure.reason)
 
-      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
+        if ctx.explicitNulls && config.Feature.enabled(nme.unsafeNulls) then
           ctx.addMode(Mode.UnsafeNullConversion)
         else ctx