Optimize unsafe nulls subtype test

Author: noti0na1

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

@@ -61,6 +61,9 @@ object Feature:
   def dynamicsEnabled(using Context): Boolean =
     enabled(nme.dynamics)
 
+  def unsafeNullsEnabled(using Context) = 
+    ctx.explicitNulls && enabled(nme.unsafeNulls)
+
   def dependentEnabled(using Context) =
     enabled(dependent, defn.LanguageExperimentalModule.moduleClass)
 

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

@@ -119,4 +119,7 @@ object Mode {
 
   /** Should we try to convert values ignoring Null type? */
   val UnsafeNullConversion: Mode = newMode(27, "UnsafeNullConversion")
+
+  /** Unsafe Nulls SubType */
+  val UnsafeNullsSubType: Mode = newMode(28, "UnsafeNullsSubType")
 }

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

@@ -59,6 +59,7 @@ object NullOpsDecorator {
     }
 
     /** Can the type has null value after erasure?
+     *  TODO
      */
     def isNullableAfterErasure(using Context): Boolean =  self match {
       case tp: ClassInfo => tp.cls.isNullableClassAfterErasure
@@ -69,20 +70,20 @@ object NullOpsDecorator {
         self.isNullType || self <:< defn.ObjectType
     }
 
-    def isUnsafelyNulltoAnyRef(pt: Type)(using Context): Boolean =
-      self.isNullType && pt.isNullableAfterErasure
+    // def isUnsafelyNulltoAnyRef(pt: Type)(using Context): Boolean =
+    //   self.isNullType && pt.isNullableAfterErasure
 
-    def isUnsafeSubtype(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
-      val selfs = self.stripAllNulls
-      val pts = pt.stripAllNulls
-      if relaxedSubtype then
-        selfs relaxed_<:< pts
-      else
-        selfs <:< pts
+    // def isUnsafeSubtype(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
+    //   val selfs = self.stripAllNulls
+    //   val pts = pt.stripAllNulls
+    //   if relaxedSubtype then
+    //     selfs relaxed_<:< pts
+    //   else
+    //     selfs <:< pts
 
-    /** Can we convert a tree with type `self` to type `pt` unsafely.
-     */
-    def isUnsafelyConvertible(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
-      self.isUnsafelyNulltoAnyRef(pt) || self.isUnsafeSubtype(pt, relaxedSubtype)
+    // /** Can we convert a tree with type `self` to type `pt` unsafely.
+    //  */
+    // def unsafeNullsSubType(pt: Type, relaxed: Boolean = false)(using Context): Boolean =
+    //   self.isUnsafelyNulltoAnyRef(pt) || self.isUnsafeSubtype(pt, relaxed)
   }
 }

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

@@ -757,7 +757,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             isSubType(hi1, tp2, approx.addLow) || compareGADT || tryLiftedToThis1
           case _ =>
             def isNullable(tp: Type): Boolean = tp.widenDealias match {
-              case tp: TypeRef => tp.symbol.isNullableClass
+              case tp: TypeRef => 
+                if ctx.mode.is(Mode.UnsafeNullsSubType) then
+                  tp.symbol.isNullableClassAfterErasure
+                else 
+                  tp.symbol.isNullableClass
               case tp: RefinedOrRecType => isNullable(tp.parent)
               case tp: AppliedType => isNullable(tp.tycon)
               case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -366,7 +366,7 @@ class TreeUnpickler(reader: TastyReader,
               else
                 val hi0 = readVariances(readType())
                 val hi =
-                  if ctx.explicitNulls && lo.isNullType && hi0.isNullableAfterErasure
+                  if ctx.explicitNulls && lo.isBottomTypeAfterErasure && hi0.isNullableAfterErasure
                   then OrNull(hi0) else hi0
                 TypeBounds(lo, hi)
             case ANNOTATEDtype =>
@@ -1247,7 +1247,7 @@ class TreeUnpickler(reader: TastyReader,
               val lo = readTpt()
               val hi0 = if currentAddr == end then lo else readTpt()
               val hi =
-                if ctx.explicitNulls && lo.tpe.isNullType && hi0.tpe.isNullableAfterErasure
+                if ctx.explicitNulls && lo.tpe.isBottomTypeAfterErasure && hi0.tpe.isNullableAfterErasure
                 then TypeTree(OrNull(hi0.tpe)) else hi0
               val alias = if currentAddr == end then EmptyTree else readTpt()
               TypeBoundsTree(lo, hi, alias)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -773,7 +773,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         val lo = readTypeRef()
         val hi0 = readTypeRef()
         val hi =
-          if ctx.explicitNulls && lo.isNullType && hi0.isNullableAfterErasure
+          if ctx.explicitNulls && lo.isBottomTypeAfterErasure && hi0.isNullableAfterErasure
           then OrNull(hi0) else hi0
         TypeBounds(lo, hi)
       case REFINEDtpe =>
@@ -1255,7 +1255,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         val lo = readTreeRef()
         val hi0 = readTreeRef()
         val hi =
-          if ctx.explicitNulls && lo.tpe.isNullType && hi0.tpe.isNullableAfterErasure
+          if ctx.explicitNulls && lo.tpe.isBottomTypeAfterErasure && hi0.tpe.isNullableAfterErasure
           then TypeTree(OrNull(hi0.tpe)) else hi0
         TypeBoundsTree(lo, hi)
 

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

@@ -133,9 +133,8 @@ object Implicits:
             else if (mt.paramInfos.lengthCompare(1) == 0 && {
                   var formal = widenSingleton(mt.paramInfos.head)
                   if (approx) formal = wildApprox(formal)
-                  explore((argType relaxed_<:< formal.widenExpr) ||
-                    Nullables.convertUnsafeNulls &&
-                      argType.isUnsafeSubtype(formal.widenExpr, true))
+                  Nullables.useUnsafeNullsSubTypeIf(ctx.mode.is(Mode.UnsafeNullConversion))(
+                    explore(argType relaxed_<:< formal.widenExpr))
                 })
               Candidate.Conversion
             else
@@ -1314,7 +1313,8 @@ trait Implicits:
 
     /** All available implicits, without ranking */
     def allImplicits: Set[TermRef] = {
-      val contextuals = ctx.implicits.eligible(wildProto, ctx.mode.is(Mode.UnsafeNullConversion)).map(tryImplicit(_, contextual = true))
+      val contextuals = ctx.implicits.eligible(wildProto, ctx.mode.is(Mode.UnsafeNullConversion))
+        .map(tryImplicit(_, contextual = true))
       val inscope = implicitScope(wildProto).eligible.map(tryImplicit(_, contextual = false))
       (contextuals.toSet ++ inscope).collect {
         case success: SearchSuccess => success.ref

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

@@ -20,11 +20,9 @@ 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))
+  inline def useUnsafeNullsSubTypeIf[T](cond: Boolean)(inline op: Context ?=> T)(using Context): T = 
+    val c = if cond then ctx.addMode(Mode.UnsafeNullsSubType) else ctx
+    op(using c)
 
   /** 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

@@ -10,8 +10,10 @@ import Trees._
 import Constants._
 import util.{Stats, SimpleIdentityMap}
 import Decorators._
+import Nullables.useUnsafeNullsSubTypeIf
 import NullOpsDecorator._
 import Uniques._
+import config.Feature
 import config.Printers.typr
 import util.SourceFile
 import util.Property
@@ -39,10 +41,10 @@ object ProtoTypes {
     def isCompatible(tp: Type, pt: Type)(using Context): Boolean =
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
-      (tpw relaxed_<:< ptw)
-      // If unsafeNulls is enabled, we relax the condition by
-      // striping all nulls from the types before subtype check.
-      || Nullables.convertUnsafeNulls && tpw.isUnsafelyConvertible(ptw, true)
+      useUnsafeNullsSubTypeIf(
+        Feature.unsafeNullsEnabled
+        || ctx.mode.is(Mode.UnsafeNullConversion))(
+          tpw relaxed_<:< ptw)
       || viewExists(tp, pt)
 
     /** Like isCompatibe, but using a subtype comparison with necessary eithers
@@ -51,16 +53,11 @@ object ProtoTypes {
     def necessarilyCompatible(tp: Type, pt: Type)(using Context): Boolean =
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
-      necessarySubType(tpw, ptw)
+      useUnsafeNullsSubTypeIf(
+        Feature.unsafeNullsEnabled
+        || ctx.mode.is(Mode.UnsafeNullConversion))(
+          necessarySubType(tpw, ptw))
       || tpw.isValueSubType(ptw)
-      || Nullables.convertUnsafeNulls && {
-        // See comments in `isCompatible`
-        val tpwsn = tpw.stripAllNulls
-        val ptwsn = ptw.stripAllNulls
-        necessarySubType(tpwsn, ptwsn)
-        || tpwsn.isValueSubType(ptwsn)
-        || tpwsn.isUnsafelyNulltoAnyRef(ptwsn)
-      }
       || viewExists(tp, pt)
 
     /** Test compatibility after normalization.

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

@@ -547,7 +547,7 @@ class Typer extends Namer
 
     def typeSelectOnTerm(using Context): Tree =
       val qual = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
-      val qual1 = if Nullables.convertUnsafeNulls then
+      val qual1 = if unsafeNullsEnabled then
         qual.tpe match {
           case OrNull(tpe1) =>
             qual.cast(AndType(qual.tpe, tpe1))
@@ -1264,9 +1264,8 @@ class Typer extends Namer
             val pt1 = if ctx.explicitNulls then pt.stripNull else pt
             pt1 match {
               case SAMType(sam)
-              if !defn.isFunctionType(pt1) && (
-                mt <:< sam ||
-                Nullables.convertUnsafeNulls && mt.stripAllNulls <:< sam.stripAllNulls) =>
+              if !defn.isFunctionType(pt1)
+                && useUnsafeNullsSubTypeIf(unsafeNullsEnabled)(mt <:< sam) =>
                 // 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.
@@ -3474,9 +3473,7 @@ class Typer extends Namer
           val pt1 = if ctx.explicitNulls then pt.stripNull else pt
           pt1 match {
             case SAMType(sam)
-            if wtp <:< sam.toFunctionType()
-              || (Nullables.convertUnsafeNulls
-                && wtp.stripAllNulls <:< sam.toFunctionType().stripAllNulls) =>
+            if useUnsafeNullsSubTypeIf(unsafeNullsEnabled)(wtp <:< sam.toFunctionType()) =>
               // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the
@@ -3548,10 +3545,9 @@ class Typer extends Namer
       val treeTpe = tree.tpe
 
       def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
-        // If explicitNulls and unsafeNulls are enabled, and
-        if ctx.mode.is(Mode.UnsafeNullConversion)
-          && pt.isValueType
-          && treeTpe.isUnsafelyConvertible(pt)
+        if pt.isValueType
+          && useUnsafeNullsSubTypeIf(ctx.mode.is(Mode.UnsafeNullConversion))(
+              treeTpe <:< pt)
         then tree.cast(pt)
         else fail
 
@@ -3566,16 +3562,16 @@ class Typer extends Namer
         else recover(failure.reason)
 
       val searchCtx =
-        if ctx.explicitNulls && config.Feature.enabled(nme.unsafeNulls) then
+        if unsafeNullsEnabled then
           ctx.addMode(Mode.UnsafeNullConversion)
         else ctx
 
       inContext(searchCtx) {
         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.mode.is(Mode.UnsafeNullConversion)
-              && treeTpe.isUnsafelyConvertible(pt)) then
+            if !(useUnsafeNullsSubTypeIf(ctx.mode.is(Mode.UnsafeNullConversion))(
+              treeTpe <:< pt)) then
               report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
             tree.cast(pt)
           else

tests/explicit-nulls/unsafe-common/unsafe-cast.scala

@@ -65,10 +65,4 @@ class S {
     n1(Array("a", null))
     n2(Array("a", null))
   }
-
-  def test[T <: AnyRef](x: T | Null): T = {
-    val y: T = x // error
-    val z: T = null // error
-    x // error
-  }
 }

tests/explicit-nulls/unsafe-common/unsafe-implicit3.scala

@@ -96,20 +96,20 @@ class S {
     val z8: Array[String | Null] | Null = y2 // error
   }
 
-  def test5[T <: AnyRef] = {
+  def test5[T >: Null <: AnyRef | Null] = {
     given Conversion[T, Array[T]] = _ => ???
 
     val y1: T = ???
     val y2: T | Null = ???
 
     val z1: Array[T] = y1
-    val z2: Array[T | Null] = y1 // error
+    val z2: Array[T | Null] = y1
     val z3: Array[T] | Null = y1
-    val z4: Array[T | Null] | Null = y1 // error
+    val z4: Array[T | Null] | Null = y1
 
-    val z5: Array[T] = y2 // error
-    val z6: Array[T | Null] = y2 // error
-    val z7: Array[T] | Null = y2 // error
-    val z8: Array[T | Null] | Null = y2 // error
+    val z5: Array[T] = y2
+    val z6: Array[T | Null] = y2
+    val z7: Array[T] | Null = y2
+    val z8: Array[T | Null] | Null = y2
   }
 }