Allow single case clauses as expressions

Author: odersky

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

@@ -2383,6 +2383,7 @@ object Parsers {
 
     /** Expr              ::=  [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
      *                      |  TypTypeParamClause ‘=>’ Expr
+     *                      |  ExprCaseClause
      *                      |  Expr1
      *  FunParams         ::=  Bindings
      *                      |  id
@@ -2434,6 +2435,8 @@ object Parsers {
           val arrowOffset = accept(ARROW)
           val body = expr(location)
           makePolyFunction(tparams, body, "literal", errorTermTree(arrowOffset), start, arrowOffset)
+        case CASE =>
+          singleCaseMatch()
         case _ =>
           val saved = placeholderParams
           placeholderParams = Nil
@@ -2497,9 +2500,8 @@ object Parsers {
             if in.token == CATCH then
               val span = in.offset
               in.nextToken()
-              (if in.token == CASE then Match(EmptyTree, caseClause(exprOnly = true) :: Nil)
-                else subExpr(),
-                span)
+              (if in.token == CASE then singleCaseMatch() else subExpr(),
+               span)
             else (EmptyTree, -1)
 
           handler match {
@@ -3193,9 +3195,9 @@ object Parsers {
         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.
+              warning(em"""Misleading indentation: this expression forms part of the preceding case.
                           |If this is intended, it should be indented for clarity.
-                          |Otherwise, if the handler is intended to be empty, use a multi-line catch with
+                          |Otherwise, if the handler is intended to be empty, use a multi-line match or catch with
                           |an indented case.""")
             expr()
           else block()
@@ -3212,6 +3214,9 @@ object Parsers {
       CaseDef(pat, grd1, body)
     }
 
+    def singleCaseMatch() =
+      Match(EmptyTree, caseClause(exprOnly = true) :: Nil)
+
     /** TypeCaseClause     ::= ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
      */
     def typeCaseClause(): CaseDef = atSpan(in.offset) {

docs/_docs/internals/syntax.md

@@ -243,6 +243,7 @@ CapFilter         ::=  ‘.’ ‘as’ ‘[’ QualId ’]’
 ```ebnf
 Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr                            Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
                     |  TypTypeParamClause ‘=>’ Expr                             PolyFunction(ts, expr)
+                    |  ExprCaseClause
                     |  Expr1
 BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
                     |  TypTypeParamClause ‘=>’ Block
@@ -295,6 +296,8 @@ SimpleExpr        ::=  SimpleRef
                     |  XmlExpr							-- to be dropped
 ColonArgument     ::=  colon [LambdaStart]
                        indent (CaseClauses | Block) outdent
+                    |  colon LambdaStart expr ENDlambda                         -- ENDlambda is inserted for each production at next EOL
+                                                                                -- does not apply if enclosed in parens
 LambdaStart       ::=  FunParams (‘=>’ | ‘?=>’)
                     |  TypTypeParamClause ‘=>’
 Quoted            ::=  ‘'’ ‘{’ Block ‘}’

tests/run/single-case-expr.scala

@@ -0,0 +1,21 @@
+case class Foo(x: Int, y: Int)
+@main def Test =
+  val f: List[Int] => Int = case y :: ys => y
+  val xs = List(1, 2, 3)
+  assert(f(xs) == 1)
+
+  val g: Foo => Int = identity(case Foo(a, b) => a)
+  val foo = Foo(1, 2)
+  assert(g(foo) == 1)
+
+  val a1 = Seq((1, 2), (3, 4)).collect(case (a, b) if b > 2 => a)
+  assert(a1 == Seq(3))
+
+  var a2 = Seq((1, 2), (3, 4)).collect(
+    case (a, b) =>
+      println(b)
+      a
+  )
+  assert(a2 == Seq(1, 3))
+
+  val partial: PartialFunction[(Int, Int), Int] = case (a, b) if b > 2 => a