Change to (using x: T) => E for context functions

Change syntax of context functions to `(using x: T) => E`. The previous
syntax `(x: T) ?=> E` is still supported, but the docs have been changed
to `using`.

Author: odersky

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

@@ -1846,9 +1846,13 @@ object Parsers {
 
     def expr(location: Location.Value): Tree = {
       val start = in.offset
+      def isSpecialClosureStart =
+        val lookahead = in.LookaheadScanner()
+        lookahead.nextToken()
+        lookahead.isIdent(nme.using) || lookahead.token == ERASED
       if in.token == IMPLICIT then
         closure(start, location, modifiers(BitSet(IMPLICIT)))
-      else if in.token == LPAREN && in.lookaheadIn(funTypeArgMods) then
+      else if in.token == LPAREN && isSpecialClosureStart then
         closure(start, location, Modifiers())
       else {
         val saved = placeholderParams
@@ -2060,7 +2064,7 @@ object Parsers {
     /** FunParams         ::=  Bindings
      *                     |   id
      *                     |   `_'
-     *  Bindings          ::=  `(' [[‘given’] [‘erased’] Binding {`,' Binding}] `)'
+     *  Bindings          ::=  `(' [[using] [‘erased’] Binding {`,' Binding}] `)'
      */
     def funParams(mods: Modifiers, location: Location.Value): List[Tree] =
       if in.token == LPAREN then
@@ -2069,8 +2073,12 @@ object Parsers {
           Nil
         else
           openParens.change(LPAREN, 1)
-          val mods1 = if mods.flags.isEmpty then modifiers(funTypeArgMods) else mods
-          try commaSeparated(() => binding(mods1))
+          var mods1 = mods
+          if mods.flags.isEmpty then
+            if isIdent(nme.using) then mods1 = addMod(mods1, atSpan(in.skipToken()) { Mod.Given() })
+            if in.token == ERASED then mods1 = addModifier(mods1)
+          try
+            commaSeparated(() => binding(mods1))
           finally
             accept(RPAREN)
             openParens.change(LPAREN, -1)

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 `(x1: T1, ..., xn: Tn) ?=> e` map
+Context function literals `(using 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 `(x1: T1, ..., xn: Tn) ?=> e` are
+Context function literals `(using 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

@@ -24,7 +24,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 an context function literal by rewriting to
 ```scala
-  (x_1: T1, ..., x_n: Tn) ?=> E
+  (using 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`
@@ -36,11 +36,11 @@ For example, continuing with the previous definitions,
 ```scala
   def g(arg: Executable[Int]) = ...
 
-  g(22)      // is expanded to g((ev: ExecutionContext) ?=> 22)
+  g(22)      // is expanded to g((using ev: ExecutionContext) => 22)
 
-  g(f(2))    // is expanded to g((ev: ExecutionContext) ?=> f(2)(using ev))
+  g(f(2))    // is expanded to g((using ev: ExecutionContext) => f(2)(using ev))
 
-  g((ctx: ExecutionContext) ?=> f(22)(using ctx)) // is left as it is
+  g((using ctx: ExecutionContext) => f(22)(using ctx)) // is left as it is
 ```
 ### Example: Builder Pattern
 
@@ -97,14 +97,14 @@ that would otherwise be necessary.
 ```
 With that setup, the table construction code above compiles and expands to:
 ```scala
-  table { ($t: Table) ?=>
+  table { (using $t: Table) =>
 
-    row { ($r: Row) ?=>
+    row { (using $r: Row) =>
       cell("top left")(using $r)
       cell("top right")(using $r)
     }(using $t)
 
-    row { ($r: Row) ?=>
+    row { (using $r: Row) =>
       cell("bottom left")(using $r)
       cell("bottom right")(using $r)
     }(using $t)

docs/docs/release-notes/syntax-changes-0.22.md

@@ -39,17 +39,16 @@ Context bounds remain supported as a shorthand for one-parameter typeclass const
 def max[T: Ordering](x: T, y: T): T = ...
 given [T: Ordering] as Ordering[List[T]] { ... }
 ```
-
-## Context Functions
-
-Implicit function types `implicit A => B` have been replaced with context function types, which are written `A ?=> B`. The syntax `(given A) => B` that was used in earlier Dotty versions is no longer supported.
-
-The same change applies to context function values. It's now
+Parameters of context function values are also written with `using`. So it is
 ```scala
-(x: A) ?=> E
+(using x: A) => E
 ```
 instead of `(implicit x: A) => E` or `(given x: A) => E`.
 
+## Context Functions Types
+
+Implicit function types `implicit A => B` have been replaced with context function types, which are written `A ?=> B`. The syntax `(given A) => B` that was used in earlier Dotty versions is no longer supported.
+
 ## Given Imports
 
 The syntax of wildcard given import selectors is now `given _`. Examples

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

@@ -23,7 +23,7 @@ package object staging {
    *
    *  Usage:
    *  ```
-   *  val e: T = withQuoteContext { // (qctx: QuoteContext) ?=>
+   *  val e: T = withQuoteContext { // (using qctx: QuoteContext) =>
    *    thunk
    *  }
    *  ```

tests/neg/i2514a.scala

@@ -1,10 +1,11 @@
 object Foo {
   def foo(): Int = {
-    val f: Int ?=> Int = (x: Int) ?=> 2 * x
+    val f: Int ?=> Int = (using x: Int) => 2 * x
     f(using 2)
   }
 
   val f = implicit (x: Int) => x
 
-  ((x: Int) ?=> x): (Int ?=> Int) // error: no implicit argument found
+  ((using 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 = (x: Ctx) ?=> ()
+inline def foo(): Unit = (using 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 = x1 ?=> x1
+  val impfun: Int ?=> Int = (using x1) => x1
 
-  val impdepfun: (x1: Int) ?=> List[x1.type] = x1 ?=> List(x1)
+  val impdepfun: (x1: Int) ?=> List[x1.type] = (using x1) => List(x1)
 
-  val erasedimpfun: (erased Int) ?=> Int = (erased x1) ?=> 0
+  val erasedimpfun: (erased Int) ?=> Int = (using erased x1) => 0
 }
 
 object Test {