Change fewer-braces parsing to allow inline lambdas

 - Allow lambda arguments on one line

# Conflicts:
#	compiler/src/dotty/tools/dotc/parsing/Parsers.scala
#	docs/_docs/internals/syntax.md
#	tests/neg/closure-args.scala
#	tests/pos/closure-args.scala

Author: odersky

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

@@ -936,24 +936,17 @@ 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.
+     *  something enclosed in (...) or [...], and this is followed by a `=>` or `?=>`.
      */
     def followingIsLambdaAfterColon(): Boolean =
-      val lookahead = in.LookaheadScanner(allowIndent = true)
-      def isArrowIndent() =
-        lookahead.isArrow
-        && {
-          lookahead.nextToken()
-          lookahead.token == INDENT
-        }
+      val lookahead = in.LookaheadScanner()
       lookahead.nextToken()
       if lookahead.isIdent || lookahead.token == USCORE then
         lookahead.nextToken()
-        isArrowIndent()
+        lookahead.isArrow
       else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
         lookahead.skipParens()
-        isArrowIndent()
+        lookahead.isArrow
       else false
 
   /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
@@ -2255,7 +2248,13 @@ object Parsers {
           accept(ARROW)
         val body =
           if location == Location.InBlock then block()
-          else if location == Location.InColonArg && in.token == INDENT then blockExpr()
+          else if location == Location.InColonArg then
+            if in.token == INDENT then
+              blockExpr()
+            else
+              in.insertMaxIndent()
+              try casesOrBlock(simplify = true)
+              finally accept(OUTDENT)
           else expr()
         Function(params, body)
       }
