Enforce stricter pattern binding rules by default

Author: griggt

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1579,10 +1579,10 @@ object desugar {
         case _ => false
 
       def needsNoFilter(gen: GenFrom): Boolean =
-        if (gen.checkMode == GenCheckMode.FilterAlways) // pattern was prefixed by `case`
+        if gen.checkMode == GenCheckMode.FilterAlways then // pattern was prefixed by `case`
           false
         else
-          gen.checkMode != GenCheckMode.FilterNow
+          gen.checkMode == GenCheckMode.Ignore
           || isVarBinding(gen.pat)
           || isIrrefutable(gen.pat, gen.expr)
 

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -168,7 +168,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   enum GenCheckMode {
     case Ignore       // neither filter nor check since filtering was done before
     case Check        // check that pattern is irrefutable
-    case FilterNow    // filter out non-matching elements since we are not yet in 3.x
     case FilterAlways // filter out non-matching elements since pattern is prefixed by `case`
   }
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2515,9 +2515,8 @@ object Parsers {
     def generatorRest(pat: Tree, casePat: Boolean): GenFrom =
       atSpan(startOffset(pat), accept(LARROW)) {
         val checkMode =
-          if (casePat) GenCheckMode.FilterAlways
-          else if sourceVersion.isAtLeast(future) then GenCheckMode.Check
-          else GenCheckMode.FilterNow  // filter for now, to keep backwards compat
+          if casePat then GenCheckMode.FilterAlways
+          else GenCheckMode.Check
         GenFrom(pat, subExpr(), checkMode)
       }
 

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

@@ -814,7 +814,6 @@ trait Checking {
     def check(pat: Tree, pt: Type): Boolean = (pt <:< pat.tpe) || fail(pat, pt)
 
     def recur(pat: Tree, pt: Type): Boolean =
-      !sourceVersion.isAtLeast(future) || // only for 3.x for now since mitigations work only after this PR
       pt.hasAnnotation(defn.UncheckedAnnot) || {
         patmatch.println(i"check irrefutable $pat: ${pat.tpe} against $pt")
         pat match {

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

@@ -202,7 +202,6 @@ class CompilationTests {
     aggregateTests(
       compileFile("tests/run-custom-args/tuple-cons.scala", allowDeepSubtypes),
       compileFile("tests/run-custom-args/i5256.scala", allowDeepSubtypes),
-      compileFile("tests/run-custom-args/fors.scala", defaultOptions.and("-source", "future")),
       compileFile("tests/run-custom-args/no-useless-forwarders.scala", defaultOptions and "-Xmixin-force-forwarders:false"),
       compileFile("tests/run-custom-args/defaults-serizaliable-no-forwarders.scala", defaultOptions and "-Xmixin-force-forwarders:false"),
       compileFilesInDir("tests/run-custom-args/erased", defaultOptions.and("-language:experimental.erasedDefinitions")),

docs/_docs/reference/changed-features/pattern-bindings.md

@@ -7,7 +7,7 @@ movedTo: https://docs.scala-lang.org/scala3/reference/changed-features/pattern-b
 In Scala 2, pattern bindings in `val` definitions and `for` expressions are
 loosely typed. Potentially failing matches are still accepted at compile-time,
 but may influence the program's runtime behavior.
-From Scala 3.1 on, type checking rules will be tightened so that warnings are reported at compile-time instead.
+From Scala 3.2 on, type checking rules will be tightened so that warnings are reported at compile-time instead.
 
 ## Bindings in Pattern Definitions
 
@@ -16,7 +16,7 @@ val xs: List[Any] = List(1, 2, 3)
 val (x: String) :: _ = xs   // error: pattern's type String is more specialized
                             // than the right-hand side expression's type Any
 ```
-This code gives a compile-time warning in Scala 3.1 (and also in Scala 3.0 under the `-source future` setting) whereas it will fail at runtime with a `ClassCastException` in Scala 2. In Scala 3.1, a pattern binding is only allowed if the pattern is _irrefutable_, that is, if the right-hand side's type conforms to the pattern's type. For instance, the following is OK:
+This code gives a compile-time warning in Scala 3.2 (and also earlier Scala 3.x under the `-source future` setting) whereas it will fail at runtime with a `ClassCastException` in Scala 2. In Scala 3.2, a pattern binding is only allowed if the pattern is _irrefutable_, that is, if the right-hand side's type conforms to the pattern's type. For instance, the following is OK:
 ```scala
 val pair = (1, true)
 val (x, y) = pair
@@ -25,7 +25,7 @@ Sometimes one wants to decompose data anyway, even though the pattern is refutab
 ```scala
 val first :: rest = elems   // error
 ```
-This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.1 it will give a warning. One can avoid the warning by marking the right-hand side with an [`@unchecked`](https://scala-lang.org/api/3.x/scala/unchecked.html) annotation:
+This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.2 it will give a warning. One can avoid the warning by marking the right-hand side with an [`@unchecked`](https://scala-lang.org/api/3.x/scala/unchecked.html) annotation:
 ```scala
 val first :: rest = elems: @unchecked   // OK
 ```
@@ -40,7 +40,7 @@ val elems: List[Any] = List((1, 2), "hello", (3, 4))
 for (x, y) <- elems yield (y, x) // error: pattern's type (Any, Any) is more specialized
                                  // than the right-hand side expression's type Any
 ```
-This code gives a compile-time warning in Scala 3.1 whereas in Scala 2 the list `elems`
+This code gives a compile-time warning in Scala 3.2 whereas in Scala 2 the list `elems`
 is filtered to retain only the elements of tuple type that match the pattern `(x, y)`.
 The filtering functionality can be obtained in Scala 3 by prefixing the pattern with `case`:
 ```scala
@@ -56,4 +56,4 @@ Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr
 
 ## Migration
 
-The new syntax is supported in Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the `-source future` setting. They will be enabled by default in version 3.1 of the language.
+The new syntax is supported in Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the `-source future` setting. They will be enabled by default in version 3.2 of the language.

tests/neg-strict/filtering-fors.scala renamed to tests/neg-custom-args/fatal-warnings/filtering-fors.scala

@@ -26,3 +26,21 @@ testNew
 0 2 4 6 8 
 0 2 4 6 8 
 a b c 
+
+testFiltering
+hello  world 
+hello  world 
+hello  world 
+1~2 3~4 
+(empty)
+hello  world 
+hello/1~2 hello/3~4 /1~2 /3~4 world/1~2 world/3~4 
+(2,1) (4,3) 
+hello  world 
+hello  world 
+hello  world 
+1~2 3~4 
+(empty)
+hello  world 
+hello/1~2 hello/3~4 /1~2 /3~4 world/1~2 world/3~4 
+(2,1) (4,3) 

tests/neg-strict/unchecked-patterns.scala renamed to tests/neg-custom-args/fatal-warnings/unchecked-patterns.scala

@@ -14,7 +14,7 @@ object Test extends App {
 
   /////////////////// old syntax ///////////////////
 
-  def testOld: Unit = {
+  def testOld(): Unit = {
     println("\ntestOld")
 
     // lists
@@ -46,7 +46,7 @@ object Test extends App {
 
   /////////////////// new syntax ///////////////////
 
-  def testNew: Unit = {
+  def testNew(): Unit = {
     println("\ntestNew")
 
     // lists
@@ -77,8 +77,41 @@ object Test extends App {
 
   }
 
+  /////////////////// filtering with case ///////////////////
+
+  def testFiltering(): Unit = {
+    println("\ntestFiltering")
+
+    val xs: List[Any] = List((1, 2), "hello", (3, 4), "", "world")
+
+    for (case x: String <- xs) do print(s"$x "); println()
+    for (case (x: String) <- xs) do print(s"$x "); println()
+    for (case y@ (x: String) <- xs) do print(s"$y "); println()
+
+    for (case (x, y) <- xs) do print(s"$x~$y "); println()
+
+    for (case (x: String) <- xs if x.isEmpty) do print("(empty)"); println()
+    for (case (x: String) <- xs; y = x) do print(s"$y "); println()
+    for (case (x: String) <- xs; case (y, z) <- xs) do print(s"$x/$y~$z "); println()
+
+    for (case (x, y) <- xs) do print(s"${(y, x)} "); println()
+
+    for case x: String <- xs do print(s"$x "); println()
+    for case (x: String) <- xs do print(s"$x "); println()
+    for case y@ (x: String) <- xs do print(s"$y "); println()
+
+    for case (x, y) <- xs do print(s"$x~$y "); println()
+
+    for case (x: String) <- xs if x.isEmpty do print("(empty)"); println()
+    for case (x: String) <- xs; y = x do print(s"$y "); println()
+    for case (x: String) <- xs; case (y, z) <- xs do print(s"$x/$y~$z "); println()
+
+    for case (x, y) <- xs do print(s"${(y, x)} "); println()
+  }
+
   ////////////////////////////////////////////////////
 
-  testOld
-  testNew
+  testOld()
+  testNew()
+  testFiltering()
 }