Optimize subtyping ignoring nulls

Author: noti0na1

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

@@ -116,9 +116,11 @@ class CheckRealizable(using Context) {
     case _: SingletonType | NoPrefix =>
       Realizable
     case tp =>
+      // TODO
+      // check the realizability of a special AndType
       def checkAndType(x: TermRef, y: Type) =
         (realizability(x) eq Realizable) && (y <:< x.widen)
-      val isStableAndType = tp match {
+      val isRealizableAndType = tp match {
         case AndType(tr: TermRef, tp1) =>
           checkAndType(tr, tp1)
         case AndType(tp1, tr: TermRef) =>
@@ -132,7 +134,7 @@ class CheckRealizable(using Context) {
         case tp: OrType  => isConcrete(tp.tp1) && isConcrete(tp.tp2)
         case _ => false
       }
-      if isStableAndType then Realizable
+      if isRealizableAndType then Realizable
       else if !isConcrete(tp) then NotConcrete
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }

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

@@ -65,6 +65,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
   private var useNecessaryEither = false
 
+  private var ignoreNulls = false
+
   /** Is a subtype check in progress? In that case we may not
    *  permanently instantiate type variables, because the corresponding
    *  constraint might still be retracted and the instantiation should
@@ -133,12 +135,24 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     }
   }
 
+  def topLevelSubTypeIgnoringNulls(tp1: Type, tp2: Type): Boolean =
+    val saved = ignoreNulls
+    ignoreNulls = true
+    try topLevelSubType(tp1, tp2)
+    finally ignoreNulls = saved
+
   def necessarySubType(tp1: Type, tp2: Type): Boolean =
     val saved = useNecessaryEither
     useNecessaryEither = true
     try topLevelSubType(tp1, tp2)
     finally useNecessaryEither = saved
 
+  def necessarySubTypeIgnoringNulls(tp1: Type, tp2: Type): Boolean =
+    val saved = useNecessaryEither
+    useNecessaryEither = true
+    try topLevelSubTypeIgnoringNulls(tp1, tp2)
+    finally useNecessaryEither = saved
+
   def testSubType(tp1: Type, tp2: Type): CompareResult =
     GADTused = false
     if !topLevelSubType(tp1, tp2) then CompareResult.Fail
@@ -333,7 +347,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case AndType(tp21, tp22) =>
         recur(tp1, tp21) && recur(tp1, tp22)
       case OrType(tp21, tp22) =>
-        if (tp21.stripTypeVar eq tp22.stripTypeVar) recur(tp1, tp21)
+        if ignoreNulls && tp22.isNullType then
+          tp1.isNullType || recur(tp1, tp21)
+        else if ignoreNulls && tp21.isNullType then
+          tp1.isNullType || recur(tp1, tp22)
+        else if tp21.stripTypeVar eq tp22.stripTypeVar then recur(tp1, tp21)
         else secondTry
       case TypeErasure.ErasedValueType(tycon1, underlying2) =>
         def compareErasedValueType = tp1 match {
@@ -463,10 +481,12 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           case OrType(tp1, tp2) => containsAnd(tp1) || containsAnd(tp2)
           case _ => false
 
-        widenOK
-        || joinOK
-        || (tp1.isSoft || constrainRHSVars(tp2)) && recur(tp11, tp2) && recur(tp12, tp2)
-        || containsAnd(tp1) && recur(tp1.join, tp2)
+        if ignoreNulls && tp12.isNullType then recur(tp11, tp2)
+        else if ignoreNulls && tp11.isNullType then recur(tp12, tp2)
+        else widenOK
+          || joinOK
+          || (tp1.isSoft || constrainRHSVars(tp2)) && recur(tp11, tp2) && recur(tp12, tp2)
+          || containsAnd(tp1) && recur(tp1.join, tp2)
      case tp1: MatchType =>
         val reduced = tp1.reduced
         if (reduced.exists) recur(reduced, tp2) else thirdTry
@@ -632,6 +652,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           case Some(b) => return b
           case _ =>
 
+        if ignoreNulls then
+          if tp22.isNullType then return recur(tp1, tp21)
+          if tp21.isNullType then return recur(tp1, tp22)
+
         // The next clause handles a situation like the one encountered in i2745.scala.
         // We have:
         //
@@ -754,7 +778,9 @@ 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 ignoreNulls 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)
@@ -2550,9 +2576,15 @@ object TypeComparer {
   def topLevelSubType(tp1: Type, tp2: Type)(using Context): Boolean =
     comparing(_.topLevelSubType(tp1, tp2))
 
+  def topLevelSubTypeIgnoringNulls(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.topLevelSubTypeIgnoringNulls(tp1, tp2))
+
   def necessarySubType(tp1: Type, tp2: Type)(using Context): Boolean =
     comparing(_.necessarySubType(tp1, tp2))
 
+  def necessarySubTypeIgnoringNulls(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.necessarySubTypeIgnoringNulls(tp1, tp2))
+
   def isSubType(tp1: Type, tp2: Type)(using Context): Boolean =
     comparing(_.isSubType(tp1, tp2))
 

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

@@ -648,11 +648,11 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         tpnme.WILDCARD
       case tp: WildcardType =>
         sigName(tp.optBounds)
-      case OrNull(tp) =>
-        // If explicit nulls is enabled and the type is nullable union,
-        // we need to strip nulls before computing the signiture name.
-        // For example, the correct name of `String | Null` is `String` instead of `Object`.
-        sigName(tp)
+      // case OrType(tp1) =>
+      //   // If explicit nulls is enabled and the type is nullable union,
+      //   // we need to strip nulls before computing the signiture name.
+      //   // For example, the correct name of `String | Null` is `String` instead of `Object`.
+      //   sigName(tp1)
       case _ =>
         val erasedTp = this(tp)
         assert(erasedTp ne tp, tp)

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

@@ -170,6 +170,8 @@ object Types {
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.parent.isStable
       case tp: AndType =>
+        // if one side is stable and another side is realizable or a subtype,
+        // then the AndType is stable
         def checkAndStable(x: Type, y: Type) =
           x.isStable && ((realizability(y) eq Realizable) || y <:< x.widen)
         checkAndStable(tp.tp1, tp.tp2) || checkAndStable(tp.tp2, tp.tp1)

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

@@ -334,7 +334,7 @@ object Implicits:
     }
 
     /** The implicit references that are eligible for type `tp`. */
-    def eligible(tp: Type, enableUnsafeNulls: Boolean = false): List[Candidate] =
+    def eligible(tp: Type, enableUnsafeNulls: Boolean): List[Candidate] =
       if tp.hash == NotCached then
         Stats.record(i"compute eligible not cached ${tp.getClass}")
         Stats.record(i"compute eligible not cached")

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

@@ -157,7 +157,7 @@ trait ImportSuggestions:
     // are in the implicit scope of `pt`.
     val alreadyAvailableCandidates: Set[Symbol] = {
       val wildProto = wildApprox(pt)
-      val contextualCandidates = ctx.implicits.eligible(wildProto)
+      val contextualCandidates = ctx.implicits.eligible(wildProto, ctx.mode.is(Mode.UnsafeNullConversion))
       val implicitScopeCandidates = ctx.run.implicitScope(wildProto).eligible
       val allCandidates = contextualCandidates ++ implicitScopeCandidates
       allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet

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

@@ -15,7 +15,7 @@ import Uniques._
 import config.Printers.typr
 import util.SourceFile
 import util.Property
-import TypeComparer.necessarySubType
+import TypeComparer._
 
 import scala.annotation.internal.sharable
 
@@ -39,10 +39,12 @@ 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)
+      (if Nullables.convertUnsafeNulls then
+        // If unsafeNulls is enabled, we relax the condition by
+        // striping all nulls from the types before subtype check.
+        topLevelSubTypeIgnoringNulls(tpw, ptw)
+      else tpw <:< ptw)
+      || tpw.isValueSubType(ptw)
       || viewExists(tp, pt)
 
     /** Like isCompatibe, but using a subtype comparison with necessary eithers
@@ -51,16 +53,10 @@ object ProtoTypes {
     def necessarilyCompatible(tp: Type, pt: Type)(using Context): Boolean =
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
-      necessarySubType(tpw, ptw)
+      (if Nullables.convertUnsafeNulls then
+        necessarySubTypeIgnoringNulls(tpw, ptw)
+      else 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.