Merge pull request #6726 from dotty-staging/fix-poly-parser

Fix #6725: Parsing of poly function with parenthesized body

Author: milessabin

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1410,7 +1410,9 @@ object desugar {
     }
 
     def makePolyFunction(targs: List[Tree], body: Tree): Tree = body match {
-      case  Function(vargs, res) =>
+      case Parens(body1) =>
+        makePolyFunction(targs, body1)
+      case Function(vargs, res) =>
         // TODO: Figure out if we need a `PolyFunctionWithMods` instead.
         val mods = body match {
           case body: FunctionWithMods => body.mods

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

@@ -864,6 +864,12 @@ object Parsers {
      */
     def toplevelTyp(): Tree = rejectWildcardType(typ())
 
+    private def isFunction(tree: Tree): Boolean = tree match {
+      case Parens(tree1) => isFunction(tree1)
+      case _: Function => true
+      case _ => false
+    }
+
     /** Type        ::=  FunType
      *                |  HkTypeParamClause ‘=>>’ Type
      *                |  MatchType
@@ -946,11 +952,11 @@ object Parsers {
             val arrowOffset = in.skipToken()
             val body = toplevelTyp()
             atSpan(start, arrowOffset) {
-              body match {
-                case _: Function => PolyFunction(tparams, body)
-                case _ =>
-                  syntaxError("Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
-                  Ident(nme.ERROR.toTypeName)
+              if (isFunction(body))
+                PolyFunction(tparams, body)
+              else {
+                syntaxError("Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
+                Ident(nme.ERROR.toTypeName)
               }
             }
           } else { accept(TLARROW); typ() }
@@ -1381,11 +1387,11 @@ object Parsers {
         val arrowOffset = accept(ARROW)
         val body = expr()
         atSpan(start, arrowOffset) {
-          body match {
-            case _: Function => PolyFunction(tparams, body)
-            case _ =>
-              syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
-              errorTermTree
+          if (isFunction(body))
+            PolyFunction(tparams, body)
+          else {
+            syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+            errorTermTree
           }
         }
       case _ =>

tests/run/polymorphic-functions.scala

@@ -90,4 +90,8 @@ object Test extends App {
     }
   val s = [T] => (t: T) => given (st: Show[T]) => st.show(t)
   assert(s(23) == "23")
+
+  // Parens handling
+  val tt1: [T] => (T => T) = [T] =>  (x: T) => x
+  val tt2: [T] =>  T => T =  [T] => ((x: T) => x)
 }