Drop special single-case syntax for match

 - A match usually has more than one case anyway
 - That way, we increase the precedence of `match`, since
   what follows is always atomic.

Author: odersky

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

@@ -1951,20 +1951,20 @@ object Parsers {
         mkIf(cond, thenp, elsep)
       }
 
-    /**    `match' (`{' CaseClauses `}' | CaseClause)
+    /**    `match' `{' CaseClauses `}'
      */
     def matchExpr(t: Tree, start: Offset, mkMatch: (Tree, List[CaseDef]) => Match) =
       in.endMarkerScope(MATCH) {
         atSpan(start, in.skipToken()) {
-          mkMatch(t, casesExpr(caseClause))
+          mkMatch(t, inBracesOrIndented(caseClauses(caseClause)))
         }
       }
 
-    /**    `match' (`{' TypeCaseClauses `}' | TypeCaseClause)
+    /**    `match' `{' TypeCaseClauses `}'
      */
     def matchType(t: Tree): MatchTypeTree =
       atSpan(t.span.start, accept(MATCH)) {
-        MatchTypeTree(EmptyTree, t, casesExpr(typeCaseClause))
+        MatchTypeTree(EmptyTree, t, inBracesOrIndented(caseClauses(typeCaseClause)))
       }
 
     /** FunParams         ::=  Bindings
@@ -2395,10 +2395,6 @@ object Parsers {
       }
     }
 
-    def casesExpr(clause: () => CaseDef): List[CaseDef] =
-      if in.token == CASE then clause() :: Nil
-      else inBracesOrIndented(caseClauses(clause))
-
     /** CaseClauses         ::= CaseClause {CaseClause}
      *  TypeCaseClauses     ::= TypeCaseClause {TypeCaseClause}
      */

docs/docs/internals/syntax.md

@@ -147,8 +147,7 @@ FunArgTypes       ::=  InfixType
                     |  ‘(’ [ ‘[given]’ FunArgType {‘,’ FunArgType } ] ‘)’
                     |  ‘(’ ‘[given]’ TypedFunParam {‘,’ TypedFunParam } ‘)’
 TypedFunParam     ::=  id ‘:’ Type
-MatchType         ::=  InfixType `match`
-                       (‘{’ TypeCaseClauses ‘}’ | TypeCaseClause)
+MatchType         ::=  InfixType `match` ‘{’ TypeCaseClauses ‘}’
 InfixType         ::=  RefinedType {id [nl] RefinedType}                        InfixOp(t1, op, t2)
 RefinedType       ::=  WithType {[nl | ‘with’] Refinement}                      RefinedTypeTree(t, ds)
 WithType          ::=  AnnotType {‘with’ AnnotType}                             (deprecated)
@@ -199,8 +198,7 @@ Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl}
                     |  [SimpleExpr ‘.’] id ‘=’ Expr                             Assign(expr, expr)
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr                       Assign(expr, expr)
                     |  Expr2
-                    |  [‘inline’] Expr2 ‘match’
-                       (‘{’ CaseClauses ‘}’ | CaseClause)                       Match(expr, cases) -- point on match
+                    |  [‘inline’] Expr2 ‘match’ ‘{’ CaseClauses ‘}’             Match(expr, cases) -- point on match
 Expr2             ::=  PostfixExpr [Ascription]
 Ascription        ::=  ‘:’ InfixType                                            Typed(expr, tp)
                     |  ‘:’ Annotation {Annotation}                              Typed(expr, Annotated(EmptyTree, annot)*)

tests/pos/i6997c.scala

@@ -4,11 +4,11 @@ import scala.quoted.{_, given}, scala.quoted.matching._
 
 inline def mcr(x: => Any): Any = ${mcrImpl('x)}
 
-def mcrImpl(body: Expr[Any])(given ctx: QuoteContext): Expr[Any] = {
-  body match case '{$x: $t} =>
-  '{
-    val tmp: $t = $x
-    println(tmp)
-    tmp
-  }
-}
+def mcrImpl(body: Expr[Any])(given ctx: QuoteContext): Expr[Any] =
+  body match
+    case '{$x: $t} =>
+      '{
+        val tmp: $t = $x
+        println(tmp)
+        tmp
+      }

tests/pos/single-case.scala

@@ -1,11 +1,7 @@
 object test with
 
-  type T[X] = X match case Int => X
-
   try
     println("hi")
   catch case ex: java.io.IOException => println("ho")
 
-  1 match case x: Int => println(x)
-