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,9 +894,8 @@ object Parsers {
       val next = in.lookahead.token
       next == LBRACKET || next == LPAREN
 
-
     def followingIsSelfType() =
-      val lookahead = in.LookaheadScanner()
+      val lookahead = in.LookaheadScanner(allowIndent = true)
       lookahead.nextToken()
       lookahead.token == COLON
       && {
@@ -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

@@ -189,7 +189,10 @@ object Scanners {
     val indentSyntax =
       ((if (Config.defaultIndent) !noindentSyntax else ctx.settings.indent.value)
        || rewriteNoIndent)
-      && !isInstanceOf[LookaheadScanner]
+      && { this match
+        case self: LookaheadScanner => self.allowIndent
+        case _ => true
+      }
 
     if (rewrite) {
       val s = ctx.settings
@@ -206,12 +209,17 @@ object Scanners {
     def featureEnabled(name: TermName) = Feature.enabled(name)(using languageImportContext)
     def erasedEnabled = featureEnabled(Feature.erasedDefinitions)
 
+    private inline val fewerBracesByDefault = false
+      // turn on to study impact on codebase if `fewerBraces` was the default
+
     private var fewerBracesEnabledCache = false
     private var fewerBracesEnabledCtx: Context = NoContext
 
     def fewerBracesEnabled =
       if fewerBracesEnabledCtx ne myLanguageImportContext then
-        fewerBracesEnabledCache = featureEnabled(Feature.fewerBraces)
+        fewerBracesEnabledCache =
+          featureEnabled(Feature.fewerBraces)
+          || fewerBracesByDefault && indentSyntax
         fewerBracesEnabledCtx = myLanguageImportContext
       fewerBracesEnabledCache
 
@@ -610,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
@@ -653,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`.
@@ -1067,7 +1081,7 @@ object Scanners {
         reset()
       next
 
-    class LookaheadScanner() extends Scanner(source, offset) {
+    class LookaheadScanner(val allowIndent: Boolean = false) extends Scanner(source, offset) {
       override def languageImportContext = Scanner.this.languageImportContext
     }
 
@@ -1643,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 = {
@@ -1673,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

@@ -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-custom-args/nowarn/nowarn.check

@@ -63,7 +63,7 @@ Matching filters for @nowarn or -Wconf:
    |                              ^
    |                              method f is deprecated
 -- Deprecation Warning: tests/neg-custom-args/nowarn/nowarn.scala:47:10 ------------------------------------------------
-47 |def t7c = f:          // warning (deprecation)
+47 |def t7c = f             // warning (deprecation)
    |          ^
    |          method f is deprecated
 -- Unchecked Warning: tests/neg-custom-args/nowarn/nowarn.scala:53:7 ---------------------------------------------------
@@ -78,10 +78,10 @@ Matching filters for @nowarn or -Wconf:
 40 |@nowarn("msg=fish") def t6d = f // error (unused nowarn), warning (deprecation)
    |^^^^^^^^^^^^^^^^^^^
    |@nowarn annotation does not suppress any warnings
--- Error: tests/neg-custom-args/nowarn/nowarn.scala:48:3 ---------------------------------------------------------------
-48 |  @nowarn("msg=fish") // error (unused nowarn)
-   |  ^^^^^^^^^^^^^^^^^^^
-   |  @nowarn annotation does not suppress any warnings
+-- Error: tests/neg-custom-args/nowarn/nowarn.scala:48:5 ---------------------------------------------------------------
+48 |  : @nowarn("msg=fish") // error (unused nowarn)
+   |    ^^^^^^^^^^^^^^^^^^^
+   |    @nowarn annotation does not suppress any warnings
 -- Error: tests/neg-custom-args/nowarn/nowarn.scala:60:0 ---------------------------------------------------------------
 60 |@nowarn def t9a = { 1: @nowarn; 2 } // error (outer @nowarn is unused)
    |^^^^^^^

tests/neg-custom-args/nowarn/nowarn.scala

@@ -42,10 +42,10 @@ def t6a = f // warning (refchecks, deprecation)
 @nowarn def t6f = f
 
 def t7a = f: @nowarn("cat=deprecation")
-def t7b = f:
-  @nowarn("msg=deprecated")
-def t7c = f:          // warning (deprecation)
-  @nowarn("msg=fish") // error (unused nowarn)
+def t7b = f
+  : @nowarn("msg=deprecated")
+def t7c = f             // warning (deprecation)
+  : @nowarn("msg=fish") // error (unused nowarn)
 def t7d = f: @nowarn("")
 def t7e = f: @nowarn
 

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,)=>