Implement new syntax for implicit closures

Author: odersky

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

@@ -1247,16 +1247,16 @@ object Parsers {
      *                |  HkTypeParamClause ‘=>>’ Type
      *                |  MatchType
      *                |  InfixType
-     *  FunType     ::=  { 'erased' | 'given' } (MonoFunType | PolyFunType)
+     *  FunType     ::=  (MonoFunType | PolyFunType)
      *  MonoFunType ::=  FunArgTypes ‘=>’ Type
      *  PolyFunType ::=  HKTypeParamClause '=>' Type
      *  FunArgTypes ::=  InfixType
-     *                |  `(' [ FunArgType {`,' FunArgType } ] `)'
-     *                |  '(' TypedFunParam {',' TypedFunParam } ')'
+     *                |  `(' [ [ ‘[given]’ ‘['erased']  FunArgType {`,' FunArgType } ] `)'
+     *                |  '(' [ ‘[given]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'
      */
     def typ(): Tree = {
       val start = in.offset
-      val imods = modifiers(funTypeMods)
+      var imods = Modifiers()
       def functionRest(params: List[Tree]): Tree =
         atSpan(start, accept(ARROW)) {
           val t = typ()
@@ -1282,6 +1282,7 @@ object Parsers {
           }
           else {
             openParens.change(LPAREN, 1)
+            imods = modifiers(funTypeArgMods)
             val paramStart = in.offset
             val ts = funArgType() match {
               case Ident(name) if name != tpnme.WILDCARD && in.token == COLON =>
@@ -1683,8 +1684,10 @@ object Parsers {
 
     def expr(location: Location.Value): Tree = {
       val start = in.offset
-      if (closureMods.contains(in.token))
+      if closureMods.contains(in.token) && allowOldGiven then
         implicitClosure(start, location, modifiers(closureMods))
+      else if in.token == LPAREN && in.lookaheadIn(funTypeArgMods) then
+        implicitClosure(start, location, modifiers())
       else {
         val saved = placeholderParams
         placeholderParams = Nil
@@ -1896,11 +1899,20 @@ object Parsers {
     /** FunParams         ::=  Bindings
      *                     |   id
      *                     |   `_'
-     *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
+     *  Bindings          ::=  `(' [[‘given’] [‘erased’] Binding {`,' Binding}] `)'
      */
     def funParams(mods: Modifiers, location: Location.Value): List[Tree] =
-      if (in.token == LPAREN)
-        inParens(if (in.token == RPAREN) Nil else commaSeparated(() => binding(mods)))
+      if in.token == LPAREN then
+        in.nextToken()
+        if in.token == RPAREN then
+          Nil
+        else
+          openParens.change(LPAREN, 1)
+          val mods1 = if mods.flags.isEmpty then modifiers(funTypeArgMods) else mods
+          try commaSeparated(() => binding(mods1))
+          finally
+            accept(RPAREN)
+            openParens.change(LPAREN, -1)
       else {
         val start = in.offset
         val name = bindingName()
@@ -2591,11 +2603,11 @@ object Parsers {
      */
     val closureMods: BitSet =
       if allowOldGiven then BitSet(GIVEN, IMPLIED, IMPLICIT, ERASED)
-      else BitSet(IMPLICIT)
+      else BitSet(IMPLICIT, ERASED)
+
+    val funTypeMods: BitSet = BitSet(IMPLIED, ERASED)
 
-    val funTypeMods: BitSet =
-      if allowOldGiven then BitSet(IMPLIED, ERASED)
-      else BitSet()
+    val funTypeArgMods: BitSet = BitSet(GIVEN, ERASED)
 
     /** Wrap annotation or constructor in New(...).<init> */
     def wrapNew(tpt: Tree): Select = Select(New(tpt), nme.CONSTRUCTOR)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -138,19 +138,27 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def toTextFunction(args: List[Type], isContextual: Boolean, isErased: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
-          if (args.length == 2 && !defn.isTupleType(args.head))
+          if args.length == 2
+             && !defn.isTupleType(args.head)
+             && !isContextual && !isErased
+          then
             atPrec(InfixPrec) { argText(args.head) }
           else
-            toTextTuple(args.init)
-        (keywordText("given ") provided isContextual) ~
-        (keywordText("erased ") provided isErased) ~
+            "("
+            ~ (keywordText("given ") provided isContextual)
+            ~ (keywordText("erased ") provided isErased)
+            ~ argsText(args.init)
+            ~ ")"
         argStr ~ " => " ~ argText(args.last)
       }
 
     def toTextDependentFunction(appType: MethodType): Text =
-      (keywordText("given ") provided appType.isImplicitMethod) ~
-      (keywordText("erased ") provided appType.isErasedMethod) ~
-      "(" ~ paramsText(appType) ~ ") => " ~ toText(appType.resultType)
+      "("
+      ~ (keywordText("given ") provided appType.isImplicitMethod)
+      ~ (keywordText("erased ") provided appType.isErasedMethod)
+      ~ paramsText(appType)
+      ~ ") => "
+      ~ toText(appType.resultType)
 
     def isInfixType(tp: Type): Boolean = tp match {
       case AppliedType(tycon, args) =>
@@ -238,7 +246,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case dummyTreeOfType(tp) :: Nil if !(tp isRef defn.NullClass) => "null: " ~ toText(tp)
           case _ => toTextGlobal(args, ", ")
         }
-        "[applied to " ~ (Str("given ") provided tp.isContextualMethod) ~ (Str("erased ") provided tp.isErasedMethod) ~ "(" ~ argsText ~ ") returning " ~ toText(resultType) ~ "]"
+        "[applied to ("
+        ~ (Str("given ") provided tp.isContextualMethod)
+        ~ (Str("erased ") provided tp.isErasedMethod)
+        ~ argsText
+        ~ ") returning "
+        ~ toText(resultType)
+        ~ "]"
       case IgnoredProto(ignored) =>
         "?" ~ (("(ignored: " ~ toText(ignored) ~ ")") provided printDebug)
       case tp @ PolyProto(targs, resType) =>

compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala

@@ -259,9 +259,9 @@ object PrepareInlineable {
         case Block(DefDef(nme.ANON_FUN, _, _, _, _) :: Nil, Closure(_, fn, _)) if fn.symbol.info.isImplicitMethod =>
           // TODO Support this pattern
           ctx.error(
-            """Macros using a return type of the form `foo(): given X => Y` are not yet supported.
+            """Macros using a return type of the form `foo(): (given X) => Y` are not yet supported.
               |
-              |Place the implicit as an argument (`foo() given X: Y`) to overcome this limitation.
+              |Place the implicit as an argument (`foo()(given X): Y`) to overcome this limitation.
               |""".stripMargin, tree.sourcePos)
         case _ =>
           ctx.error(

docs/docs/internals/syntax.md

@@ -144,12 +144,11 @@ Type              ::=  FunType
                     |  HkTypeParamClause ‘=>>’ Type                             TypeLambda(ps, t)
                     |  MatchType
                     |  InfixType
-FunType           ::=  ['given'] (MonoFunType | PolyFunType)
-MonoFunType       ::=  FunArgTypes ‘=>’ Type                                    Function(ts, t)
-PolyFunType       :: = HKTypeParamClause '=>' Type                              PolyFunction(ps, t)
+FunType           ::=  FunArgTypes ‘=>’ Type                                    Function(ts, t)
+                    |  HKTypeParamClause '=>' Type                              PolyFunction(ps, t)
 FunArgTypes       ::=  InfixType
-                    |  ‘(’ [ FunArgType {‘,’ FunArgType } ] ‘)’
-                    |  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
+                    |  ‘(’ [ ‘[given]’ FunArgType {‘,’ FunArgType } ] ‘)’
+                    |  ‘(’ ‘[given]’ TypedFunParam {‘,’ TypedFunParam } ‘)’
 TypedFunParam     ::=  id ‘:’ Type
 MatchType         ::=  InfixType `match` TypeCaseClauses
 InfixType         ::=  RefinedType {id [cnl] RefinedType}                       InfixOp(t1, op, t2)
@@ -318,7 +317,7 @@ ClosureMods       ::=  { ‘implicit’ | ‘given’}
 
 ### Bindings and Imports
 ```ebnf
-Bindings          ::=  ‘(’ Binding {‘,’ Binding} ‘)’
+Bindings          ::=  ‘(’ [[‘given’] Binding {‘,’ Binding}] ‘)’
 Binding           ::=  (id | ‘_’) [‘:’ Type]                                    ValDef(_, id, tpe, EmptyTree)
 
 Modifier          ::=  LocalModifier