Optimize matchs in Types

Author: noti0na1

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

@@ -757,10 +757,10 @@ 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 => 
+              case tp: TypeRef =>
                 if ctx.mode.is(Mode.UnsafeNullsSubType) then
                   tp.symbol.isNullableClassAfterErasure
-                else 
+                else
                   tp.symbol.isNullableClass
               case tp: RefinedOrRecType => isNullable(tp.parent)
               case tp: AppliedType => isNullable(tp.tycon)

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

@@ -20,6 +20,7 @@ import Denotations._
 import Periods._
 import CheckRealizable._
 import Variances.{Variance, varianceFromInt, varianceToInt, setStructuralVariances, Invariant}
+import typer.Nullables
 import util.Stats._
 import util.SimpleIdentitySet
 import ast.tpd._
@@ -30,6 +31,7 @@ import Hashable._
 import Uniques._
 import collection.mutable
 import config.Config
+import config.Feature
 import annotation.{tailrec, constructorOnly}
 import language.implicitConversions
 import scala.util.hashing.{ MurmurHash3 => hashing }
@@ -783,7 +785,7 @@ 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 Feature.unsafeNullsEnabled =>
           // 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)
@@ -1032,12 +1034,8 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes) ||
-      (ctx.explicitNulls &&
-        // TODO: optimize, for example, add a parameter to ignore Null type?
-        TypeComparer.matchesType(
-          this.stripAllNulls, that.stripAllNulls,
-          relaxed = !ctx.phase.erasedTypes))
+      Nullables.useUnsafeNullsSubTypeIf(ctx.explicitNulls)(
+        TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes))
     }
 
     /** This is the same as `matches` except that it also matches => T with T and

tests/explicit-nulls/neg/unsafe-scope.scala

@@ -5,16 +5,19 @@ class S {
     val s: String | Null = ???
 
     val x: String = s // error
-    val xs: Array[String | Null] = s // error
+    val xl = s.length // error
+    val xs: Array[String | Null] | Null = s // error
 
     {
       import scala.language.unsafeNulls
       // ensure the previous search cache is not used here
       val y: String = s
-      val ys: Array[String | Null] = s
+      val yl = s.length
+      val ys: Array[String | Null] | Null = s
     }
 
     val z: String = s // error
-    val zs: Array[String | Null] = s // error
+    val zl = s.length // error
+    val zs: Array[String | Null] | Null = s // error
   }
 }