Revert previous changes and simplify Nothing | T to T and Null | T to if T is nullable

Author: SuperCl4sh

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

@@ -370,32 +370,6 @@ object Types extends TypeUtils {
       loop(this)
     }
 
-    /* Is this type exactly Nothing or is an AndOrType with a type that is exactly Nothing? */
-    def hasNothing(using Context): Boolean = {
-      def loop(tp: Type): Boolean = tp match {
-        case tp: TypeRef =>
-          tp.isExactlyNothing
-        case tp: AndOrType =>
-          loop(tp.tp1) || loop(tp.tp2)
-        case _ =>
-          false
-      }
-      loop(this)
-    }
-
-    /* Is this type exactly Null or is an AndOrType with a type that is exactly Null? */
-    def hasNull(using Context): Boolean = {
-      def loop(tp: Type): Boolean = tp match {
-        case tp: TypeRef =>
-          tp.isExactlyNull
-        case tp: AndOrType =>
-          loop(tp.tp1) || loop(tp.tp2)
-        case _ =>
-          false
-      }
-      loop(this)
-    }
-
     /** Is this type guaranteed not to have `null` as a value? */
     final def isNotNull(using Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null

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

@@ -418,8 +418,6 @@ object PatternMatcher {
               && !hasExplicitTypeArgs(extractor)
             case _ => false
           }
-
-          if (tpt.tpe.hasNull || tpt.tpe.hasNothing) report.error(em"${tpt.tpe} cannot be used in runtime type tests", tpt)
 
           TestPlan(TypeTest(tpt, isTrusted), scrutinee, tree.span,
             letAbstract(ref(scrutinee).cast(tpt.tpe)) { casted =>

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

@@ -330,13 +330,17 @@ object TypeTestsCasts {
             expr.isInstance(testType).withSpan(tree.span)
           case OrType(tp1, tp2) =>
             evalOnce(expr) { e =>
-              transformTypeTest(e, tp1, flagUnrelated = false)
-                .or(transformTypeTest(e, tp2, flagUnrelated = false))
+              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)
             }
           case AndType(tp1, tp2) =>
             evalOnce(expr) { e =>
               transformTypeTest(e, tp1, flagUnrelated)
-                .and(transformTypeTest(e, tp2, flagUnrelated))
+              .and(transformTypeTest(e, tp2, flagUnrelated))
             }
           case defn.MultiArrayOf(elem, ndims) if isGenericArrayElement(elem, isScala2 = false) =>
             def isArrayTest(arg: Tree) =