Replace sub match introducer keyword from with to if

Author: EugeneFlesselle

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

@@ -2585,22 +2585,54 @@ object Parsers {
         mkIf(cond, thenp, elsep)
       }
 
+    /* When parsing (what will become) a sub sub match, that is,
+     * when in a guard of case of a match, in a guard of case of a match;
+     * we will eventually reach Scanners.handleNewLine at the end of the sub sub match
+     * with an in.currretRegion of the shape `InCase +: Indented :+ InCase :+ Indented :+ ...`
+     * if we did not do dropInnerCaseRegion.
+     * In effect, a single outdent would be inserted by handleNewLine after the sub sub match.
+     * This causes the remaining cases of the outer match to be included in the intermediate sub match.
+     * For example:
+     *    match
+     *      case x1 if x1 match
+     *        case y if y match
+     *          case z => "a"
+     *      case x2 => "b"
+     * would become
+     *    match
+     *      case x1 if x1 match {
+     *        case y if y match {
+     *          case z => "a"
+     *        }
+     *        case x2 => "b"
+     *     }
+     * This issue is avoided by dropping the `InCase` region when parsing match clause,
+     * since `Indetented :+ Indented :+ ...` now allows handleNewLine to insert two outdents.
+     * Note that this _could_ break previous code which relied on matches within guards
+     * being considered as a separate region without explicit indentation.
+     */
+    private def dropInnerCaseRegion(): Unit =
+      in.currentRegion match
+        case Indented(width, prefix, Scanners.InCase(r)) => in.currentRegion = Indented(width, prefix, r)
+        case Scanners.InCase(r) => in.currentRegion = r
+        case _ =>
+
     /**    MatchClause ::= `match' `{' CaseClauses `}'
+     *                   | `match' ExprCaseClause
      */
     def matchClause(t: Tree): Match =
       atSpan(startOffset(t), in.skipToken()) {
-        Match(t, inBracesOrIndented(caseClauses(() => caseClause())))
+        val cases =
+          if in.featureEnabled(Feature.subCases) then
+            dropInnerCaseRegion()
+            if in.token == CASE
+            then caseClause(exprOnly = true) :: Nil // single case without new line
+            else inBracesOrIndented(caseClauses(() => caseClause()))
+          else
+            inBracesOrIndented(caseClauses(() => caseClause()))
+        Match(t, cases)
       }
 
-    /** SubMatchClause ::= `match' `{' CaseClauses `}'
-     */
-    def subMatchClause(t: Tree): SubMatch = atSpan(startOffset(t), accept(MATCH)):
-      val cases =
-        if in.token == CASE
-        then caseClause(exprOnly = true) :: Nil // single sub case without new line
-        else inBracesOrIndented(caseClauses(() => caseClause()))
-      SubMatch(t, cases)
-
     /**    `match' <<< TypeCaseClauses >>>
      */
     def matchType(t: Tree): MatchTypeTree =
@@ -3109,12 +3141,19 @@ object Parsers {
         accept(CASE)
         (withinMatchPattern(pattern()), guard())
       }
-      val body =
-        if in.token == WITH && in.featureEnabled(Feature.subCases) then atSpan(in.skipToken()):
-          val t = subMatchClause(simpleExpr(Location.ElseWhere))
+      var grd1 = grd // may be reset to EmptyTree (and used as sub match body instead) if there is no leading ARROW
+      val tok = in.token
+
+      extension (self: Tree) def asSubMatch: Tree = self match
+        case Match(sel, cases) if in.featureEnabled(Feature.subCases) =>
           if in.isStatSep then in.nextToken() // else may have been consumed by sub sub match
-          t
-        else atSpan(accept(ARROW)):
+          SubMatch(sel, cases)
+        case _ =>
+          syntaxErrorOrIncomplete(ExpectedTokenButFound(ARROW, tok))
+          EmptyTree
+
+      val body = tok match
+        case ARROW =>  atSpan(in.skipToken()):
           if exprOnly then
             if in.indentSyntax && in.isAfterLineEnd && in.token != INDENT then
               warning(em"""Misleading indentation: this expression forms part of the preceding catch case.
@@ -3123,7 +3162,16 @@ object Parsers {
                           |an indented case.""")
             expr()
           else block()
