Suggest runtimeChecked in warning/error messages

suggest `.runtimeChecked` instead of `: @unchecked`

also, change the patch applied under 3.2-migration.

Author: bishabosha

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1054,8 +1054,9 @@ trait Checking {
   }
 
   /** Check that pattern `pat` is irrefutable for scrutinee type `sel.tpe`.
-   *  This means `sel` is either marked @unchecked or `sel.tpe` conforms to the
-   *  pattern's type. If pattern is an UnApply, also check that the extractor is
+   *  This means `sel` is either marked `: @RuntimeChecked`, `: @unchecked` (old style),
+   *  or `sel.tpe` conforms to the pattern's type. If pattern is an Unapply,
+   *  also check that the extractor is
    *  irrefutable, and do the check recursively.
    */
   def checkIrrefutable(sel: Tree, pat: Tree, isPatDef: Boolean)(using Context): Boolean = {
@@ -1068,7 +1069,7 @@ trait Checking {
       import Reason.*
       val message = reason match
         case NonConforming =>
-          var reportedPt = pt.dropAnnot(defn.UncheckedAnnot)
+          var reportedPt = pt.dropAnnot(defn.UncheckedAnnot).dropAnnot(defn.RuntimeCheckedAnnot)
           if !pat.tpe.isSingleton then reportedPt = reportedPt.widen
           val problem = if pat.tpe <:< reportedPt then "is more specialized than" else "does not match"
           em"pattern's type ${pat.tpe} $problem the right hand side expression's type $reportedPt"
@@ -1084,7 +1085,7 @@ trait Checking {
           else em"pattern binding uses refutable extractor `$extractor`"
 
       val fix =
-        if isPatDef then "adding `: @unchecked` after the expression"
+        if isPatDef then "adding `.runtimeChecked` after the expression"
         else "adding the `case` keyword before the full pattern"
       val addendum =
         if isPatDef then "may result in a MatchError at runtime"

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2213,10 +2213,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             typedMatchFinish(tree, sel1, selType, tree.cases, pt)
         }
 
-        /** Are some form of brackets necessary to annotate the tree `sel` as `@unchecked`?
+        /** Are some form of brackets necessary to annotate the tree `sel` as `.runtimeChecked`?
          *  If so, return a Some(opening bracket, closing bracket), otherwise None.
          */
-        def uncheckedBrackets(sel: untpd.Tree): Option[(String, String)] = sel match
+        def runtimeCheckedBrackets(sel: untpd.Tree): Option[(String, String)] = sel match
           case _: untpd.If
              | _: untpd.Match
              | _: untpd.ForYield
@@ -2235,20 +2235,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   && sourceVersion.isAtLeast(`3.2`)
                   && sourceVersion.isMigrating
                 then
-                  if isPatDef then uncheckedBrackets(tree.selector) match
+                  if isPatDef then runtimeCheckedBrackets(tree.selector) match
                     case None =>
-                      patch(Span(tree.selector.span.end), ": @unchecked")
+                      patch(Span(tree.selector.span.end), ".runtimeChecked")
                     case Some(bl, br) =>
                       patch(Span(tree.selector.span.start), s"$bl")
-                      patch(Span(tree.selector.span.end), s"$br: @unchecked")
+                      patch(Span(tree.selector.span.end), s"$br.runtimeChecked")
                   else
                     patch(Span(tree.span.start), "case ")
 
                 // skip exhaustivity check in later phase
                 // TODO: move the check above to patternMatcher phase
-                val uncheckedTpe = AnnotatedType(sel.tpe.widen, Annotation(defn.UncheckedAnnot, tree.selector.span))
+                val runtimeCheckedTpe = AnnotatedType(sel.tpe.widen, Annotation(defn.RuntimeCheckedAnnot, tree.selector.span))
                 tpd.cpy.Match(result)(
-                  selector = tpd.Typed(sel, tpd.TypeTree(uncheckedTpe, inferred = true)),
+                  selector = tpd.Typed(sel, tpd.TypeTree(runtimeCheckedTpe, inferred = true)),
                   cases = result.cases
                 )
               case _ =>

tests/neg/i11118.check

@@ -1,11 +1,11 @@
 -- Warning: tests/neg/i11118.scala:2:12 --------------------------------------------------------------------------------
 2 |val (a,b) = (1,2,3) // error // warning
   |            ^^^^^^^
-  |          pattern's type (Any, Any) does not match the right hand side expression's type (Int, Int, Int)
+  |       pattern's type (Any, Any) does not match the right hand side expression's type (Int, Int, Int)
   |
-  |          If the narrowing is intentional, this can be communicated by adding `: @unchecked` after the expression,
-  |          which may result in a MatchError at runtime.
-  |          This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+  |       If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+  |       which may result in a MatchError at runtime.
+  |       This patch can be rewritten automatically under -rewrite -source 3.2-migration.
 -- Error: tests/neg/i11118.scala:2:4 -----------------------------------------------------------------------------------
 2 |val (a,b) = (1,2,3) // error // warning
   |    ^

tests/neg/refutable-pattern-binding-messages.check

@@ -27,22 +27,22 @@
   |      ^^^^^^^^^^^^^^^
   |      pattern binding uses refutable extractor `Test.Positive`
   |
-  |      If this usage is intentional, this can be communicated by adding `: @unchecked` after the expression,
+  |      If this usage is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
   |      which may result in a MatchError at runtime.
   |      This patch can be rewritten automatically under -rewrite -source 3.2-migration.
 -- Warning: tests/neg/refutable-pattern-binding-messages.scala:10:20 ---------------------------------------------------
 10 |  val i :: is = List(1, 2, 3)             // warn: pattern type more specialized
    |                ^^^^^^^^^^^^^
-   |        pattern's type ::[Int] is more specialized than the right hand side expression's type List[Int]
+   |     pattern's type ::[Int] is more specialized than the right hand side expression's type List[Int]
    |
-   |        If the narrowing is intentional, this can be communicated by adding `: @unchecked` after the expression,
-   |        which may result in a MatchError at runtime.
-   |        This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+   |     If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+   |     which may result in a MatchError at runtime.
+   |     This patch can be rewritten automatically under -rewrite -source 3.2-migration.
 -- Warning: tests/neg/refutable-pattern-binding-messages.scala:16:10 ---------------------------------------------------
 16 |  val 1 = 2                               // warn: pattern type does not match
    |          ^
-   |        pattern's type (1 : Int) does not match the right hand side expression's type (2 : Int)
+   |     pattern's type (1 : Int) does not match the right hand side expression's type (2 : Int)
    |
-   |        If the narrowing is intentional, this can be communicated by adding `: @unchecked` after the expression,
-   |        which may result in a MatchError at runtime.
-   |        This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+   |     If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+   |     which may result in a MatchError at runtime.
+   |     This patch can be rewritten automatically under -rewrite -source 3.2-migration.

tests/neg/t5702-neg-bad-and-wild.check

@@ -57,8 +57,8 @@
 -- Warning: tests/neg/t5702-neg-bad-and-wild.scala:22:20 ---------------------------------------------------------------
 22 |    val K(x @ _*) = k
    |                    ^
-   |        pattern's type Int* does not match the right hand side expression's type Int
+   |     pattern's type Int* does not match the right hand side expression's type Int
    |
-   |        If the narrowing is intentional, this can be communicated by adding `: @unchecked` after the expression,
-   |        which may result in a MatchError at runtime.
-   |        This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+   |     If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+   |     which may result in a MatchError at runtime.
+   |     This patch can be rewritten automatically under -rewrite -source 3.2-migration.

tests/rewrites/refutable-pattern-bindings.check

@@ -2,26 +2,26 @@ val xs: List[Any] = ???
 
 val hd :: tl = (xs match
   case Nil => null :: xs
-  case _   => xs): @unchecked
+  case _   => xs).runtimeChecked
 
-val h :: t = xs: @unchecked
+val h :: t = xs.runtimeChecked
 
 val a :: b =
   (if xs.isEmpty then null :: xs
-  else xs): @unchecked
+  else xs).runtimeChecked
 
 val c :: d =
   (try xs.head :: xs
-  catch case _: NoSuchElementException => null :: xs): @unchecked
+  catch case _: NoSuchElementException => null :: xs).runtimeChecked
 
 val e :: f =
   {val zero = null :: Nil
   if xs.isEmpty then zero
-  else xs}: @unchecked
+  else xs}.runtimeChecked
 
 val j :: k =
   (for
     case (x: String) <- xs
-  yield x): @unchecked
+  yield x).runtimeChecked
 
-val (_: Int | _: AnyRef) = (??? : AnyRef): @unchecked
+val (_: Int | _: AnyRef) = (??? : AnyRef).runtimeChecked

tests/warn/i16649-refutable.check

@@ -3,6 +3,6 @@
   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |      pattern binding uses refutable extractor `'{...}`
   |
-  |      If this usage is intentional, this can be communicated by adding `: @unchecked` after the expression,
+  |      If this usage is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
   |      which may result in a MatchError at runtime.
   |      This patch can be rewritten automatically under -rewrite -source 3.2-migration.