Switch back to ?=> for context function closures

The old syntax was awkward since everywhere else after a `using` it's the
_name of the paramater_ that's optional, not the type.

Author: odersky

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
@@ -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

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/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/pos/i6862/lib_1.scala

@@ -1,3 +1,3 @@
 trait Ctx
-inline def foo(): Unit = (using x: Ctx) => ()
+inline def foo(): Unit = (x: Ctx) ?=> ()
 def bar[T](b: Ctx ?=> Unit): Unit = ???

tests/run-custom-args/lambda-serialization-others.scala

@@ -36,11 +36,11 @@ class C1 {
 
 class C2
     extends Serializable /* Needed because of #5866 */ {
-  val impfun: Int ?=> Int = (using x1) => x1
+  val impfun: Int ?=> Int = x1 ?=> x1
 
-  val impdepfun: (x1: Int) ?=> List[x1.type] = (using x1) => List(x1)
+  val impdepfun: (x1: Int) ?=> List[x1.type] = x1 ?=> List(x1)
 
-  val erasedimpfun: (erased Int) ?=> Int = (using erased x1) => 0
+  val erasedimpfun: (erased Int) ?=> Int = (erased x1) ?=> 0
 }
 
 object Test {