respect @unchecked in type patterns

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -20,7 +20,6 @@ import ProtoTypes._
 import transform.SymUtils._
 import reporting.diagnostic.messages._
 import config.Printers.{exhaustivity => debug}
-import util.Positions.Position
 
 /** Space logic for checking exhaustivity and unreachability of pattern matching
  *
@@ -404,20 +403,23 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       else
         Prod(pat.tpe.stripAnnots, fun.tpe.widen, fun.symbol, pats.map(project), irrefutable(fun))
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
-    case Typed(expr, tp) => Typ(erase(expr.tpe.stripAnnots)(tp.pos), true)
+    case Typed(expr, tpt) =>
+      val unchecked = expr.tpe.hasAnnotation(ctx.definitions.UncheckedAnnot)
+      def warn(msg: String): Unit = if (!unchecked) ctx.warning(UncheckedTypePattern(msg), tpt.pos)
+      Typ(erase(expr.tpe.stripAnnots)(warn), true)
     case _ =>
       debug.println(s"unknown pattern: $pat")
       Empty
   }
 
   /* Erase a type binding according to erasure semantics in pattern matching */
-  def erase(tp: Type)(implicit pos: Position): Type = tp match {
+  def erase(tp: Type)(implicit warn: String => Unit): Type = tp match {
     case tp @ AppliedType(tycon, args) =>
       if (tycon.isRef(defn.ArrayClass)) tp.derivedAppliedType(tycon, args.map(erase))
       else {
         val ignoreWarning = args.forall(p => p.typeSymbol.is(BindDefinedType) || p.isInstanceOf[TypeBounds])
         if (!ignoreWarning)
-          ctx.warning(UncheckedTypePattern("type arguments are not checked since they are eliminated by erasure"), pos)
+          warn("type arguments are not checked since they are eliminated by erasure")
 
         tp.derivedAppliedType(tycon, args.map(t => WildcardType))
       }
@@ -426,7 +428,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     case AndType(tp1, tp2) =>
       AndType(erase(tp1), erase(tp2))
     case tp: RefinedType =>
-      ctx.warning(UncheckedTypePattern("type refinement is not checked since it is eliminated by erasure"), pos)
+      warn("type refinement is not checked since it is eliminated by erasure")
       tp.derivedRefinedType(erase(tp.parent), tp.refinedName, WildcardType)
     case _ => tp
   }

tests/patmat/3144b.scala

@@ -0,0 +1,6 @@
+class Test {
+  def f(x: Any): Int = x match {
+    case xs: List[Int] @unchecked => xs.head
+    case _ => 0
+  }
+}