Change fewer-braces parsing to new scheme

 - Require a colon in front of a lambda argument
 - Allow lambda arguments on one line

Author: odersky

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

@@ -43,6 +43,7 @@ object Parsers {
   enum Location(val inParens: Boolean, val inPattern: Boolean, val inArgs: Boolean):
     case InParens      extends Location(true, false, false)
     case InArgs        extends Location(true, false, true)
+    case InColonArg    extends Location(false, false, true)
     case InPattern     extends Location(false, true, false)
     case InGuard       extends Location(false, false, false)
     case InPatternArgs extends Location(false, true, true) // InParens not true, since it might be an alternative
@@ -893,7 +894,6 @@ object Parsers {
       val next = in.lookahead.token
       next == LBRACKET || next == LPAREN
 
-
     def followingIsSelfType() =
       val lookahead = in.LookaheadScanner()
       lookahead.nextToken()
@@ -917,10 +917,10 @@ object Parsers {
            }
       }
 
-    /** When encountering a `:`, is that in the first binding of a lambda?
-     *  @pre location of the enclosing expression is `InParens`, so there is am open `(`.
+    /** When encountering a `:`, is that in the binding of a lambda?
+     *  @pre location of the enclosing expression is `InParens`, so there is an open `(`.
      */
-    def followingisLambdaParams() =
+    def followingIsLambdaParams() =
       val lookahead = in.LookaheadScanner()
       lookahead.nextToken()
       while lookahead.token != RPAREN && lookahead.token != EOF do
@@ -932,6 +932,21 @@ object Parsers {
         lookahead.isArrow
       }
 
+    /** 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 `?=>`.
+     */
+    def followingIsLambdaAfterColon(): Boolean =
+      val lookahead = in.LookaheadScanner()
+      lookahead.nextToken()
+      if lookahead.isIdent || lookahead.token == USCORE then
+        lookahead.nextToken()
+        lookahead.isArrow
+      else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+        lookahead.skipParens()
+        lookahead.isArrow
+      else false
+
   /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
@@ -2229,7 +2244,17 @@ object Parsers {
           in.nextToken()
         else
           accept(ARROW)
-        Function(params, if (location == Location.InBlock) block() else expr())
+        val body =
+          if location == Location.InBlock then block()
+          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)
       }
 
     /** PostfixExpr   ::= InfixExpr [id [nl]]
@@ -2279,9 +2304,12 @@ object Parsers {
      *                 |  SimpleExpr `.` MatchClause
      *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
      *                 |  SimpleExpr1 ArgumentExprs
-     *                 |  SimpleExpr1 `:` IndentedExpr                       -- under language.experimental.fewerBraces
-     *                 |  SimpleExpr1 FunParams (‘=>’ | ‘?=>’) IndentedExpr  -- under language.experimental.fewerBraces
-     *  IndentedExpr  ::=  indent (CaseClauses | Block) outdent
+     *                 |  SimpleExpr1 `:` ColonArgument                   -- under language.experimental.fewerBraces
+     *  ColonArgument ::= indent (CaseClauses | Block) outdent
+     *                 |  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 ‘]’
      */
@@ -2337,65 +2365,38 @@ object Parsers {
       simpleExprRest(t, location, canApply)
     }
 
-    def simpleExprRest(t: Tree, location: Location, canApply: Boolean = true): Tree = {
+    def simpleExprRest(t: Tree, location: Location, canApply: Boolean = true): Tree =
       if (canApply) argumentStart()
-      in.token match {
+      in.token match
         case DOT =>
           in.nextToken()
           simpleExprRest(selectorOrMatch(t), location, canApply = true)
         case LBRACKET =>
           val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
           simpleExprRest(tapp, location, canApply = true)
-        case LPAREN if canApply =>
-          val app = atSpan(startOffset(t), in.offset) {
-            val argExprs @ (args, isUsing) = argumentExprs()
-            if !isUsing && in.isArrow && location != Location.InGuard && in.fewerBracesEnabled then
-              val params = convertToParams(Tuple(args))
-              if params.forall(_.name != nme.ERROR) then
-                applyToClosure(t, in.offset, params)
-              else
-                mkApply(t, argExprs)
-            else
-              mkApply(t, argExprs)
-          }
-          simpleExprRest(app, location, canApply = true)
-        case LBRACE | INDENT if canApply =>
+        case LPAREN | LBRACE | INDENT if canApply =>
           val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs()) }
           simpleExprRest(app, location, canApply = true)
         case USCORE =>
-          if in.lookahead.isArrow && location != Location.InGuard && in.fewerBracesEnabled then
-            val app = applyToClosure(t, in.offset, convertToParams(wildcardIdent()))
-            simpleExprRest(app, location, canApply = true)
-          else
-            atSpan(startOffset(t), in.skipToken()) { PostfixOp(t, Ident(nme.WILDCARD)) }
-        case IDENTIFIER
-        if !in.isOperator && in.lookahead.isArrow && location != Location.InGuard && in.fewerBracesEnabled =>
-          val app = applyToClosure(t, in.offset, convertToParams(termIdent()))
-          simpleExprRest(app, location, canApply = true)
+          atSpan(startOffset(t), in.skipToken()) { PostfixOp(t, Ident(nme.WILDCARD)) }
         case _ =>
