Simplify uncheckable local classes check

Author: dwijnand

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

@@ -31,7 +31,7 @@ object TypeTestsCasts {
   import typer.Inferencing.maximizeType
   import typer.ProtoTypes.constrained
 
-  /** Whether `(x:X).isInstanceOf[P]` can be checked at runtime?
+  /** Whether `(x: X).isInstanceOf[P]` can be checked at runtime?
    *
    *  First do the following substitution:
    *  (a) replace `T @unchecked` and pattern binder types (e.g., `_$1`) in P with WildcardType
@@ -48,7 +48,8 @@ object TypeTestsCasts {
    *     (c) maximize `pre.F[Xs]` and check `pre.F[Xs] <:< P`
    *  6. if `P = T1 | T2` or `P = T1 & T2`, checkable(X, T1) && checkable(X, T2).
    *  7. if `P` is a refinement type, FALSE
-   *  8. otherwise, TRUE
+   *  8. if `P` is a local class which is not statically reachable from the scope where `X` is defined, FALSE
+   *  9. otherwise, TRUE
    */
   def checkable(X: Type, P: Type, span: Span)(using Context): Boolean = atPhase(Phases.refchecksPhase.next) {
     // Run just before ElimOpaque transform (which follows RefChecks)
@@ -58,7 +59,7 @@ object TypeTestsCasts {
       def apply(tp: Type) = tp match {
         case tref: TypeRef if tref.typeSymbol.isPatternBound =>
           WildcardType
-        case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedAnnot =>
+        case tp if tp.hasAnnotation(defn.UncheckedAnnot) =>
           WildcardType
         case _ => mapOver(tp)
       }
@@ -123,11 +124,6 @@ object TypeTestsCasts {
 
     }
 
-    lazy val scrutineeIsUnchecked = X.widenTermRefExpr.existsPart {
-      case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedAnnot => true
-      case _ => false
-    }
-
     def recur(X: Type, P: Type): Boolean = (X <:< P) || (P.dealias match {
       case _: SingletonType     => true
       case _: TypeProxy
@@ -157,26 +153,13 @@ object TypeTestsCasts {
       case AnnotatedType(t, _)  => recur(X, t)
       case tp2: RefinedType     => recur(X, tp2.parent) && TypeComparer.hasMatchingMember(tp2.refinedName, X, tp2)
       case tp2: RecType         => recur(X, tp2.parent)
-      case tp2
-      if tp2.typeSymbol.isLocal && !scrutineeIsUnchecked =>
-        val sym = tp2.typeSymbol
-        val methodSymbol = sym.owner
-        val tpSyms = typer.ErrorReporting.substitutableTypeSymbolsInScope(sym).toSet
-        def isAccessible(sym: Symbol): Boolean = sym == methodSymbol || sym.isType && isAccessible(sym.owner)
-        val seen = scala.collection.mutable.Set.empty[Type]
-        def hasPoison(tp: Type): Boolean =
-          seen += tp
-          tp.baseClasses.filter(isAccessible).exists { sym =>
-            sym.info.decls.exists { sym =>
-              sym.info.existsPart(tp => tpSyms.contains(tp.typeSymbol))
-                || !seen.contains(sym.info) && isAccessible(sym.info.typeSymbol.maybeOwner) && hasPoison(sym.info)
-            }
-          }
-        !hasPoison(tp2)
+      case _
+      if P.classSymbol.isLocal && P.classSymbol.isInaccessibleChildOf(X.classSymbol) => // 8
+        false
       case _                    => true
     })
 
-    val res = recur(X.widen, replaceP(P))
+    val res = X.widenTermRefExpr.hasAnnotation(defn.UncheckedAnnot) || recur(X.widen, replaceP(P))
 
     debug.println(i"checking  ${X.show} isInstanceOf ${P} = $res")
 

tests/neg/i4812.check

@@ -22,3 +22,7 @@
 60 |      case prev: A => // error: the type test for A cannot be checked at runtime
    |           ^
    |           the type test for A cannot be checked at runtime
+-- Error: tests/neg/i4812.scala:96:11 ----------------------------------------------------------------------------------
+96 |      case x: B => // error: the type test for B cannot be checked at runtime
+   |           ^
+   |           the type test for B cannot be checked at runtime

tests/neg/i4812.scala

@@ -80,6 +80,34 @@ object Test:
       case prev: A => prev.elem
       case _       => prev = new A(x); x
 
+  def test9 =
+    trait A
+    class B extends A
+    val x: A = new B
+    x match
+      case x: B => x
+
+  sealed class A
+  var prevA: A = _
+  def test10: A =
+    val methodCallId = System.nanoTime()
+    class B(val id: Long) extends A
+    prevA match
+      case x: B => // error: the type test for B cannot be checked at runtime
+        x.ensuring(x.id == methodCallId, s"Method call id $methodCallId != ${x.id}")
+      case _    =>
+        val x = new B(methodCallId)
+        prevA = x
+        x
+
+  def test11 =
+    trait A
+    trait B
+    class C extends A with B
+    val x: A = new C
+    x match
+      case x: B => x
+
   def main(args: Array[String]): Unit =
     test(1)
     val x: String = test("") // was: ClassCastException: java.lang.Integer cannot be cast to java.lang.String