Change fewerBraces to always require colon

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
@@ -431,7 +432,7 @@ object Parsers {
           convertToParam(t, mods) :: Nil
         case Tuple(ts) =>
           ts.map(convertToParam(_, mods))
-        case t: Typed =>
+        case t @ Typed(Ident(_), _) =>
           report.errorOrMigrationWarning(
             em"parentheses are required around the parameter of a lambda${rewriteNotice()}",
             in.sourcePos(), from = `3.0`)
@@ -444,22 +445,24 @@ object Parsers {
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, mods: Modifiers, expected: String = "formal parameter"): ValDef = tree match
-      case param: ValDef =>
-        param.withMods(param.mods | mods.flags)
-      case id @ Ident(name) =>
-        makeParameter(name.asTermName, TypeTree(), mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
-      // the following three cases are needed only for 2.x parameters without enclosing parentheses
-      case Typed(_, tpt: TypeBoundsTree) =>
-        syntaxError(s"not a legal $expected", tree.span)
-        makeParameter(nme.ERROR, tree, mods)
-      case Typed(id @ Ident(name), tpt) =>
-        makeParameter(name.asTermName, tpt, mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
-      case Typed(Splice(Ident(name)), tpt) =>
-        makeParameter(("$" + name).toTermName, tpt, mods).withSpan(tree.span)
-      case _ =>
-        syntaxError(s"not a legal $expected", tree.span)
+    def convertToParam(tree: Tree, mods: Modifiers): ValDef =
+      def fail() =
+        syntaxError(s"not a legal formal parameter for a function literal", tree.span)
         makeParameter(nme.ERROR, tree, mods)
+      tree match
+        case param: ValDef =>
+          param.withMods(param.mods | mods.flags)
+        case id @ Ident(name) =>
+          makeParameter(name.asTermName, TypeTree(), mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        // the following three cases are needed only for 2.x parameters without enclosing parentheses
+        case Typed(_, tpt: TypeBoundsTree) =>
+          fail()
+        case Typed(id @ Ident(name), tpt) =>
+          makeParameter(name.asTermName, tpt, mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        case Typed(Splice(Ident(name)), tpt) =>
+          makeParameter(("$" + name).toTermName, tpt, mods).withSpan(tree.span)
+        case _ =>
+          fail()
 
     /** Convert (qual)ident to type identifier
      */
@@ -893,9 +896,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 +919,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 +934,28 @@ 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 `?=>`
+     *  and an INDENT.
+     */
+    def followingIsLambdaAfterColon(): Boolean =
+      val lookahead = in.LookaheadScanner(allowIndent = true)
+      def isArrowIndent() =
+        lookahead.isArrow
+        && {
+          lookahead.nextToken()
+          lookahead.token == INDENT
+        }
+      lookahead.nextToken()
+      if lookahead.isIdent || lookahead.token == USCORE then
+        lookahead.nextToken()
+        isArrowIndent()
+      else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+        lookahead.skipParens()
+        isArrowIndent()
+      else false
+
   /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
@@ -2226,7 +2250,11 @@ 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 && in.token == INDENT then blockExpr()
+          else expr()
+        Function(params, body)
       }
 
     /** PostfixExpr   ::= InfixExpr [id [nl]]
@@ -2276,9 +2304,11 @@ 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
      *  Quoted        ::= ‘'’ ‘{’ Block ‘}’
      *                 |  ‘'’ ‘[’ Type ‘]’
      */
@@ -2334,65 +2364,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

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
 
@@ -1067,7 +1075,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
     }
 

docs/_docs/internals/syntax.md

@@ -254,13 +254,13 @@ 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
 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,25 @@
 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 b: Int = xs       // error
+  .map: x => x * x    // error
+  .filter: y => y > 0  // error
+  (0)
+val d = xs   // error
+  .map: x => x.toString + xs.dropWhile:
+    y => y > 0
+
+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/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,)=>