Syntax change for single cases

Allow a single case clause after a match or catch without requiring
braces or indent tokens around it. E.g.

    try ...
    catch case ex: Ex => ...

    s match case p => ...

Ratiionale: With indentation syntax, it feels natural to shorten

    try ...
    catch
      case ex: Ex => ...

to

    try ...
    catch case ex: Ex => ...

Author: odersky

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

@@ -1248,6 +1248,9 @@ object Parsers {
       // note: next is defined here because current == NEWLINE
       if (in.token == NEWLINE && in.next.token == token) in.nextToken()
 
+    def newLinesOptWhenFollowedBy(token: Int): Unit =
+      if in.isNewLine && in.next.token == token then in.nextToken()
+
     def newLinesOptWhenFollowedBy(name: Name): Unit =
       if in.isNewLine && in.next.token == IDENTIFIER && in.next.name == name then
         in.nextToken()
@@ -1742,8 +1745,7 @@ object Parsers {
      *                      |  [SimpleExpr `.'] id `=' Expr
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  Expr2
-     *                      |  [‘inline’] Expr2 `match' `{' CaseClauses `}'
-     *                      |  `given' `match' `{' ImplicitCaseClauses `}'
+     *                      |  [‘inline’] Expr2 `match' (`{' CaseClauses `}' | CaseClause)
      *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
      *  Binding           ::=  (id | `_') [`:' Type]
      *  Expr2             ::=  PostfixExpr [Ascription]
@@ -1829,11 +1831,12 @@ object Parsers {
           atSpan(in.skipToken()) {
             val body = expr()
             val (handler, handlerStart) =
-              if (in.token == CATCH) {
+              if in.token == CATCH then
                 val span = in.offset
                 in.nextToken()
-                (subExpr(), span)
-              }
+                (if in.token == CASE then Match(EmptyTree, caseClause() :: Nil)
+                 else subExpr(),
+                 span)
               else (EmptyTree, -1)
 
             handler match {
@@ -1955,20 +1958,20 @@ object Parsers {
         mkIf(cond, thenp, elsep)
       }
 
-    /**    `match' { CaseClauses }
+    /**    `match' (`{' CaseClauses `}' | CaseClause)
      */
     def matchExpr(t: Tree, start: Offset, mkMatch: (Tree, List[CaseDef]) => Match) =
       indentRegion(MATCH) {
         atSpan(start, in.skipToken()) {
-          mkMatch(t, inBracesOrIndented(caseClauses(caseClause)))
+          mkMatch(t, casesExpr(caseClause))
         }
       }
 
-    /**    `match' { TypeCaseClauses }
+    /**    `match' (`{' TypeCaseClauses `}' | TypeCaseClause)
      */
     def matchType(t: Tree): MatchTypeTree =
       atSpan(t.span.start, accept(MATCH)) {
-        inBracesOrIndented(MatchTypeTree(EmptyTree, t, caseClauses(typeCaseClause)))
+        MatchTypeTree(EmptyTree, t, casesExpr(typeCaseClause))
       }
 
     /** FunParams         ::=  Bindings
@@ -2399,8 +2402,11 @@ object Parsers {
       }
     }
 
+    def casesExpr(clause: () => CaseDef): List[CaseDef] =
+      if in.token == CASE then clause() :: Nil
+      else inBracesOrIndented(caseClauses(clause))
+
     /** CaseClauses         ::= CaseClause {CaseClause}
-     *  ImplicitCaseClauses ::= ImplicitCaseClause {ImplicitCaseClause}
      *  TypeCaseClauses     ::= TypeCaseClause {TypeCaseClause}
      */
     def caseClauses(clause: () => CaseDef): List[CaseDef] = {
@@ -2410,9 +2416,8 @@ object Parsers {
       buf.toList
     }
 
-   /** CaseClause         ::= ‘case’ Pattern [Guard] `=>' Block
-    *  ImplicitCaseClause ::= ‘case’ PatVar [Ascription] [Guard] `=>' Block
-    */
+    /** CaseClause         ::= ‘case’ Pattern [Guard] `=>' Block
+     */
     val caseClause: () => CaseDef = () => atSpan(in.offset) {
       val (pat, grd) = inSepRegion(LPAREN, RPAREN) {
         accept(CASE)
@@ -2430,7 +2435,7 @@ object Parsers {
       }
       CaseDef(pat, EmptyTree, atSpan(accept(ARROW)) {
         val t = typ()
-        if (isStatSep) in.nextToken()
+        newLinesOptWhenFollowedBy(CASE)
         t
       })
     }

docs/docs/internals/syntax.md

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

tests/pos/single-case.scala

@@ -0,0 +1,11 @@
+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)
+
+