Small tweaks

Author: odersky

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

@@ -1085,9 +1085,19 @@ object Parsers {
       }
 
     /** Is the token sequence following the current `:` token classified as a lambda?
-     *  This is the case if the input starts with an identifier, a wildcard, or
-     *  something enclosed in (...) or [...], and this is followed by a `=>` or `?=>`
-     *  and an INDENT.
+     *  If yes return a defined parsing function to parse the lambda body, if not
+     *  return None. The case is triggered in two :if the input starts with an identifier,
+     *  a wildcard, or something enclosed in (...) or [...], this is followed by a
+     *  `=>` or `?=>`, one one of the following two cases applies:
+     *    1. The next token is an indent. In this case the return parsing function parses
+     *       an Expr in location Location.InColonArg.
+     *    2. The next token is on the same line and the enclosing region is not `(...)`.
+     *       In this case the parsing function parses an Expr in location Location.InColonArg
+     *       enclosed in a SingleLineLambda region, and then eats the ENDlambda token
+     *       generated by the Scanner at the end of that region.
+     *  The reason for excluding (2) in regions enclosed in parentheses is to avoid
+     *  an ambiguity with type ascription `(x: A => B)`, where function types are only
+     *  allowed inside parentheses.
      */
     def followingIsLambdaAfterColon(): Option[() => Tree] =
       val lookahead = in.LookaheadScanner(allowIndent = true)
@@ -1101,7 +1111,7 @@ object Parsers {
             Some: () =>
               val t = inSepRegion(SingleLineLambda(_)):
                 expr(Location.InColonArg)
-              accept(ENDLAMBDA)
+              accept(ENDlambda)
               t
           else None
         else None
@@ -1178,11 +1188,14 @@ object Parsers {
         case _ => infixOp
     }
 
-    /** True if we are seeing a lambda argument after a colon of the form:
+    /** Optionally, if we are seeing a lambda argument after a colon of the form
      *    : (params) =>
      *      body
+     *  or a single-line lambda
+     *    : (params) => body
+     *  then return the function used to parse `body`.
      */
-    def isColonLambda: Option[() => Tree] =
+    def detectColonLambda: Option[() => Tree] =
       if sourceVersion.enablesFewerBraces && in.token == COLONfollow
       then followingIsLambdaAfterColon()
       else None
@@ -1209,7 +1222,7 @@ object Parsers {
           opStack = OpInfo(top1, op, in.offset) :: opStack
           colonAtEOLOpt()
           newLineOptWhenFollowing(canStartOperand)
-          isColonLambda match
+          detectColonLambda match
             case Some(parseExpr) =>
               in.nextToken()
               recur(parseExpr())
@@ -2778,6 +2791,7 @@ object Parsers {
      *                 |  SimpleExpr1 ColonArgument
      *  ColonArgument ::= colon [LambdaStart]
      *                    indent (CaseClauses | Block) outdent
+     *                 |  colon LambdaStart expr ENDlambda        -- under experimental.relaxedLambdaSyntax
      *  LambdaStart   ::= FunParams (‘=>’ | ‘?=>’)
      *                 |  TypTypeParamClause ‘=>’
      *  ColonArgBody  ::= indent (CaseClauses | Block) outdent
@@ -2860,7 +2874,7 @@ object Parsers {
                   makeParameter(name.asTermName, typedOpt(), Modifiers(), isBackquoted = isBackquoted(id))
                 }
               case _ => t
-          else isColonLambda match
+          else detectColonLambda match
             case Some(parseExpr) =>
               val app =
                 atSpan(startOffset(t), in.skipToken()):

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

@@ -617,8 +617,8 @@ object Scanners {
         && !statCtdTokens.contains(lastToken)
         && !isTrailingBlankLine
 
-      if currentRegion.closedBy == ENDLAMBDA then
-        insert(ENDLAMBDA, lineOffset)
+      if currentRegion.closedBy == ENDlambda then
+        insert(ENDlambda, lineOffset)
       else if newlineIsSeparating
          && canEndStatTokens.contains(lastToken)
          && canStartStatTokens.contains(token)
@@ -1685,7 +1685,7 @@ object Scanners {
   case class InParens(prefix: Token, outer: Region) extends Region(prefix + 1)
   case class InBraces(outer: Region) extends Region(RBRACE)
   case class InCase(outer: Region) extends Region(OUTDENT)
-  case class SingleLineLambda(outer: Region) extends Region(ENDLAMBDA)
+  case class SingleLineLambda(outer: Region) extends Region(ENDlambda)
 
   /** A class describing an indentation region.
    *  @param width   The principal indentation width

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

@@ -203,7 +203,7 @@ object Tokens extends TokensCommon {
     // A `:` recognized as starting an indentation block
   inline val SELFARROW = 90;        enter(SELFARROW, "=>") // reclassified ARROW following self-type
 
-  inline val ENDLAMBDA = 99;        enter(ENDLAMBDA, "end of single-line lambda")
+  inline val ENDlambda = 99;        enter(ENDlambda, "end of single-line lambda")
 
   /** XML mode */
   inline val XMLSTART = 100;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
@@ -269,7 +269,7 @@ object Tokens extends TokensCommon {
   final val canStartStatTokens3: TokenSet = canStartExprTokens3 | mustStartStatTokens | BitSet(
     AT, CASE, END)
 
-  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT, ENDLAMBDA)
+  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT, ENDlambda)
 
   /** Tokens that stop a lookahead scan search for a `<-`, `then`, or `do`.
    *  Used for disambiguating between old and new syntax.

tests/neg/closure-args.check

@@ -14,12 +14,16 @@
    |    Illegal start of toplevel definition
    |
    | longer explanation available when compiling with `-explain`
--- [E018] Syntax Error: tests/neg/closure-args.scala:18:46 -------------------------------------------------------------
-18 |val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error
-   |                                              ^^^^
-   |                                              expression expected but case found
+-- [E018] Syntax Error: tests/neg/closure-args.scala:18:20 -------------------------------------------------------------
+18 |val e = xs.map: y => // error
+   |                    ^
+   |                    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
 -- [E008] Not Found Error: tests/neg/closure-args.scala:10:4 -----------------------------------------------------------
  8 |val b: Int = xs
  9 |  .map: x => x

tests/neg/closure-args.scala

@@ -15,4 +15,7 @@ val d = xs
 
 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