-          t match
-            case id @ Ident(name)
-            if in.isColon() && location == Location.InParens && followingisLambdaParams() =>
-              if name.is(WildcardParamName) then
-                assert(name == placeholderParams.head.name)
-                placeholderParams = placeholderParams.tail
-              atSpan(startOffset(id)) {
-                makeParameter(name.asTermName, typedOpt(), Modifiers(), isBackquoted = isBackquoted(id))
-              }
-            case _ =>
-              t
-      }
-    }
-
-    def applyToClosure(t: Tree, start: Offset, params: List[ValDef]): Tree =
-      atSpan(startOffset(t), in.offset) {
-        val arg = atSpan(start, in.skipToken()) {
-          if in.token != INDENT then
-            syntaxErrorOrIncomplete(i"indented expression expected, ${in} found")
-          Function(params, blockExpr())
-        }
-        Apply(t, arg)
-      }
+          if in.isColon() && location == Location.InParens && followingIsLambdaParams() then
+            t match
+              case id @ Ident(name) =>
+                if name.is(WildcardParamName) then
+                  assert(name == placeholderParams.head.name)
+                  placeholderParams = placeholderParams.tail
+                atSpan(startOffset(id)) {
+                  makeParameter(name.asTermName, typedOpt(), Modifiers(), isBackquoted = isBackquoted(id))
+                }
+              case _ => t
+          else if in.fewerBracesEnabled && in.token == COLON && followingIsLambdaAfterColon() then
+            val app = atSpan(startOffset(t), in.skipToken()) {
+              Apply(t, expr(Location.InColonArg) :: Nil)
+            }
+            simpleExprRest(app, location, canApply = true)
+          else t
+    end simpleExprRest
 
     /** SimpleExpr    ::=  ‘new’ ConstrApp {`with` ConstrApp} [TemplateBody]
      *                  |  ‘new’ TemplateBody
@@ -2499,12 +2500,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

@@ -610,9 +610,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
@@ -653,7 +657,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`.
@@ -1643,25 +1649,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 = {
@@ -1673,6 +1683,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

@@ -254,13 +254,14 @@ SimpleExpr        ::=  SimpleRef
                     |  SimpleExpr ‘.’ MatchClause
                     |  SimpleExpr TypeArgs                                      TypeApply(expr, args)
                     |  SimpleExpr ArgumentExprs                                 Apply(expr, args)
-                    |  SimpleExpr ‘:’ IndentedExpr                              -- under language.experimental.fewerBraces
-                    |  SimpleExpr FunParams (‘=>’ | ‘?=>’) IndentedExpr         -- under language.experimental.fewerBraces
+                    |  SimpleExpr ‘:’ ColonArgument                             -- under language.experimental.fewerBraces
                     |  SimpleExpr ‘_’                                           PostfixOp(expr, _) (to be dropped)
-                    |  XmlExpr													                        -- to be dropped
-IndentedExpr      ::=  indent CaseClauses | Block outdent
-Quoted            ::=  ‘'’ ‘{’ Block ‘}’  
-                    |  ‘'’ ‘[’ Type ‘]’
+                    |  XmlExpr													-- to be dropped
+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

@@ -1,9 +1,14 @@
 import language.experimental.fewerBraces
 
-val x = List().map (x: => Int) => // error
+val x = List().map: (x: => Int) => // error
   ???
-val y = List() map x =>  // error
+val y = List() map: x =>  // error
   x + 1   // error
-val z = List() map + => // error
+val z = List().map: + => // ok
   ???
 
+val xs = List(1)
+val d = xs
+  .map: x => x.toString + xs.dropWhile:
+    y => y > 0  // error
+

tests/neg/i7751.scala

@@ -1,3 +1,3 @@
 import language.experimental.fewerBraces
-val a = Some(a=a,)=> // error // error // error
+val a = Some(a=a,)=> // error // error
 val a = Some(x=y,)=>

tests/pos/closure-args.scala

@@ -1,16 +1,38 @@
 import language.experimental.fewerBraces
 
-val xs = List(1, 2, 3)
-val ys = xs.map x =>
-  x + 1
-val x = ys.foldLeft(0) (x, y) =>
-  x + y
-val y = ys.foldLeft(0) (x: Int, y: Int) =>
-  val z = x + y
-  z * z
-val as: Int = xs
-  .map x =>
-    x * x
-  .filter y =>
-    y > 0
-  (0)
+object Test1:
+  val xs = List(1, 2, 3)
+  val ys = xs.map: x =>
+    x + 1
+  val x = ys.foldLeft(0): (x, y) =>
+    x + y
+  val y = ys.foldLeft(0): (x: Int, y: Int) =>
+    val z = x + y
+    z * z
+  val a: Int = xs
+    .map: x =>
+      x * x
+    .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
+  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 q = (x: String => String) => x