Modify logic type tests logic to strip the | Null's from testType and add a forceStrip argument to .stripNull that makes it strip | Null's even when explicit-nulls is not enabled

Author: SuperCl4sh

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

@@ -8,13 +8,14 @@ import Types.*
 object NullOpsDecorator:
 
   extension (self: Type)
-    /** Syntactically strips the nullability from this type.
+    /** If explicit-nulls is enabled, syntactically strips the nullability from this type.
+     *  If explicit-nulls is not enabled, removes all Null in unions.
      *  If the type is `T1 | ... | Tn`, and `Ti` references to `Null`,
      *  then return `T1 | ... | Ti-1 | Ti+1 | ... | Tn`.
      *  If this type isn't (syntactically) nullable, then returns the type unchanged.
-     *  The type will not be changed if explicit-nulls is not enabled.
+     *  The type will not be changed if explicit-nulls is not enabled and forceStrip is false.
      */
-    def stripNull(stripFlexibleTypes: Boolean = true)(using Context): Type = {
+    def stripNull(stripFlexibleTypes: Boolean = true, forceStrip: Boolean = false)(using Context): Type = {
       def strip(tp: Type): Type =
         val tpWiden = tp.widenDealias
         val tpStripped = tpWiden match {
@@ -42,7 +43,7 @@ object NullOpsDecorator:
         }
         if tpStripped ne tpWiden then tpStripped else tp
 
-      if ctx.explicitNulls then strip(self) else self
+      if ctx.explicitNulls || forceStrip then strip(self) else self
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */

compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala

@@ -16,6 +16,7 @@ import reporting.*
 import config.Printers.{ transforms => debug }
 
 import patmat.Typ
+import dotty.tools.dotc.core.NullOpsDecorator.stripNull
 import dotty.tools.dotc.util.SrcPos
 
 /** This transform normalizes type tests and type casts,
@@ -323,19 +324,15 @@ object TypeTestsCasts {
          *  The transform happens before erasure of `testType`, thus cannot be merged
          *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
          */
-        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
+        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias.stripNull(false, true) match {
           case tref: TermRef if tref.symbol == defn.EmptyTupleModule =>
             ref(defn.RuntimeTuples_isInstanceOfEmptyTuple).appliedTo(expr)
           case _: SingletonType =>
             expr.isInstance(testType).withSpan(tree.span)
-          case OrType(tp1, tp2) =>
+          case t @ OrType(tp1, tp2) =>
             evalOnce(expr) { e =>
-              lazy val tp1Tree = transformTypeTest(e, tp1, flagUnrelated = false)
-              lazy val tp2Tree = transformTypeTest(e, tp2, flagUnrelated = false)
-
-              if (tp1.isNothingType || (tp1.isNullType && !tp2.isNotNull)) tp2Tree
-              else if (tp2.isNothingType || (tp2.isNullType && !tp1.isNotNull)) tp1Tree
-              else tp1Tree.or(tp2Tree)
+              transformTypeTest(e, tp1, flagUnrelated = false)
+                .or(transformTypeTest(e, tp2, flagUnrelated = false))
             }
           case AndType(tp1, tp2) =>
             evalOnce(expr) { e =>

tests/neg/i23243.check

@@ -1,9 +1,9 @@
 object Extractor:
   def unapply(s: String|Null): Boolean = true
-  
+
 class A
 
 def main =
   ("foo": (A|String)) match
-    case Extractor() => println("foo matched") // error
+    case Extractor() => println("foo matched")
     case _ => println("foo didn't match")