Rename functions

Author: noti0na1

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

@@ -37,12 +37,6 @@ import Types._
  */
 object JavaNullInterop {
 
-  /** Should we try to convert values ignoring Null type at this moment? */
-  def convertUnsafeNulls(using Context): Boolean =
-    ctx.explicitNulls && (
-      config.Feature.enabled(nme.unsafeNulls) ||
-      ctx.mode.is(Mode.UnsafeNullConversion))
-
   /** Transforms the type `tp` of Java member `sym` to be explicitly nullable.
    *  `tp` is needed because the type inside `sym` might not be set when this method is called.
    *

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

@@ -69,10 +69,16 @@ object NullOpsDecorator {
         self.isNullType || self <:< defn.ObjectType
     }
 
+    def isUnsafelyNulltoAnyRef(pt: Type)(using Context): Boolean =
+      self.isNullType && pt.isNullableAfterErasure
+
     /** Can we convert a tree with type `self` to type `pt` unsafely.
      */
-    def isUnsafeConvertable(pt: Type)(using Context): Boolean =
-      (self.isNullType && pt.isNullableAfterErasure) ||
-      (self.stripAllNulls <:< pt.stripAllNulls)
+    def isUnsafelyConvertable(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
+      self.isUnsafelyNulltoAnyRef(pt) ||
+      (if relaxedSubtype then
+        self.stripAllNulls relaxed_<:< pt.stripAllNulls
+      else
+        self.stripAllNulls <:< pt.stripAllNulls)
   }
 }

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

@@ -20,6 +20,12 @@ import ast.Trees.mods
 object Nullables:
   import ast.tpd._
 
+  /** Should we try to convert values ignoring Null type at this moment? */
+  def convertUnsafeNulls(using Context): Boolean =
+    ctx.explicitNulls && (
+      config.Feature.enabled(nme.unsafeNulls) ||
+      ctx.mode.is(Mode.UnsafeNullConversion))
+
   /** A set of val or var references that are known to be not null, plus a set of
    *  variable references that are not known (anymore) to be not null
    */

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

@@ -40,13 +40,11 @@ object ProtoTypes {
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
       (tpw relaxed_<:< ptw) ||
-        ctx.explicitNulls &&
-          // If unsafeNulls is enabled, we relax the condition by striping all nulls from the types
-          // before subtype check. We use Feature to check language feature. However, when we search implicits,
-          // the context is from ContextualImplicits; hence, we don't know whether unsafeNulls is enabled.
-          // We have to add Mode.UnsafeNullConversion before implicit search.
-          (config.Feature.enabled(nme.unsafeNulls) || ctx.mode.is(Mode.UnsafeNullConversion)) &&
-          (tpw.stripAllNulls relaxed_<:< ptw.stripAllNulls) ||
+        // If unsafeNulls is enabled, we relax the condition by striping all nulls from the types
+        // before subtype check. We use Feature to check language feature. However, when we search implicits,
+        // the context is from ContextualImplicits; hence, we don't know whether unsafeNulls is enabled.
+        // We have to add Mode.UnsafeNullConversion before implicit search.
+        Nullables.convertUnsafeNulls && tpw.isUnsafelyConvertable(ptw, true) ||
         viewExists(tp, pt)
 
     /** Like isCompatibe, but using a subtype comparison with necessary eithers
@@ -56,12 +54,12 @@ object ProtoTypes {
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
       necessarySubType(tpw, ptw) || tpw.isValueSubType(ptw) ||
-      ctx.explicitNulls && {
+      Nullables.convertUnsafeNulls && {
         val tpwsn = tpw.stripAllNulls
         val ptwsn = ptw.stripAllNulls
         // See comments in `isCompatible`
-        (config.Feature.enabled(nme.unsafeNulls) || ctx.mode.is(Mode.UnsafeNullConversion)) &&
-        (necessarySubType(tpwsn, ptwsn) || tpwsn.isValueSubType(ptwsn))
+        necessarySubType(tpwsn, ptwsn) || tpwsn.isValueSubType(ptwsn) ||
+          tpwsn.isUnsafelyNulltoAnyRef(ptwsn)
       } ||
       viewExists(tp, pt)
 

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

@@ -1266,7 +1266,7 @@ class Typer extends Namer
               case SAMType(sam)
               if !defn.isFunctionType(pt1) && (
                 mt <:< sam ||
-                JavaNullInterop.convertUnsafeNulls && mt.stripAllNulls <:< sam.stripAllNulls) =>
+                Nullables.convertUnsafeNulls && mt.stripAllNulls <:< sam.stripAllNulls) =>
                 // SAMs of the form C[?] where C is a class cannot be conversion targets.
                 // The resulting class `class $anon extends C[?] {...}` would be illegal,
                 // since type arguments to `C`'s super constructor cannot be constructed.
@@ -3446,7 +3446,7 @@ class Typer extends Namer
           pt1 match {
             case SAMType(sam)
             if wtp <:< sam.toFunctionType() ||
-              (JavaNullInterop.convertUnsafeNulls &&
+              (Nullables.convertUnsafeNulls &&
                 wtp.stripAllNulls <:< sam.toFunctionType().stripAllNulls) =>
               // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
@@ -3521,7 +3521,7 @@ class Typer extends Namer
       def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
         // If explicitNulls and unsafeNulls are enabled, and
         if ctx.mode.is(Mode.UnsafeNullConversion) && pt.isValueType &&
-          treeTpe.isUnsafeConvertable(pt)
+          treeTpe.isUnsafelyConvertable(pt)
         then tree.cast(pt)
         else fail
 
@@ -3544,9 +3544,8 @@ class Typer extends Namer
         if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
           if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
             // We want to allow `null` to `AnyRef` if UnsafeNullConversion is enabled
-            if !(ctx.explicitNulls &&
-              treeTpe.isUnsafeConvertable(pt) &&
-              ctx.mode.is(Mode.UnsafeNullConversion)) then
+            if !(ctx.mode.is(Mode.UnsafeNullConversion) &&
+              treeTpe.isUnsafelyConvertable(pt)) then
               report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
             tree.cast(pt)
           else

docs/docs/internals/explicit-nulls.md

@@ -35,7 +35,7 @@ There are some utility functions for nullable types in `NullOpsDecorator.scala`
   ones (as `stripNull` does).
 - `isNullableUnion` determines whether `this` is a nullable union.
 - `isNullableAfterErasure` determines whether `this` type can have `null` value after erasure.
-- `isUnsafeConvertable` determines whether we can convert `this` type to `pt` unsafely if we ignore `Null` type.
+- `isUnsafelyConvertable` determines whether we can convert `this` type to `pt` unsafely if we ignore `Null` type.
 
 Within `Types.scala`, we also defined an extractor `OrNull` to extract the non-nullable part of a nullable unions .
 
@@ -97,7 +97,7 @@ Since we want to allow selecting member on nullable values, when searching a mem
 During adapting, if the type of the tree is not a subtype of the expected type, the `adaptToSubType` in `Typer.scala` will run. The implicit search is invoked to find conversions for the tree. If `unsafeNulls` is enabled, we use the new search scheme:
 1. If the `tree.tpe` is nullable, we strip `Null` from the tree then search.
 2. If the `tree.tpe` is not nullable or the last step fails, we search on the tree directly.
-3. If the last step fails, we try to cast tree to `pt` if the two types `isUnsafeConvertable`.
+3. If the last step fails, we try to cast tree to `pt` if the two types `isUnsafelyConvertable`.
 
 Since implicit search (finding candidates and trying to type the new tree) could run in some different contexts, we have to pass the `UnsafeNullConversion` mode to the search context.