Allow curried lambdas with indented blocks

Author: odersky

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

@@ -1114,27 +1114,32 @@ object Parsers {
           lookahead.observeArrowIndented()
           if lookahead.token == INDENT || lookahead.token == EOF then
             Some(() => expr(Location.InColonArg))
-          else if in.featureEnabled(Feature.relaxedLambdaSyntax)
-              && !in.currentRegion.isInstanceOf[InParens]
-          then
-            Some: () =>
-              val t = inSepRegion(SingleLineLambda(_)):
-                expr(Location.InColonArg)
-              accept(ENDlambda)
-              t
+          else if in.featureEnabled(Feature.relaxedLambdaSyntax) then
+            isParamsAndArrow() match
+              case success @ Some(_) => success
+              case _ if !in.currentRegion.isInstanceOf[InParens] =>
+                Some: () =>
+                  val t = inSepRegion(SingleLineLambda(_)):
+                    expr(Location.InColonArg)
+                  accept(ENDlambda)
+                  t
+              case _ => None
           else None
         else None
-      lookahead.nextToken()
-      if lookahead.isIdent || lookahead.token == USCORE then
+      def isParamsAndArrow(): Option[() => Tree] =
         lookahead.nextToken()
-        isArrowIndent()
-      else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
-        lookahead.skipParens()
-        isArrowIndent()
-      else if lookahead.token == CASE && in.featureEnabled(Feature.relaxedLambdaSyntax) then
-        Some(() => singleCaseMatch())
-      else
-        None
+        if lookahead.isIdent || lookahead.token == USCORE then
+          lookahead.nextToken()
+          isArrowIndent()
+        else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+          lookahead.skipParens()
+          isArrowIndent()
+        else if lookahead.token == CASE && in.featureEnabled(Feature.relaxedLambdaSyntax) then
+          Some(() => singleCaseMatch())
+        else
+          None
+      isParamsAndArrow()
+    end followingIsLambdaAfterColon
 
     /** Can the next lookahead token start an operand as defined by
      *  leadingOperandTokens, or is postfix ops enabled?
@@ -2804,7 +2809,7 @@ object Parsers {
      *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
      *                 |  SimpleExpr1 ArgumentExprs
      *                 |  SimpleExpr1 ColonArgument
-     *  ColonArgument ::= colon [LambdaStart]
+     *  ColonArgument ::= colon {LambdaStart}
      *                    indent (CaseClauses | Block) outdent
      *                 |  colon LambdaStart expr ENDlambda        -- under experimental.relaxedLambdaSyntax
      *                 |  colon ExprCaseClause                    -- under experimental.relaxedLambdaSyntax

docs/_docs/internals/syntax.md

@@ -294,9 +294,9 @@ SimpleExpr        ::=  SimpleRef
                     |  SimpleExpr ColonArgument                                 -- under language.experimental.fewerBraces
                     |  SimpleExpr ‘_’                                           PostfixOp(expr, _) (to be dropped)
                     |  XmlExpr							-- to be dropped
-ColonArgument     ::=  colon [LambdaStart]
+ColonArgument     ::=  colon {LambdaStart}
                        indent (CaseClauses | Block) outdent
-                    |  colon LambdaStart expr ENDlambda                         -- ENDlambda is inserted for each production at next EOL
+                    |  colon LambdaStart {LambdaStart} expr ENDlambda                         -- ENDlambda is inserted for each production at next EOL
                                                                                 -- does not apply if enclosed in parens
                     |  colon ExprCaseClause
 LambdaStart       ::=  FunParams (‘=>’ | ‘?=>’)

tests/neg/closure-args.check

@@ -20,10 +20,10 @@
    |                    expression expected but end of single-line lambda found
    |
    | longer explanation available when compiling with `-explain`
--- [E040] Syntax Error: tests/neg/closure-args.scala:21:64 -------------------------------------------------------------
-21 |val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error
-   |                                                                ^^^^
-   |                                                            end of single-line lambda expected, but 'case' found
+-- [E040] Syntax Error: tests/neg/closure-args.scala:21:41 -------------------------------------------------------------
+21 |val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error // error
+   |                                         ^
+   |                                         'case' expected, but identifier found
 -- [E008] Not Found Error: tests/neg/closure-args.scala:10:4 -----------------------------------------------------------
  8 |val b: Int = xs
  9 |  .map: x => x
@@ -57,3 +57,10 @@
    |                              Not found: type y
    |
    | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/closure-args.scala:21:97 ------------------------------------------------------
+21 |val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error // error
+   |                                                                                                 ^
+   |                                                                                      Found:    Unit
+   |                                                                                      Required: List[Int] => Int
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg/closure-args.scala

@@ -18,4 +18,4 @@ val c = List(xs.map: y => y + y)  // error // error // error // error
 val e = xs.map: y => // error
 y + 1
 
-val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error
+val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error // error

tests/pos/curried-colon-lambda.scala

@@ -0,0 +1,12 @@
+import language.experimental.relaxedLambdaSyntax
+
+def fun(f: Int => Int => Int): Int = f(1)(2)
+
+val a = fun: (x: Int) =>
+  (y: Int) => x + y
+
+val b = fun: (x: Int) => (y: Int) => x + y
+
+val c = fun: (x: Int) => (y: Int) =>
+  x + y
+