Alternative: preserve : @unchecked message pre 3.8

patch and warning message text will still suggest/replace `: @unchecked` pre 3.8.

from 3.8-migration onwards, the message/patch suggests `.runtimeChecked`

This preserves behavior under older source versions.

Author: bishabosha

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

@@ -1085,7 +1085,10 @@ trait Checking {
           else em"pattern binding uses refutable extractor `$extractor`"
 
       val fix =
-        if isPatDef then "adding `.runtimeChecked` after the expression"
+        if isPatDef then
+          val patchText =
+            if sourceVersion.isAtLeast(`3.8`) then ".runtimeChecked" else ": @unchecked"
+          s"adding `$patchText` after the expression"
         else "adding the `case` keyword before the full pattern"
       val addendum =
         if isPatDef then "may result in a MatchError at runtime"
@@ -1098,7 +1101,9 @@ trait Checking {
           case NonConforming => sel.srcPos
           case RefutableExtractor => pat.source.atSpan(pat.span `union` sel.span)
         else pat.srcPos
-      def rewriteMsg = Message.rewriteNotice("This patch", `3.2-migration`)
+      def rewriteMsg = Message.rewriteNotice("This patch",
+        if isPatDef && sourceVersion.isAtLeast(`3.8`) then `3.8-migration` else `3.2-migration`
+      )
       report.errorOrMigrationWarning(
         message.append(
           i"""|
@@ -1107,7 +1112,7 @@ trait Checking {
               |which $addendum.$rewriteMsg"""),
         pos,
         // we tighten for-comprehension without `case` to error in 3.4,
-        // but we keep pat-defs as warnings for now ("@unchecked"),
+        // but we keep pat-defs as warnings for now (".runtimeChecked"),
         // until we propose an alternative way to assert exhaustivity to the typechecker.
         if isPatDef then MigrationVersion.ForComprehensionUncheckedPathDefs
         else MigrationVersion.ForComprehensionPatternWithoutCase

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

@@ -2235,12 +2235,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   && sourceVersion.isAtLeast(`3.2`)
                   && sourceVersion.isMigrating
                 then
-                  if isPatDef then runtimeCheckedBrackets(tree.selector) match
+                  if isPatDef then
+                    val patchText =
+                      if sourceVersion.isAtLeast(`3.8`) then ".runtimeChecked"
+                      else ": @unchecked"
+                    runtimeCheckedBrackets(tree.selector) match
                     case None =>
-                      patch(Span(tree.selector.span.end), ".runtimeChecked")
+                      patch(Span(tree.selector.span.end), patchText)
                     case Some(bl, br) =>
                       patch(Span(tree.selector.span.start), s"$bl")
-                      patch(Span(tree.selector.span.end), s"$br.runtimeChecked")
+                      patch(Span(tree.selector.span.end), s"$br$patchText")
                   else
                     patch(Span(tree.span.start), "case ")
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -70,7 +70,8 @@ class CompilationTests {
       compileFile("tests/rewrites/private-this.scala", defaultOptions.and("-rewrite", "-source", "future-migration")),
       compileFile("tests/rewrites/alphanumeric-infix-operator.scala", defaultOptions.and("-rewrite", "-source", "future-migration")),
       compileFile("tests/rewrites/filtering-fors.scala", defaultOptions.and("-rewrite", "-source", "3.2-migration")),
-      compileFile("tests/rewrites/refutable-pattern-bindings.scala", defaultOptions.and("-rewrite", "-source", "3.2-migration")),
+      compileFile("tests/rewrites/refutable-pattern-bindings-old.scala", defaultOptions.and("-rewrite", "-source", "3.2-migration")),
+      compileFile("tests/rewrites/refutable-pattern-bindings.scala", defaultOptions.and("-rewrite", "-source", "3.8-migration")),
       compileFile("tests/rewrites/i8982.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i9632.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i11895.scala", defaultOptions.and("-indent", "-rewrite")),

tests/neg/i11118.check

@@ -5,7 +5,7 @@
   |
   |       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.
+  |       This patch can be rewritten automatically under -rewrite -source 3.8-migration.
 -- Error: tests/neg/i11118.scala:2:4 -----------------------------------------------------------------------------------
 2 |val (a,b) = (1,2,3) // error // warning
   |    ^

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

@@ -0,0 +1,48 @@
+-- Error: tests/neg/refutable-pattern-binding-messages-old.scala:6:14 --------------------------------------------------
+6 |  for Positive(i) <- List(1, 2, 3) do ()  // error: refutable extractor
+  |      ^^^^^^^^^^^
+  |      pattern binding uses refutable extractor `Test.Positive`
+  |
+  |      If this usage is intentional, this can be communicated by adding the `case` keyword before the full pattern,
+  |      which will result in a filtering for expression (using `withFilter`).
+  |      This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+-- Error: tests/neg/refutable-pattern-binding-messages-old.scala:11:11 -------------------------------------------------
+11 |  for ((x: String) <- xs) do ()           // error: pattern type more specialized
+   |           ^^^^^^
+   | pattern's type String is more specialized than the right hand side expression's type AnyRef
+   |
+   | If the narrowing is intentional, this can be communicated by adding the `case` keyword before the full pattern,
+   | which will result in a filtering for expression (using `withFilter`).
+   | This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+-- Error: tests/neg/refutable-pattern-binding-messages-old.scala:15:13 -------------------------------------------------
+15 |  for none @ None <- ys do ()             // error: pattern type does not match
+   |             ^^^^
+   | pattern's type None.type does not match the right hand side expression's type (x$1 : Option[?])
+   |
+   | If the narrowing is intentional, this can be communicated by adding the `case` keyword before the full pattern,
+   | which will result in a filtering for expression (using `withFilter`).
+   | This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+-- Warning: tests/neg/refutable-pattern-binding-messages-old.scala:5:14 ------------------------------------------------
+5 |  val Positive(p) = 5                     // warn: refutable extractor
+  |      ^^^^^^^^^^^^^^^
+  |      pattern binding uses refutable extractor `Test.Positive`
+  |
+  |      If this usage 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.
+-- Warning: tests/neg/refutable-pattern-binding-messages-old.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]
+   |
+   |        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.
+-- Warning: tests/neg/refutable-pattern-binding-messages-old.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)
+   |
+   |        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.

tests/neg/refutable-pattern-binding-messages-old.scala

@@ -0,0 +1,17 @@
+//> using options -source 3.7
+object Test {
+  // refutable extractor
+  object Positive { def unapply(i: Int): Option[Int] = Some(i).filter(_ > 0) }
+  val Positive(p) = 5                     // warn: refutable extractor
+  for Positive(i) <- List(1, 2, 3) do ()  // error: refutable extractor
+
+  // more specialized
+  val xs: List[AnyRef] = ???
+  val i :: is = List(1, 2, 3)             // warn: pattern type more specialized
+  for ((x: String) <- xs) do ()           // error: pattern type more specialized
+
+  // does not match
+  val ys: List[Option[?]] = ???
+  for none @ None <- ys do ()             // error: pattern type does not match
+  val 1 = 2                               // warn: pattern type does not match
+}

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

@@ -29,20 +29,20 @@
   |
   |      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.
+  |      This patch can be rewritten automatically under -rewrite -source 3.8-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]
    |
    |     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.
+   |     This patch can be rewritten automatically under -rewrite -source 3.8-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)
    |
    |     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.
