Enforce stricter pattern binding rules by default

Author: griggt

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

@@ -1578,10 +1578,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

@@ -169,7 +169,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

@@ -2508,9 +2508,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

@@ -817,7 +817,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")),

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()
 }