Allow braces just on the outside of polymorphic lambdas

Also refactor grammar so that polymorphic lambdas and regular lambdas have the same
level of precedence.

Fixes #12277

Author: odersky

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

@@ -1838,13 +1838,15 @@ object Parsers {
       t
 
     /** Expr              ::=  [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
+     *                      |  HkTypeParamClause ‘=>’ Expr
      *                      |  Expr1
      *  FunParams         ::=  Bindings
      *                      |  id
      *                      |  `_'
      *  ExprInParens      ::=  PostfixExpr `:' Type
      *                      |  Expr
      *  BlockResult       ::=  [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block
+     *                      |  HkTypeParamClause ‘=>’ Block
      *                      |  Expr1
      *  Expr1             ::=  [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
      *                      |  [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
@@ -1855,7 +1857,6 @@ object Parsers {
      *                      |  `throw' Expr
      *                      |  `return' [Expr]
      *                      |  ForExpr
-     *                      |  HkTypeParamClause ‘=>’ Expr
      *                      |  [SimpleExpr `.'] id `=' Expr
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  PostfixExpr [Ascription]
@@ -1876,28 +1877,41 @@ object Parsers {
     def expr(location: Location): Tree = {
       val start = in.offset
       def isSpecialClosureStart = in.lookahead.isIdent(nme.erased) && in.erasedEnabled
-      if in.token == IMPLICIT then
-        closure(start, location, modifiers(BitSet(IMPLICIT)))
-      else if in.token == LPAREN && isSpecialClosureStart then
-        closure(start, location, Modifiers())
-      else {
-        val saved = placeholderParams
-        placeholderParams = Nil
-
-        def wrapPlaceholders(t: Tree) = try
-          if (placeholderParams.isEmpty) t
-          else new WildcardFunction(placeholderParams.reverse, t)
-        finally placeholderParams = saved
-
-        val t = expr1(location)
-        if in.isArrow then
-          placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
-          wrapPlaceholders(closureRest(start, location, convertToParams(t)))
-        else if isWildcard(t) then
-          placeholderParams = placeholderParams ::: saved
-          t
-        else wrapPlaceholders(t)
-      }
+      in.token match
+        case IMPLICIT =>
+          closure(start, location, modifiers(BitSet(IMPLICIT)))
+        case LPAREN if isSpecialClosureStart =>
+          closure(start, location, Modifiers())
+        case LBRACKET =>
+          val start = in.offset
+          val tparams = typeParamClause(ParamOwner.TypeParam)
+          val arrowOffset = accept(ARROW)
+          val body = expr(location)
+          atSpan(start, arrowOffset) {
+            if (isFunction(body))
+              PolyFunction(tparams, body)
+            else {
+              syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+              errorTermTree
+            }
+          }
+        case _ =>
+          val saved = placeholderParams
+          placeholderParams = Nil
+
+          def wrapPlaceholders(t: Tree) = try
+            if (placeholderParams.isEmpty) t
+            else new WildcardFunction(placeholderParams.reverse, t)
+          finally placeholderParams = saved
+
+          val t = expr1(location)
+          if in.isArrow then
+            placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
+            wrapPlaceholders(closureRest(start, location, convertToParams(t)))
+          else if isWildcard(t) then
+            placeholderParams = placeholderParams ::: saved
+            t
+          else wrapPlaceholders(t)
     }
 
     def expr1(location: Location = Location.ElseWhere): Tree = in.token match
@@ -1981,19 +1995,6 @@ object Parsers {
         }
       case FOR =>
         forExpr()
-      case LBRACKET =>
-        val start = in.offset
-        val tparams = typeParamClause(ParamOwner.TypeParam)
-        val arrowOffset = accept(ARROW)
-        val body = expr()
-        atSpan(start, arrowOffset) {
-          if (isFunction(body))
-            PolyFunction(tparams, body)
-          else {
-            syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
-            errorTermTree
-          }
-        }
       case _ =>
         if isIdent(nme.inline)
            && !in.inModifierPosition()

docs/docs/internals/syntax.md

@@ -205,8 +205,10 @@ Types             ::=  Type {‘,’ Type}
 ### Expressions
 ```ebnf
 Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr                            Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
+                    |  HkTypeParamClause ‘=>’ Expr                              PolyFunction(ts, expr)
                     |  Expr1
 BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
+                    |  HkTypeParamClause ‘=>’ Block
                     |  Expr1
 FunParams         ::=  Bindings
                     |  id
@@ -220,7 +222,6 @@ Expr1             ::=  [‘inline’] ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[
                     |  ‘throw’ Expr                                             Throw(expr)
                     |  ‘return’ [Expr]                                          Return(expr?)
                     |  ForExpr
-                    |  HkTypeParamClause ‘=>’ Expr                              PolyFunction(ts, expr)
                     |  [SimpleExpr ‘.’] id ‘=’ Expr                             Assign(expr, expr)
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr                       Assign(expr, expr)
                     |  PostfixExpr [Ascription]

docs/docs/reference/syntax.md

@@ -202,8 +202,10 @@ Types             ::=  Type {‘,’ Type}
 ### Expressions
 ```ebnf
 Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr
+                    |  HkTypeParamClause ‘=>’ Expr
                     |  Expr1
 BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
+                    |  HkTypeParamClause ‘=>’ Block
                     |  Expr1
 FunParams         ::=  Bindings
                     |  id
@@ -217,7 +219,6 @@ Expr1             ::=  [‘inline’] ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[
                     |  ‘throw’ Expr
                     |  ‘return’ [Expr]
                     |  ForExpr
-                    |  HkTypeParamClause ‘=>’ Expr
                     |  [SimpleExpr ‘.’] id ‘=’ Expr
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr
                     |  PostfixExpr [Ascription]

tests/neg/tuple-ops.scala

@@ -12,13 +12,13 @@ val r3: ((2, 1), (8, 2)) = c.zip(a)  // error
 // Map
 case class Foo[X](x: X)
 
-val r6: (Int, Int, String) = a.map[[t] =>> Int]([t] => x: t => x match {  // error
+val r6: (Int, Int, String) = a.map[[t] =>> Int]([t] => (x: t) => x match {  // error
   case x: Int => x * x
   case _ => ???
 })
 
 val r7: ((1, Foo[1]), (2), (3, Foo[3])) =
-  a.map[[t] =>> (t, Foo[t])]( [t] => x: t => (x, Foo(x)) )  // error
+  a.map[[t] =>> (t, Foo[t])]( [t] => (x: t) => (x, Foo(x)) )  // error
 
 // More Zip
 val t1: Int *: Long *: Tuple = (1, 2l, 100, 200)

tests/pos/i12277.scala

@@ -0,0 +1,18 @@
+def foo(f: => () => Unit): Unit = ???
+def boo(f: [A] => () => Unit): Unit = ???
+
+object test:
+  foo { () =>  // okay
+    println(1)
+    println(2)
+  }
+
+  boo { [A] => () => // error
+    println(1)
+    println(2)
+  }
+
+  boo { [A] => () => { // okay
+    println(1)
+    println(2)
+  }}