-      CaseDef(pat, grd, body)
+        case IF => atSpan(in.skipToken()):
+          // a sub match after a guard is parsed the same as one without
+          val t = inSepRegion(InCase)(postfixExpr(Location.InGuard))
+          t.asSubMatch
+        case other =>
+          val t = grd1.asSubMatch
+          grd1 = EmptyTree
+          t
+
+      CaseDef(pat, grd1, body)
     }
 
     /** TypeCaseClause     ::= ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]

tests/neg/parser-stability-20.scala

@@ -2,5 +2,4 @@ object x0 {
 def unapply= Array
 x0 match
 x0        // error
-case x0(  // error
-// error
+case x0(

tests/pos/inline-match-sub-cases.scala

@@ -5,10 +5,10 @@ object Test:
   // using transparent to test whether test whether reduced as expected
   transparent inline def foo(i: Int, j: Int): String =
     inline i match
-      case 0 with j match
+      case 0 if j match
         case 1 => "01"
         case 2 => "02"
-      case 1 with j match
+      case 1 if j match
         case 1 => "11"
         case 2 => "12"
       case _ => "3"
@@ -20,7 +20,7 @@ object Test:
 
   transparent inline def bar(x: Option[Any]): String =
     inline x match
-      case Some(y: Int) with y match
+      case Some(y: Int) if y match
         case 1 => "a"
         case 2 => "b"
       case Some(z: String) => "c"

tests/pos/match-single-sub-case.scala

@@ -1,17 +1,17 @@
 import scala.language.experimental.subCases
 
-// single sub case can be one the same line as outer case
+// single sub case can be on the same line as outer case
 object Test:
   val x: Option[Option[Int]] = ???
   x match
-    case Some(x2) with x2 match case Some(x3) => "aa"
-    case Some(x2) if false with x2 match case Some(x3) if true => "aa"
-    case Some(x2) with x2 match case Some(x3) with x2 match case Some(x3) => "bb"
-    case Some(y2) with y2 match
-      case Some(y3) with y3 match
+    case Some(x2) if x2 match case Some(x3) => "aa"
+    case Some(x2) if false if x2 match case Some(x3) if true => "aa"
+    case Some(x2) if x2 match case Some(x3) if x2 match case Some(x3) => "bb"
+    case Some(y2) if y2 match
+      case Some(y3) if y3 match
         case 1 => "a"
         case 2 => "b"
-    case Some(x2) with x2 match case Some(x3) with x3 match
+    case Some(x2) if x2 match case Some(x3) if x3 match
       case 1 => "a"
       case 2 => "b"
     case None => "d"

tests/pos/match-sub-sub-cases.scala

@@ -3,15 +3,17 @@ import scala.language.experimental.subCases
 object Test:
   val x: Option[Option[Int]] = ???
   x match
-    case Some(x2) with x2 match
-      case Some(x3) with x3 match
+    case Some(x2) if true if x2 match
+      case Some(x3) if false if x3 match
         case 1 => "a"
-        case 2 => "b"
+        case x if x % 2 == 0 if x match
+          case 4 => "b"
+          case 6 => "b"
     case None => "d"
 
   x match {
-    case Some(x2) with x2 match {
-      case Some (x3) with x3 match {
+    case Some(x2) if x2 match {
+      case Some (x3) if x3 match {
         case 1 => "a"
         case 2 => "b"
       }

tests/run/catch-sub-cases.scala

@@ -10,10 +10,10 @@ import E.*
 
 def test(op: => Nothing): String =
   try op catch
-    case A(x: Int) if true with x match
+    case A(x: Int) if true if x match
       case 1 => "A(1)"
       case 2 => "A(2)"
-    case B(x: String) with x match
+    case B(x: String) if x match
       case "a" => "B(a)"
       case "b" => "B(b)"
     case _ => "other"

tests/run/match-sub-cases.scala

@@ -17,12 +17,12 @@ import E.*
 @main def Test =
 
   def test(e: E): Int = e match
-    case A(B(e1)) if true with e1.f match
-      case Some(x) with x match
+    case A(B(e1)) if true if e1.f match
+      case Some(x) if x match
         case A(_) => 11
         case C => 12
-    case B(A(e1)) with e1.f match
-      case Some(C) => 21
+    case B(A(e1)) if e1.f match
+      case Some(C) if false || true => 21
       case None => 22
     case _ => 3
   end test

tests/run/pf-sub-cases.scala

@@ -1,8 +1,8 @@
 import scala.language.experimental.subCases
 
 val pf: PartialFunction[Option[Option[Int]], String] =
-  case Some(x2) with x2 match
-    case Some(x3) with x3 match
+  case Some(x2) if x2 match
+    case Some(x3) if x3 match
       case 1 => "a"
       case 2 => "b"
   case Some(None) => "c"

tests/warn/sub-cases-exhaustivity.scala

@@ -13,19 +13,19 @@ object Test:
   val e: E = ???
 
   e match // warn: match may not be exhaustive: It would fail on pattern case: E.A(_) | E.B(_)
-    case A(e1) with e1.f match
+    case A(e1) if e1.f match
       case B(_) => 11
       case C => 12
-    case B(e1) with e1.f match
+    case B(e1) if e1.f match
       case C => 21
       case A(_) => 22
     case C => 3
 
   e match // warn: match may not be exhaustive: It would fail on pattern case: E.B(_)
-    case A(e1) with e1.f match
+    case A(e1) if e1.f match
       case B(_) => 11
       case C => 12
-    case B(e1) with e1.f match
+    case B(e1) if e1.f match
       case C => 21
       case A(_) => 22
     case A(_) => 3 // nowarn: should not be reported as unreachable