Make isInstanceOf[Null] illegal everywhere

also add `scala.Singleton` to untestable types

Author: Kordyjan

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

@@ -1196,7 +1196,7 @@ class Definitions {
 
   @tu lazy val topClasses: Set[Symbol] = Set(AnyClass, MatchableClass, ObjectClass, AnyValClass)
 
-  @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass)
+  @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass, SingletonClass)
 
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))

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

@@ -236,16 +236,14 @@ object TypeTestsCasts {
 
             val foundEffectiveClass = effectiveClass(expr.tpe.widen)
 
-            val isUntestable = defn.untestableClasses.contains(testCls)
-            val isIllegalPrimitiveTest = foundEffectiveClass.isPrimitiveValueClass && !testCls.isPrimitiveValueClass
-            if isIllegalPrimitiveTest || isUntestable then
+            if foundEffectiveClass.isPrimitiveValueClass && !testCls.isPrimitiveValueClass then
               report.error(i"cannot test if value of $exprType is a reference of $testCls", tree.srcPos)
               false
             else foundClasses.exists(check)
           end checkSensical
 
           if (expr.tpe <:< testType)
-            if (expr.tpe.isNotNull || testType.widen.isRef(defn.NullClass)) {
+            if (expr.tpe.isNotNull) {
               if (!inMatch) report.warning(TypeTestAlwaysSucceeds(expr.tpe, testType), tree.srcPos)
               constant(expr, Literal(Constant(true)))
             }
@@ -341,8 +339,14 @@ object TypeTestsCasts {
           case AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
             ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
           case _ =>
-            val erasedTestType = erasure(testType)
-            transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
+            val testWidened = testType.widen
+            defn.untestableClasses.find(testWidened.isRef(_)) match
+              case Some(untestable) =>
+                report.error(i"$untestable cannot be used in runtime type tests", tree.srcPos)
+                constant(expr, Literal(Constant(false)))
+              case _ =>
+                val erasedTestType = erasure(testType)
+                transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
         }
 
         if (sym.isTypeTest) {

tests/explicit-nulls/pos/matchable.scala

@@ -1,3 +1 @@
-def foo1[T <: Matchable](t: T) = t match { case t: Null => () }
-
 def foo2[T <: Matchable](t: T) = t match { case null => () }

tests/neg/i4004.scala

@@ -1,13 +1,16 @@
 @main def Test =
   "a".isInstanceOf[Null] // error
-  null.isInstanceOf[Null]
+  null.isInstanceOf[Null] // error
   "a".isInstanceOf[Nothing] // error
+  "a".isInstanceOf[Singleton] // error
 
   "a" match
   case _: Null => () // error
+  case _: Nothing => () // error
+  case _: Singleton => () // error
   case _ => ()
 
   null match
-  case _: Null => ()
+  case _: Null => () // error
   case _ => ()