+   |     This patch can be rewritten automatically under -rewrite -source 3.8-migration.

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

@@ -1,4 +1,4 @@
-
+//> using options -source 3.8
 object Test {
   // refutable extractor
   object Positive { def unapply(i: Int): Option[Int] = Some(i).filter(_ > 0) }

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

@@ -61,4 +61,4 @@
    |
    |     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.
+   |     This patch can be rewritten automatically under -rewrite -source 3.8-migration.

tests/rewrites/refutable-pattern-bindings-old.check

@@ -0,0 +1,29 @@
+// NOTE: this file is compiled under -source 3.2-migration (i.e. it will rewrite to `: @unchecked`)
+// see refutable-pattern-bindings.scala for the version compiled under -source 3.8-migration (which rewrites to `.runtimeChecked`)
+val xs: List[Any] = ???
+
+val hd :: tl = (xs match
+  case Nil => null :: xs
+  case _   => xs): @unchecked
+
+val h :: t = xs: @unchecked
+
+val a :: b =
+  (if xs.isEmpty then null :: xs
+  else xs): @unchecked
+
+val c :: d =
+  (try xs.head :: xs
+  catch case _: NoSuchElementException => null :: xs): @unchecked
+
+val e :: f =
+  {val zero = null :: Nil
+  if xs.isEmpty then zero
+  else xs}: @unchecked
+
+val j :: k =
+  (for
+    case (x: String) <- xs
+  yield x): @unchecked
+
+val (_: Int | _: AnyRef) = (??? : AnyRef): @unchecked