fix bootstrapped tests

Author: bishabosha

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

@@ -1,11 +1,3 @@
--- Error: tests/neg/refutable-pattern-binding-messages.scala:5:14 ------------------------------------------------------
-5 |  val Positive(p) = 5                     // error: 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.
 -- Error: tests/neg/refutable-pattern-binding-messages.scala:6:14 ------------------------------------------------------
 6 |  for Positive(i) <- List(1, 2, 3) do ()  // error: refutable extractor
   |      ^^^^^^^^^^^
@@ -14,14 +6,6 @@
   |      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.scala:10:20 -----------------------------------------------------
-10 |  val i :: is = List(1, 2, 3)             // error: 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.
 -- Error: tests/neg/refutable-pattern-binding-messages.scala:11:11 -----------------------------------------------------
 11 |  for ((x: String) <- xs) do ()           // error: pattern type more specialized
    |           ^^^^^^
@@ -38,6 +22,22 @@
    | 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.scala:5:14 ------------------------------------------------------
+5 |  val Positive(p) = 5                     // error: 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.
+-- Error: tests/neg/refutable-pattern-binding-messages.scala:10:20 -----------------------------------------------------
+10 |  val i :: is = List(1, 2, 3)             // error: 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.
 -- Error: tests/neg/refutable-pattern-binding-messages.scala:16:10 -----------------------------------------------------
 16 |  val 1 = 2                               // error: pattern type does not match
    |          ^

tests/pos/irrefutable.scala

@@ -1,22 +1,11 @@
-// The test which this should perform but does not
-// is that f1 is recognized as irrefutable and f2 is not
-// This can be recognized via the generated classes:
-//
-// A$$anonfun$f1$1.class
-// A$$anonfun$f2$1.class
-// A$$anonfun$f2$2.class
-//
-// The extra one in $f2$ is the filter.
-//
-// !!! Marking with exclamation points so maybe someday
-// this test will be finished.
+// This tests that f1 is recognized as an irrefutable pattern and f2 is not
 class A {
   case class Foo[T](x: T)
 
   def f1(xs: List[Foo[Int]]) = {
     for (Foo(x: Int) <- xs) yield x
   }
   def f2(xs: List[Foo[Any]]) = {
-    for (Foo(x: Int) <- xs) yield x
+    for (case Foo(x: Int) <- xs) yield x
   }
 }

tests/pos/t6205.scala

@@ -2,7 +2,7 @@
 class A[T]
 class Test1 {
   def x(backing: Map[A[_], Any]) =
-    for( (k: A[kt], v) <- backing)
+    for(case (k: A[kt], v) <- backing)
       yield (k: A[kt])
 }
 

tests/run/ReplacementMatching.scala

@@ -32,12 +32,12 @@ object Test {
 
   def groupsMatching: Unit = {
     val Date = """(\d+)/(\d+)/(\d+)""".r
-    for (Regex.Groups(a, b, c) <- Date findFirstMatchIn "1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.") {
+    for (case Regex.Groups(a, b, c) <- Date findFirstMatchIn "1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.") {
       assert(a == "1")
       assert(b == "1")
       assert(c == "2001")
     }
-    for (Regex.Groups(a, b, c) <- (Date findAllIn "1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.").matchData) {
+    for (case Regex.Groups(a, b, c) <- (Date findAllIn "1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.").matchData) {
       assert(a == "1" || a == "31")
       assert(b == "1" || b == "12")
       assert(c == "2001" || c == "2000")

tests/run/patmat-bind-typed.scala

@@ -1,5 +1,5 @@
 object Test {
-  def f(xs: List[Any]) = for (key @ (dummy: String) <- xs) yield key
+  def f(xs: List[Any]) = for (case key @ (dummy: String) <- xs) yield key
 
   def main(args: Array[String]): Unit = {
     f("abc" :: Nil) foreach println

tests/run/quoted-sematics-1.scala

@@ -82,24 +82,24 @@ def typeChecks(g: Gamma)(level: 0 | 1)(term: Term): Option[Type] =
       yield LambdaType(t, res)
     case App(fun, arg) => // T-App
       for
-        LambdaType(t1, t2) <- typeChecks(g)(level)(fun)
+        case LambdaType(t1, t2) <- typeChecks(g)(level)(fun)
         `t1` <- typeChecks(g)(level)(arg)
       yield t2
     case Box(body) if level == 0 => // T-Box
       for t <- typeChecks(g)(1)(body) yield BoxType(t)
     case Lift(body) if level == 0 => // T-Lift
       for NatType <- typeChecks(g)(0)(body) yield BoxType(NatType)
     case Splice(body) if level == 1 => // T-Unbox
-      for BoxType(t) <- typeChecks(g)(0)(body) yield t
+      for case BoxType(t) <- typeChecks(g)(0)(body) yield t
     case Match(scrutinee, pat, thenp, elsep) => // T-Pat
       for
-        BoxType(t1) <- typeChecks(g)(0)(scrutinee)
+        case BoxType(t1) <- typeChecks(g)(0)(scrutinee)
         delta <- typePatChecks(g, t1)(pat)
         t <- typeChecks(g ++ delta)(0)(thenp)
         `t` <- typeChecks(g)(0)(elsep)
       yield t
     case Fix(t) if level == 0 =>
-      for LambdaType(t1, t2) <- typeChecks(g)(0)(t) yield t2 // T-Fix
+      for case LambdaType(t1, t2) <- typeChecks(g)(0)(t) yield t2 // T-Fix
     case _ => None
   if res.isEmpty then
     println(s"Failed to type $term at level $level with environment $g")

tests/run/t6406-regextract.scala

@@ -20,10 +20,10 @@ object Test extends App {
   val t = "Last modified 2011-07-15"
   val p1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
   val y1: Option[String] = for {
-    p1(year, month, day) <- p1 findFirstIn t
+    case p1(year, month, day) <- p1 findFirstIn t
   } yield year
   val y2: Option[String] = for {
-    p1(year, month, day) <- p1 findFirstMatchIn t
+    case p1(year, month, day) <- p1 findFirstMatchIn t
   } yield year
   println(s"$y1 $y2")
 

tests/run/t6646.scala

@@ -8,9 +8,9 @@ object Test {
     val l = List(PrimaryKey, NoNull, lower)
 
     // withFilter must be generated in these
-    for (option @ NoNull <- l) println("Found " + option)
-    for (option @ `lower` <- l) println("Found " + option)
-    for ((`lower`, i) <- l.zipWithIndex) println("Found " + i)
+    for (case option @ NoNull <- l) println("Found " + option)
+    for (case option @ `lower` <- l) println("Found " + option)
+    for (case (`lower`, i) <- l.zipWithIndex) println("Found " + i)
 
     // no withFilter
     for (X <- List("A single ident is always a pattern")) println(X)

tests/run/t6968.scala

@@ -1,7 +1,7 @@
 object Test {
   def main(args: Array[String]): Unit = {
     val mixedList = List(1,(1,2),4,(3,1),(5,4),6)
-    val as = for((a,b) <- mixedList) yield a
+    val as = for(case (a,b) <- mixedList) yield a
     println(as.mkString(", "))
   }
 }