Switch to new syntax for implicit function types and closures

Author: odersky

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -8,7 +8,7 @@ import scala.reflect.ClassTag
 trait Liftable[T] {
 
   /** Lift a value into an expression containing the construction of that value */
-  def toExpr(x: T): delegate QuoteContext => Expr[T]
+  def toExpr(x: T): (given QuoteContext) => Expr[T]
 
 }
 
@@ -31,112 +31,112 @@ object Liftable {
 
   private class PrimitiveLiftable[T <: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Liftable[T] {
     /** Lift a primitive value `n` into `'{ n }` */
-    def toExpr(x: T) = delegate qctx => {
+    def toExpr(x: T) = (given qctx) => {
       import qctx.tasty._
       Literal(Constant(x)).seal.asInstanceOf[Expr[T]]
     }
   }
 
   given ClassIsLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
     /** Lift a `Class[T]` into `'{ classOf[T] }` */
-    def toExpr(x: Class[T]) = delegate qctx => {
+    def toExpr(x: Class[T]) = (given qctx) => {
       import qctx.tasty._
       Ref(defn.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
     }
   }
 
   given ClassTagIsLiftable[T: Type] as Liftable[ClassTag[T]] = new Liftable[ClassTag[T]] {
-    def toExpr(ct: ClassTag[T]): delegate QuoteContext => Expr[ClassTag[T]] =
+    def toExpr(ct: ClassTag[T]): (given QuoteContext) => Expr[ClassTag[T]] =
       '{ ClassTag[T](${ct.runtimeClass.toExpr}) }
   }
 
   given ArrayIsLiftable[T: Type: Liftable: ClassTag] as Liftable[Array[T]] = new Liftable[Array[T]] {
-    def toExpr(arr: Array[T]): delegate QuoteContext => Expr[Array[T]] =
+    def toExpr(arr: Array[T]): (given QuoteContext) => Expr[Array[T]] =
       '{ Array[T](${arr.toSeq.toExpr}: _*)(${summon[ClassTag[T]].toExpr}) }
   }
 
   given ArrayOfBooleanIsLiftable as Liftable[Array[Boolean]] = new Liftable[Array[Boolean]] {
-    def toExpr(array: Array[Boolean]): delegate QuoteContext => Expr[Array[Boolean]] =
+    def toExpr(array: Array[Boolean]): (given QuoteContext) => Expr[Array[Boolean]] =
       if (array.length == 0) '{ Array.emptyBooleanArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfByteIsLiftable as Liftable[Array[Byte]] = new Liftable[Array[Byte]] {
-    def toExpr(array: Array[Byte]): delegate QuoteContext => Expr[Array[Byte]] =
+    def toExpr(array: Array[Byte]): (given QuoteContext) => Expr[Array[Byte]] =
       if (array.length == 0) '{ Array.emptyByteArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfShortIsLiftable as Liftable[Array[Short]] = new Liftable[Array[Short]] {
-    def toExpr(array: Array[Short]): delegate QuoteContext => Expr[Array[Short]] =
+    def toExpr(array: Array[Short]): (given QuoteContext) => Expr[Array[Short]] =
       if (array.length == 0) '{ Array.emptyShortArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfCharIsLiftable as Liftable[Array[Char]] = new Liftable[Array[Char]] {
-    def toExpr(array: Array[Char]): delegate QuoteContext => Expr[Array[Char]] =
+    def toExpr(array: Array[Char]): (given QuoteContext) => Expr[Array[Char]] =
       if (array.length == 0) '{ Array.emptyCharArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfIntIsLiftable as Liftable[Array[Int]] = new Liftable[Array[Int]] {
-    def toExpr(array: Array[Int]): delegate QuoteContext => Expr[Array[Int]] =
+    def toExpr(array: Array[Int]): (given QuoteContext) => Expr[Array[Int]] =
       if (array.length == 0) '{ Array.emptyIntArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfLongIsLiftable as Liftable[Array[Long]] = new Liftable[Array[Long]] {
-    def toExpr(array: Array[Long]): delegate QuoteContext => Expr[Array[Long]] =
+    def toExpr(array: Array[Long]): (given QuoteContext) => Expr[Array[Long]] =
       if (array.length == 0) '{ Array.emptyLongArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfFloatIsLiftable as Liftable[Array[Float]] = new Liftable[Array[Float]] {
-    def toExpr(array: Array[Float]): delegate QuoteContext => Expr[Array[Float]] =
+    def toExpr(array: Array[Float]): (given QuoteContext) => Expr[Array[Float]] =
       if (array.length == 0) '{ Array.emptyFloatArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given ArrayOfDoubleIsLiftable as Liftable[Array[Double]] = new Liftable[Array[Double]] {
-    def toExpr(array: Array[Double]): delegate QuoteContext => Expr[Array[Double]] =
+    def toExpr(array: Array[Double]): (given QuoteContext) => Expr[Array[Double]] =
       if (array.length == 0) '{ Array.emptyDoubleArray }
       else '{ Array(${array(0).toExpr}, ${array.toSeq.tail.toExpr}: _*) }
   }
 
   given IArrayIsLiftable[T: Type] as Liftable[IArray[T]] given (ltArray: Liftable[Array[T]]) = new Liftable[IArray[T]] {
-    def toExpr(iarray: IArray[T]): delegate QuoteContext => Expr[IArray[T]] =
+    def toExpr(iarray: IArray[T]): (given QuoteContext) => Expr[IArray[T]] =
       '{ ${ltArray.toExpr(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] }
   }
 
   given [T: Type: Liftable] as Liftable[Seq[T]] = new Liftable[Seq[T]] {
-    def toExpr(xs: Seq[T]): delegate QuoteContext => Expr[Seq[T]] =
+    def toExpr(xs: Seq[T]): (given QuoteContext) => Expr[Seq[T]] =
       xs.map(summon[Liftable[T]].toExpr).toExprOfSeq
   }
 
   given [T: Type: Liftable] as Liftable[List[T]] = new Liftable[List[T]] {
-    def toExpr(xs: List[T]): delegate QuoteContext => Expr[List[T]] =
+    def toExpr(xs: List[T]): (given QuoteContext) => Expr[List[T]] =
       xs.map(summon[Liftable[T]].toExpr).toExprOfList
   }
 
   given [T: Type: Liftable] as Liftable[Set[T]] = new Liftable[Set[T]] {
-    def toExpr(set: Set[T]): delegate QuoteContext => Expr[Set[T]] =
+    def toExpr(set: Set[T]): (given QuoteContext) => Expr[Set[T]] =
       '{ Set(${set.toSeq.toExpr}: _*) }
   }
 
   given [T: Type: Liftable, U: Type: Liftable] as Liftable[Map[T, U]] = new Liftable[Map[T, U]] {
-    def toExpr(map: Map[T, U]): delegate QuoteContext => Expr[Map[T, U]] =
+    def toExpr(map: Map[T, U]): (given QuoteContext) => Expr[Map[T, U]] =
     '{ Map(${map.toSeq.toExpr}: _*) }
   }
 
   given [T: Type: Liftable] as Liftable[Option[T]] = new Liftable[Option[T]] {
-    def toExpr(x: Option[T]): delegate QuoteContext => Expr[Option[T]] = x match {
+    def toExpr(x: Option[T]): (given QuoteContext) => Expr[Option[T]] = x match {
       case Some(x) => '{ Some[T](${x.toExpr}) }
       case None => '{ None: Option[T] }
     }
   }
 
   given [L: Type: Liftable, R: Type: Liftable] as Liftable[Either[L, R]] = new Liftable[Either[L, R]] {
-    def toExpr(x: Either[L, R]): delegate QuoteContext => Expr[Either[L, R]] = x match {
+    def toExpr(x: Either[L, R]): (given QuoteContext) => Expr[Either[L, R]] = x match {
       case Left(x) => '{ Left[L, R](${x.toExpr}) }
       case Right(x) => '{ Right[L, R](${x.toExpr}) }
     }
@@ -289,19 +289,19 @@ object Liftable {
   }
 
   given [H: Type: Liftable, T <: Tuple: Type: Liftable] as Liftable[H *: T] = new {
-    def toExpr(tup: H *: T): delegate QuoteContext => Expr[H *: T] =
+    def toExpr(tup: H *: T): (given QuoteContext) => Expr[H *: T] =
       '{ ${summon[Liftable[H]].toExpr(tup.head)} *: ${summon[Liftable[T]].toExpr(tup.tail)} }
       // '{ ${tup.head.toExpr} *: ${tup.tail.toExpr} } // TODO figure out why this fails during CI documentation
   }
 
   given as Liftable[BigInt] = new Liftable[BigInt] {
-    def toExpr(x: BigInt): delegate QuoteContext => Expr[BigInt] =
+    def toExpr(x: BigInt): (given QuoteContext) => Expr[BigInt] =
       '{ BigInt(${x.toByteArray.toExpr}) }
   }
 
   /** Lift a BigDecimal using the default MathContext */
   given as Liftable[BigDecimal] = new Liftable[BigDecimal] {
-    def toExpr(x: BigDecimal): delegate QuoteContext => Expr[BigDecimal] =
+    def toExpr(x: BigDecimal): (given QuoteContext) => Expr[BigDecimal] =
       '{ BigDecimal(${x.toString.toExpr}) }
   }
 

tests/generic-java-signatures/i3653.scala

@@ -5,7 +5,7 @@ class Foo {
      c0: T, c1: T, c2: T, c3: T, c4: T, c5: T, c6: T, c7: T, c8: T, c9: T) => 0
 
   // #6946
-  def baz = (x: given String => Unit) => x given ""
+  def baz = (x: (given String) => Unit) => x given ""
 }
 
 object Test {

tests/neg/erased-4.scala

@@ -3,13 +3,13 @@ object Test {
   def main(args: Array[String]): Unit = {
     def foo  erased (i: Int) = 0
 
-    val f: erased Int => Int =
-      erased (x: Int) => {
+    val f: (erased Int) => Int =
+      (erased x: Int) => {
         x // error
       }
 
-    val f2: erased Int => Int =
-      erased (x: Int) => {
+    val f2: (erased Int) => Int =
+      (erased x: Int) => {
         foo(x)
       }
   }

tests/neg/erased-5.scala

@@ -1,14 +1,14 @@
 object Test {
 
-  type UU[T] = erased T => Int
+  type UU[T] = (erased T) => Int
 
   def main(args: Array[String]): Unit = {
-    fun { x => // error: `Int => Int` not compatible with `erased Int => Int`
+    fun { x => // error: `Int => Int` not compatible with `(erased Int) => Int`
       x
     }
 
     fun {
-      (x: Int) => x // error: `Int => Int` not compatible with `erased Int => Int`
+      (x: Int) => x // error: `Int => Int` not compatible with `(erased Int) => Int`
     }
   }
 

tests/neg/i2146.scala

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

tests/neg/i2514a.scala

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

tests/neg/i2642.scala

@@ -1,10 +1,10 @@
 object Foo {
-  type X = given () => Int // now ok, used to be: implicit function needs parameters
+  type X = (given) => Int // error: an identifier expected, but ')' found
   def ff: X = () // error: found: Unit, expected: Int
 
-  type Y = erased () => Int // error: empty function may not be erased
+  type Y = (erased) => Int // error: empty function may not be erased
   def gg: Y = () // error: found: Unit, expected: Y
 
-  type Z = erased given () => Int // error: empty function may not be erased
+  type Z = (erased given) => Int // error: empty function may not be erased
   def hh: Z = () // error: found: Unit, expected: Int
 }

tests/neg/i2960.scala

@@ -22,7 +22,7 @@ class Tag(val name: String,
         this
     }
 
-    def apply[U](f: given Tag => U)(implicit t: Tag = null): this.type = {
+    def apply[U](f: (given Tag) => U)(implicit t: Tag = null): this.type = {
         if(t != null) t.children += this
         f given this
         this

tests/neg/i4196.scala

@@ -1,6 +1,6 @@
 object Test {
   @annotation.tailrec
-  def foo(i: given Unit => Int): given Unit => Int =
+  def foo(i: (given Unit) => Int): (given Unit) => Int =
     if (i == 0)
       0
     else

tests/neg/i4611a.scala

@@ -1,6 +1,6 @@
 // Don't qualify as SAM type because result type is an implicit function type
 trait Foo {
-  def foo(x: Int): given Int => Int
+  def foo(x: Int): (given Int) => Int
 }
 
 trait Bar[T] {
@@ -12,10 +12,10 @@ class Test {
     def foo(x: Int) = 1
   }
 
-  val good2 = new Bar[given Int => Int] {
+  val good2 = new Bar[(given Int) => Int] {
     def bar(x: Int) = 1
   }
 
   val bad1: Foo = (x: Int) => 1 // error
-  val bad2: Bar[given Int => Int] = (x: Int) => 1 // error
+  val bad2: Bar[(given Int) => Int] = (x: Int) => 1 // error
 }