Handle unchecked scrutinee

Author: dwijnand

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

@@ -123,6 +123,11 @@ 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
@@ -153,7 +158,7 @@ object TypeTestsCasts {
       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 =>
+      if tp2.typeSymbol.isLocal && !scrutineeIsUnchecked =>
         val sym = tp2.typeSymbol
         val methodSymbol = sym.owner
         val tpSyms = typer.ErrorReporting.substitutableTypeSymbolsInScope(sym).toSet

tests/neg/i4812.check

@@ -19,6 +19,6 @@
    |             ^
    |             the type test for A cannot be checked at runtime
 -- Error: tests/neg/i4812.scala:60:11 ----------------------------------------------------------------------------------
-60 |      case prev: Foo => // error: the type test for A cannot be checked at runtime
+60 |      case prev: A => // error: the type test for A cannot be checked at runtime
    |           ^
-   |           the type test for Foo cannot be checked at runtime
+   |           the type test for A cannot be checked at runtime

tests/neg/i4812.scala

@@ -54,19 +54,32 @@ object Test:
           x
 
   def test6[T](x: T): T =
-    class Foo { var bar: Bar = null }
-    class Bar { var foo: Foo = null; var elem: T = _ }
+    class A { var b: B = null }
+    class B { var a: A = null; var elem: T = _ }
     prev match
-      case prev: Foo => // error: the type test for A cannot be checked at runtime
-        prev.bar.elem
+      case prev: A => // error: the type test for A cannot be checked at runtime
+        prev.b.elem
       case _ =>
-        val foo = new Foo
-        val bar = new Bar
-        bar.elem = x
-        foo.bar = bar
-        prev = foo
+        val a = new A
+        val b = new B
+        b.elem = x
+        a.b = b
+        prev = a
         x
 
+  def test7[T](x: T): T =
+    class A(val elem: T)
+    prev match
+      case prev: A @unchecked => prev.elem
+      case _                  => prev = new A(x); x
+
+  def test8[T](x: T): T =
+    class A(val elem: T)
+    val p = prev
+    (p: @unchecked) match
+      case prev: A => prev.elem
+      case _       => prev = new A(x); 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