@@ -2312,6 +2311,7 @@ object Parsers {
      *                 |  FunParams (‘=>’ | ‘?=>’) ColonArgBody
      *                 |  HkTypeParamClause ‘=>’ ColonArgBody
      *  ColonArgBody  ::= indent (CaseClauses | Block) outdent
+     *                 |  <silent-indent> (CaseClauses | Block) outdent   -- silent-indent is inserted by Scanner if no real indent is found
      *  Quoted        ::= ‘'’ ‘{’ Block ‘}’
      *                 |  ‘'’ ‘[’ Type ‘]’
      */
@@ -2502,12 +2502,13 @@ object Parsers {
      */
     def blockExpr(): Tree = atSpan(in.offset) {
       val simplify = in.token == INDENT
-      inDefScopeBraces {
-        if (in.token == CASE) Match(EmptyTree, caseClauses(() => caseClause()))
-        else block(simplify)
-      }
+      inDefScopeBraces { casesOrBlock(simplify) }
     }
 
+    def casesOrBlock(simplify: Boolean): Tree =
+      if (in.token == CASE) Match(EmptyTree, caseClauses(() => caseClause()))
+      else block(simplify)
+
     /** Block ::= BlockStatSeq
      *  @note  Return tree does not have a defined span.
      */

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

@@ -618,9 +618,13 @@ object Scanners {
                 if next.token != COLON then
                   handleNewIndentWidth(r.enclosing, ir =>
                     errorButContinue(
-                      i"""The start of this line does not match any of the previous indentation widths.
-                          |Indentation width of current line : $nextWidth
-                          |This falls between previous widths: ${ir.width} and $lastWidth"""))
+                      if r.indentWidth == IndentWidth.Max then
+                        i"""Enclosing expression is nested in a one line lambda expression following `:`.
+                           |It may not spill over to a new line."""
+                      else
+                        i"""The start of this line does not match any of the previous indentation widths.
+                            |Indentation width of current line : $nextWidth
+                            |This falls between previous widths: ${ir.width} and $lastWidth"""))
               case r =>
                 if skipping then
                   if r.enclosing.isClosedByUndentAt(nextWidth) then
@@ -661,7 +665,9 @@ object Scanners {
           currentRegion = Indented(nextWidth, COLONEOL, currentRegion)
           offset = next.offset
           token = INDENT
-    end observeIndented
+
+    def insertMaxIndent() =
+      currentRegion = Indented(IndentWidth.Max, ARROW, currentRegion)
 
     /** Insert an <outdent> token if next token closes an indentation region.
      *  Exception: continue if indentation region belongs to a `match` and next token is `case`.
@@ -1651,25 +1657,29 @@ object Scanners {
   enum IndentWidth {
     case Run(ch: Char, n: Int)
     case Conc(l: IndentWidth, r: Run)
+    case Max // delimits one-line lambdas following a `:`
 
-    def <= (that: IndentWidth): Boolean = this match {
+    def <= (that: IndentWidth): Boolean = this match
       case Run(ch1, n1) =>
-        that match {
+        that match
           case Run(ch2, n2) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
           case Conc(l, r) => this <= l
-        }
+          case Max => true
       case Conc(l1, r1) =>
         that match {
           case Conc(l2, r2) => l1 == l2 && r1 <= r2
+          case Max => true
           case _ => false
         }
-    }
+      case Max =>
+        that == Max
 
     def < (that: IndentWidth): Boolean = this <= that && !(that <= this)
 
     def toPrefix: String = this match {
       case Run(ch, n) => ch.toString * n
       case Conc(l, r) => l.toPrefix ++ r.toPrefix
+      case Max => "(max >>)"
     }
 
     override def toString: String = {
@@ -1681,6 +1691,7 @@ object Scanners {
       this match {
         case Run(ch, n) => s"$n ${kind(ch)}${if (n == 1) "" else "s"}"
         case Conc(l, r) => s"$l, $r"
+        case Max => "(max >>)"
       }
     }
   }

docs/_docs/internals/syntax.md

@@ -261,6 +261,7 @@ ColonArgument     ::=  indent CaseClauses | Block outdent
                     |  FunParams (‘=>’ | ‘?=>’) ColonArgBody
                     |  HkTypeParamClause ‘=>’ ColonArgBody
 ColonArgBody      ::=  indent (CaseClauses | Block) outdent
+                    |  <silent-indent> (CaseClauses | Block) outdent            -- silent-indent is inserted by Lexer if no real indent is found
 ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
 ExprInParens      ::=  PostfixExpr ‘:’ Type                                     -- normal Expr allows only RefinedType here
                     |  Expr

tests/neg/closure-args.scala

@@ -8,18 +8,7 @@ val z = List().map: + => // ok
   ???
 
 val xs = List(1)
-val b: Int = xs       // error
-  .map: x => x * x    // error
-  .filter: y => y > 0  // error
-  (0)
-val d = xs   // error
+val d = xs
   .map: x => x.toString + xs.dropWhile:
-    y => y > 0
+    y => y > 0  // error
 
-val c = List(xs.map: y => y + y)  // error // error
-val d2: String = xs    // error
-  .map: x => x.toString + xs.dropWhile: y => y > 0  // error // error
-  .filter: z => !z.isEmpty // error
-  (0)
-
-val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1  // error // error

tests/pos/closure-args.scala

@@ -15,19 +15,24 @@ object Test1:
     .filter: (y: Int) =>
       y > 0
     (0)
+  val b: Int = xs
+    .map: x => x * x
+    .filter: y => y > 0
+    (0)
+  val c = List(xs.map: y => y + y)
+  val d: String = xs
+    .map: x => x.toString + xs.dropWhile: y => y > 0
+    .filter: z => !z.isEmpty
+    (0)
   val e = xs.map:
       case 1 => 2
       case 2 => 3
       case x => x
-    .filter:
-      x => x > 0
+    .filter: x => x > 0
+  val fs: List[List[Int] => Int] = xs.map: x => case y :: ys => y case Nil => -1
 
   extension (xs: List[Int]) def foo(f: [X] => X => X) = ()
 
-  val p = xs.foo:
-    [X] => (x: X) => x
+  val p = xs.foo: [X] => (x: X) => x
 
   val q = (x: String => String) => x
-
-  val r = x < 0 && :
-    y > 0