Better prediction of formal parameters of lambdas

Instead of parsing all formal parameters of a lambda as expressions
and converting to parameters at the end, we now scan ahead the first time
we see a `:` to determine whether the list is followed by `=>` or `?=>`.
If that's the case we parse this parameter and all following ones as
bindings instead of expressions.

Author: odersky

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

@@ -444,9 +444,12 @@ object Parsers {
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, mods: Modifiers, expected: String = "formal parameter"): ValDef = tree match {
+    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)
@@ -455,7 +458,6 @@ object Parsers {
       case _ =>
         syntaxError(s"not a legal $expected", tree.span)
         makeParameter(nme.ERROR, tree, mods)
-    }
 
     /** Convert (qual)ident to type identifier
      */
@@ -913,6 +915,21 @@ 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 `(`.
+     */
+    def followingisLambdaParams() =
+      val lookahead = in.LookaheadScanner()
+      lookahead.nextToken()
+      while lookahead.token != RPAREN && lookahead.token != EOF do
+        if lookahead.token == LPAREN then lookahead.skipParens()
+        else lookahead.nextToken()
+      lookahead.token == RPAREN
+      && {
+        lookahead.nextToken()
+        lookahead.isArrow
+      }
+
   /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
@@ -2292,7 +2309,7 @@ object Parsers {
           placeholderParams = param :: placeholderParams
           atSpan(start) { Ident(pname) }
         case LPAREN =>
-          atSpan(in.offset) { makeTupleOrParens(inParens(exprsInParensOpt())) }
+          atSpan(in.offset) { makeTupleOrParens(inParens(exprsInParensOrBindings())) }
         case LBRACE | INDENT =>
           canApply = false
           blockExpr()
@@ -2362,7 +2379,17 @@ object Parsers {
           val app = applyToClosure(t, in.offset, convertToParams(termIdent()))
           simpleExprRest(app, location, canApply = true)
         case _ =>
-          t
+          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
       }
     }
 
@@ -2396,9 +2423,20 @@ object Parsers {
       }
 
     /**   ExprsInParens     ::=  ExprInParens {`,' ExprInParens}
+     *    Bindings          ::=  Binding {`,' Binding}
      */
-    def exprsInParensOpt(): List[Tree] =
-      if (in.token == RPAREN) Nil else commaSeparated(exprInParens)
+    def exprsInParensOrBindings(): List[Tree] =
+      if in.token == RPAREN then Nil
+      else in.currentRegion.withCommasExpected {
+        var isFormalParams = false
+        def exprOrBinding() =
+          if isFormalParams then binding(Modifiers())
+          else
+            val t = exprInParens()
+            if t.isInstanceOf[ValDef] then isFormalParams = true
+            t
+        commaSeparatedRest(exprOrBinding(), exprOrBinding)
+      }
 
     /** ParArgumentExprs ::= `(' [‘using’] [ExprsInParens] `)'
      *                    |  `(' [ExprsInParens `,'] PostfixExpr `*' ')'

tests/neg/i13769.check

@@ -1,10 +1,6 @@
--- Error: tests/neg/i13769.scala:2:18 ----------------------------------------------------------------------------------
-2 |val te = tup.map((x: _ <: Int) => List(x)) // error // error
-  |                  ^^^^^^^^^^^
-  |                  not a legal formal parameter
--- [E006] Not Found Error: tests/neg/i13769.scala:2:39 -----------------------------------------------------------------
-2 |val te = tup.map((x: _ <: Int) => List(x)) // error // error
-  |                                       ^
-  |                                       Not found: x
+-- [E035] Syntax Error: tests/neg/i13769.scala:2:21 --------------------------------------------------------------------
+2 |val te = tup.map((x: _ <: Int) => List(x)) // error
+  |                     ^^^^^^^^
+  |                     Unbound wildcard type
   |
   | longer explanation available when compiling with `-explain`

tests/neg/i13769.scala

@@ -1,2 +1,2 @@
 val tup = (1, "s")
-val te = tup.map((x: _ <: Int) => List(x)) // error // error
+val te = tup.map((x: _ <: Int) => List(x)) // error

tests/neg/i1424.scala

@@ -1,3 +1,3 @@
 class Test {
-  (x: Int) => x // error: not a legal self type clause // error: not found x
+  (x: Int) => x // error: not a legal self type clause
 }

tests/neg/i7818.scala

@@ -1 +1 @@
-def foo = (x: @) => ()  // error // error
+def foo = (x: @) => ()  // error