Merge pull request #10487 from dotty-staging/change-ift-params

Fix #10484: Switch back to old context function closure syntax

Author: nicolasstucki

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

@@ -443,35 +443,35 @@ object Parsers {
 
     /** Convert tree to formal parameter list
     */
-    def convertToParams(tree: Tree): List[ValDef] = tree match {
+    def convertToParams(tree: Tree, mods: Modifiers): List[ValDef] = tree match {
       case Parens(t) =>
-        convertToParam(t) :: Nil
+        convertToParam(t, mods) :: Nil
       case Tuple(ts) =>
-        ts.map(convertToParam(_))
+        ts.map(convertToParam(_, mods))
       case t: Typed =>
         report.errorOrMigrationWarning(
           em"parentheses are required around the parameter of a lambda${rewriteNotice()}",
           in.sourcePos())
         if migrateTo3 then
           patch(source, t.span.startPos, "(")
           patch(source, t.span.endPos, ")")
-        convertToParam(t) :: Nil
+        convertToParam(t, mods) :: Nil
       case t =>
-        convertToParam(t) :: Nil
+        convertToParam(t, mods) :: Nil
     }
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, expected: String = "formal parameter"): ValDef = tree match {
+    def convertToParam(tree: Tree, mods: Modifiers, expected: String = "formal parameter"): ValDef = tree match {
       case id @ Ident(name) =>
-        makeParameter(name.asTermName, TypeTree(), EmptyModifiers, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        makeParameter(name.asTermName, TypeTree(), mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
       case Typed(id @ Ident(name), tpt) =>
-        makeParameter(name.asTermName, tpt, EmptyModifiers, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        makeParameter(name.asTermName, tpt, mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
       case Typed(Splice(Ident(name)), tpt) =>
-        makeParameter(("$" + name).toTermName, tpt, EmptyModifiers).withSpan(tree.span)
+        makeParameter(("$" + name).toTermName, tpt, mods).withSpan(tree.span)
       case _ =>
         syntaxError(s"not a legal $expected", tree.span)
-        makeParameter(nme.ERROR, tree, EmptyModifiers)
+        makeParameter(nme.ERROR, tree, mods)
     }
 
     /** Convert (qual)ident to type identifier
@@ -1864,14 +1864,14 @@ object Parsers {
       accept(altToken)
       t
 
-    /** Expr              ::=  [`implicit'] FunParams ‘=>’ Expr
+    /** Expr              ::=  [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
      *                      |  Expr1
      *  FunParams         ::=  Bindings
      *                      |  id
      *                      |  `_'
      *  ExprInParens      ::=  PostfixExpr `:' Type
      *                      |  Expr
-     *  BlockResult       ::=  [‘implicit’] FunParams ‘=>’ Block
+     *  BlockResult       ::=  [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block
      *                      |  Expr1
      *  Expr1             ::=  [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
      *                      |  [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
@@ -1920,9 +1920,10 @@ object Parsers {
         finally placeholderParams = saved
 
         val t = expr1(location)
-        if (in.token == ARROW) {
+        if (in.token == ARROW || in.token == CTXARROW) {
           placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
-          wrapPlaceholders(closureRest(start, location, convertToParams(t)))
+          val paramMods = if in.token == CTXARROW then Modifiers(Given) else EmptyModifiers
+          wrapPlaceholders(closureRest(start, location, convertToParams(t, paramMods)))
         }
         else if (isWildcard(t)) {
           placeholderParams = placeholderParams ::: saved
@@ -2124,7 +2125,7 @@ object Parsers {
     /** FunParams         ::=  Bindings
      *                     |   id
      *                     |   `_'
-     *  Bindings          ::=  `(' [[‘using’] [‘erased’] Binding {`,' Binding}] `)'
+     *  Bindings          ::=  `(' [[‘erased’] Binding {`,' Binding}] `)'
      */
     def funParams(mods: Modifiers, location: Location): List[Tree] =
       if in.token == LPAREN then
@@ -2185,7 +2186,7 @@ object Parsers {
 
     def closureRest(start: Int, location: Location, params: List[Tree]): Tree =
       atSpan(start, in.offset) {
-        accept(ARROW)
+        if in.token == CTXARROW then in.nextToken() else accept(ARROW)
         Function(params, if (location == Location.InBlock) block() else expr())
       }
 
@@ -2309,7 +2310,7 @@ object Parsers {
       possibleTemplateStart()
       val parents =
         if in.isNestedStart then Nil
-        else constrApps(commaOK = false, templateCanFollow = true)
+        else constrApps(commaOK = false)
       colonAtEOLOpt()
       possibleTemplateStart(isNew = true)
       parents match {
@@ -3492,7 +3493,7 @@ object Parsers {
       val parents =
         if (in.token == EXTENDS) {
           in.nextToken()
-          constrApps(commaOK = true, templateCanFollow = false)
+          constrApps(commaOK = true)
         }
         else Nil
       Template(constr, parents, Nil, EmptyValDef, Nil)
@@ -3536,7 +3537,7 @@ object Parsers {
         val noParams = tparams.isEmpty && vparamss.isEmpty
         if !(name.isEmpty && noParams) then
           accept(nme.as)
-        val parents = constrApps(commaOK = true, templateCanFollow = true)
+        val parents = constrApps(commaOK = true)
         if in.token == EQUALS && parents.length == 1 && parents.head.isType then
           accept(EQUALS)
           mods1 |= Final
@@ -3616,19 +3617,12 @@ object Parsers {
 
     /** ConstrApps  ::=  ConstrApp {(‘,’ | ‘with’) ConstrApp}
      */
-    def constrApps(commaOK: Boolean, templateCanFollow: Boolean): List[Tree] =
+    def constrApps(commaOK: Boolean): List[Tree] =
       val t = constrApp()
       val ts =
-        if in.token == WITH then
-          in.nextToken()
-          newLineOptWhenFollowedBy(LBRACE)
-          if templateCanFollow && (in.token == LBRACE || in.token == INDENT) then
-            Nil
-          else
-            constrApps(commaOK, templateCanFollow)
-        else if commaOK && in.token == COMMA then
+        if in.token == WITH || commaOK && in.token == COMMA then
           in.nextToken()
-          constrApps(commaOK, templateCanFollow)
+          constrApps(commaOK)
         else Nil
       t :: ts
 
@@ -3645,7 +3639,7 @@ object Parsers {
               in.sourcePos())
             Nil
           }
-          else constrApps(commaOK = true, templateCanFollow = true)
+          else constrApps(commaOK = true)
         }
         else Nil
       newLinesOptWhenFollowedBy(nme.derives)
@@ -3772,7 +3766,7 @@ object Parsers {
             case Typed(tree @ This(EmptyTypeIdent), tpt) =>
               self = makeSelfDef(nme.WILDCARD, tpt).withSpan(first.span)
             case _ =>
-              val ValDef(name, tpt, _) = convertToParam(first, "self type clause")
+              val ValDef(name, tpt, _) = convertToParam(first, EmptyModifiers, "self type clause")
               if (name != nme.ERROR)
                 self = makeSelfDef(name, tpt).withSpan(first.span)
           }

docs/docs/internals/syntax.md

@@ -185,9 +185,9 @@ Types             ::=  Type {‘,’ Type}
 
 ### Expressions
 ```ebnf
-Expr              ::=  FunParams ‘=>’ Expr                                      Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
+Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr                            Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
                     |  Expr1
-BlockResult       ::=  FunParams ‘=>’ Block
+BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
                     |  Expr1
 FunParams         ::=  Bindings
                     |  id
@@ -322,7 +322,7 @@ ClosureMods       ::=  { ‘implicit’ | ‘given’}
 
 ### Bindings and Imports
 ```ebnf
-Bindings          ::=  ‘(’ [[‘using’] Binding {‘,’ Binding}] ‘)’
+Bindings          ::=  ‘(’ [Binding {‘,’ Binding}] ‘)’
 Binding           ::=  (id | ‘_’) [‘:’ Type]                                    ValDef(_, id, tpe, EmptyTree)
 
 Modifier          ::=  LocalModifier

docs/docs/reference/contextual/context-functions-spec.md

@@ -28,7 +28,7 @@ trait ContextFunctionN[-T1 , ... , -TN, +R] {
 Context function types erase to normal function types, so these classes are
 generated on the fly for typechecking, but not realized in actual code.
 
-Context function literals `(using x1: T1, ..., xn: Tn) => e` map
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` map
 context parameters `xi` of types `Ti` to the result of evaluating the expression `e`.
 The scope of each context parameter `xi` is `e`. The parameters must have pairwise distinct names.
 
@@ -54,7 +54,7 @@ Note: The closing paragraph of the
 [Anonymous Functions section](https://www.scala-lang.org/files/archive/spec/2.12/06-expressions.html#anonymous-functions)
 of Scala 2.12 is subsumed by context function types and should be removed.
 
-Context function literals `(using x1: T1, ..., xn: Tn) => e` are
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` are
 automatically created for any expression `e` whose expected type is
 `scala.ContextFunctionN[T1, ..., Tn, R]`, unless `e` is
 itself a context function literal. This is analogous to the automatic

docs/docs/reference/contextual/context-functions.md

@@ -27,7 +27,7 @@ Conversely, if the expected type of an expression `E` is a context function type
 `(T_1, ..., T_n) ?=> U` and `E` is not already an
 context function literal, `E` is converted to a context function literal by rewriting it to
 ```scala
-  (using x_1: T1, ..., x_n: Tn) => E
+  (x_1: T1, ..., x_n: Tn) ?=> E
 ```
 where the names `x_1`, ..., `x_n` are arbitrary. This expansion is performed
 before the expression `E` is typechecked, which means that `x_1`, ..., `x_n`
@@ -39,12 +39,12 @@ For example, continuing with the previous definitions,
 ```scala
   def g(arg: Executable[Int]) = ...
 
-  g(22)      // is expanded to g((using ev: ExecutionContext) => 22)
+  g(22)      // is expanded to g((ev: ExecutionContext) ?=> 22)
 
-  g(f(2))    // is expanded to g((using ev: ExecutionContext) => f(2)(using ev))
+  g(f(2))    // is expanded to g((ev: ExecutionContext) ?=> f(2)(using ev))
 
-  g(ExecutionContext ?=> f(3))  // is expanded to g((using ev: ExecutionContext) => f(3)(using ev))
-  g((using ctx: ExecutionContext) => f(22)(using ctx)) // is left as it is
+  g((ctx: ExecutionContext) ?=> f(3))  // is expanded to g((ctx: ExecutionContext) ?=> f(3)(using ctx))
+  g((ctx: ExecutionContext) ?=> f(3)(using ctx)) // is left as it is
 ```
 
 ### Example: Builder Pattern
@@ -102,14 +102,14 @@ that would otherwise be necessary.
 ```
 With that setup, the table construction code above compiles and expands to:
 ```scala
-  table { (using $t: Table) =>
+  table { ($t: Table) ?=>
 
-    row { (using $r: Row) =>
+    row { ($r: Row) ?=>
       cell("top left")(using $r)
       cell("top right")(using $r)
     }(using $t)
 
-    row { (using $r: Row) =>
+    row { ($r: Row) ?=>
       cell("bottom left")(using $r)
       cell("bottom right")(using $r)
     }(using $t)

staging/src/scala/quoted/staging/staging.scala

@@ -7,7 +7,7 @@ package object staging:
    *
    *  Usage:
    *  ```
-   *  val e: T = run { // (using Quotes) =>
+   *  val e: T = run { // (quotes: Quotes) ?=>
    *    expr
    *  }
    *  ```
@@ -23,7 +23,7 @@ package object staging:
    *
    *  Usage:
    *  ```
-   *  val e: T = withQuotes { // (using Quotes) =>
+   *  val e: T = withQuotes { // (quotes: Quotes) ?=>
    *    thunk
    *  }
    *  ```

tests/disabled/run/tupled-function-extension-method.scala

@@ -17,11 +17,11 @@ object Test {
     println(f3(1, 2, 3))
     println(f25(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25))
 
-    val if1 = new Expr((using i: Int) => Tuple1(i))
-    val if2 = new Expr((using i: Int, j: Int) => (i, i + j))
-    val if3 = new Expr((using i: Int, j: Int, k: Int) => (i, i + j, i + j + k))
+    val if1 = new Expr((i: Int) ?=> Tuple1(i))
+    val if2 = new Expr((i: Int, j: Int) ?=> (i, i + j))
+    val if3 = new Expr((i: Int, j: Int, k: Int) ?=> (i, i + j, i + j + k))
     val if25 = new Expr(
-     (using x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int, x23: Int, x24: Int, x25: Int) =>
+     (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int, x23: Int, x24: Int, x25: Int) ?=>
         (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)
     )
 

tests/neg/i2006.scala

@@ -4,7 +4,7 @@ object Test {
   inline def bar(f: Int ?=> Int) = f // error
 
   def main(args: Array[String]) = {
-    foo((using thisTransaction) => 43)
-    bar((using thisTransaction) => 44)
+    foo(thisTransaction ?=> 43)
+    bar(thisTransaction ?=> 44)
   }
 }

tests/neg/i2146.scala

@@ -1,5 +1,5 @@
 class Test {
-  def foo[A, B]: A ?=> B ?=> Int = { (using b: B) =>  // error: found Int, required: A ?=> B ?=> Int
+  def foo[A, B]: A ?=> B ?=> Int = { (b: B) ?=>  // error: found Int, required: A ?=> B ?=> Int
     42
   }
 }

tests/neg/i2514a.scala

@@ -1,11 +1,10 @@
 object Foo {
   def foo(): Int = {
-    val f: Int ?=> Int = (using x: Int) => 2 * x
+    val f: Int ?=> Int = (x: Int) ?=> 2 * x
     f(using 2)
   }
 
   val f = implicit (x: Int) => x
 
-  ((using x: Int) => x): (Int ?=> Int) // error: no implicit argument found
+  ((x: Int) ?=> x): (Int ?=> Int) // error: no implicit argument found
 }
-

tests/neg/i4668.scala

@@ -8,4 +8,4 @@ trait Functor[F[_]] { def map[A,B](x: F[A])(f: A => B): F[B] }
 object Functor { implicit object listFun extends Functor[List] { def map[A,B](ls: List[A])(f: A => B) = ls.map(f) } }
 
 val map: (A:Type,B:Type,F:Type1) ?=>  (Functor[F.T]) ?=> (F.T[A.T]) => (A.T => B.T) => F.T[B.T] =
-  (using fun) => (using x) => f => fun.map(x)(f) // error
+  fun ?=> x => f => fun.map(x)(f) // error