Drop given A => B syntax

odersky · odersky · commit 23ca102eed89 · 2019-09-16T18:24:01.000+02:00
Replace with `delegate A =&gt; B` in tests and with `ImplicitFunctionType[A, B]` in bootstrap code.
Also replace `given x: T =&gt; e` with `delegate x: T =&gt; e`, except in bootstrap code, where the
latter is not legal.

These measures are necessary for migration to new given scheme.
diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala
@@ -118,14 +118,14 @@ object Annotations {
       apply(New(atp, args))
 
     /** Create an annotation where the tree is computed lazily. */
-    def deferred(sym: Symbol)(treeFn: given Context => Tree)(implicit ctx: Context): Annotation =
+    def deferred(sym: Symbol)(treeFn: ImplicitFunction1[Context, Tree])(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         override def symbol(implicit ctx: Context): Symbol = sym
         def complete(implicit ctx: Context) = treeFn given ctx
       }
 
     /** Create an annotation where the symbol and the tree are computed lazily. */
-    def deferredSymAndTree(symf: given Context => Symbol)(treeFn: given Context => Tree)(implicit ctx: Context): Annotation =
+    def deferredSymAndTree(symf: ImplicitFunction1[Context, Symbol])(treeFn: ImplicitFunction1[Context, Tree])(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         private[this] var mySym: Symbol = _
 
@@ -153,7 +153,7 @@ object Annotations {
     object Child {
 
       /** A deferred annotation to the result of a given child computation */
-      def later(delayedSym: given Context => Symbol, span: Span)(implicit ctx: Context): Annotation = {
+      def later(delayedSym: ImplicitFunction1[Context, Symbol], span: Span)(implicit ctx: Context): Annotation = {
         def makeChildLater(implicit ctx: Context) = {
           val sym = delayedSym
           New(defn.ChildAnnot.typeRef.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil)
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -315,7 +315,7 @@ object Contexts {
     /** Run `op` as if it was run in a fresh explore typer state, but possibly
      *  optimized to re-use the current typer state.
      */
-    final def test[T](op: given Context => T): T = typerState.test(op)(this)
+    final def test[T](op: ImplicitFunction1[Context, T]): T = typerState.test(op)(this)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =
diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -172,7 +172,7 @@ object Decorators {
 
   implicit object reportDeco {
     def (x: T) reporting[T](
-        op: given WrappedResult[T] => String,
+        op: ImplicitFunction1[WrappedResult[T], String],
         printer: config.Printers.Printer = config.Printers.default): T = {
       printer.println(op given WrappedResult(x))
       x
diff --git a/compiler/src/dotty/tools/dotc/core/Periods.scala b/compiler/src/dotty/tools/dotc/core/Periods.scala
@@ -21,7 +21,7 @@ abstract class Periods { self: Context =>
     op(ctx.fresh.setPeriod(pd))
 
   /** Execute `op` at given phase id */
-  def atPhase[T](pid: PhaseId)(op: given Context => T): T =
+  def atPhase[T](pid: PhaseId)(op: ImplicitFunction1[Context, T]): T =
     op given ctx.withPhase(pid)
 
   /** The period containing the current period where denotations do not change.
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -31,12 +31,12 @@ trait Phases {
     }
 
   /** Execute `op` at given phase */
-  def atPhase[T](phase: Phase)(op: given Context => T): T =
+  def atPhase[T](phase: Phase)(op: ImplicitFunction1[Context, T]): T =
     atPhase(phase.id)(op)
 
-  def atNextPhase[T](op: given Context => T): T = atPhase(phase.next)(op)
+  def atNextPhase[T](op: ImplicitFunction1[Context, T]): T = atPhase(phase.next)(op)
 
-  def atPhaseNotLaterThan[T](limit: Phase)(op: given Context => T): T =
+  def atPhaseNotLaterThan[T](limit: Phase)(op: ImplicitFunction1[Context, T]): T =
     if (!limit.exists || phase <= limit) op given this else atPhase(limit)(op)
 
   def isAfterTyper: Boolean = base.isAfterTyper(phase)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2307,14 +2307,14 @@ object TypeComparer {
   val FreshApprox: ApproxState = new ApproxState(4)
 
   /** Show trace of comparison operations when performing `op` */
-  def explaining[T](say: String => Unit)(op: given Context => T)(implicit ctx: Context): T = {
+  def explaining[T](say: String => Unit)(op: ImplicitFunction1[Context, T])(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
     val res = try { op given nestedCtx } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 
   /** Like [[explaining]], but returns the trace instead */
-  def explained[T](op: given Context => T)(implicit ctx: Context): String = {
+  def explained[T](op: ImplicitFunction1[Context, T])(implicit ctx: Context): String = {
     var trace: String = null
     try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace
diff --git a/compiler/src/dotty/tools/dotc/core/TyperState.scala b/compiler/src/dotty/tools/dotc/core/TyperState.scala
@@ -96,7 +96,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
    *  typerstate. If it is unshared, run `op` in current typerState, restoring typerState
    *  to previous state afterwards.
    */
-  def test[T](op: given Context => T)(implicit ctx: Context): T =
+  def test[T](op: ImplicitFunction1[Context, T])(implicit ctx: Context): T =
     if (isShared)
       op given ctx.fresh.setExploreTyperState()
     else {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1279,7 +1279,7 @@ class TreeUnpickler(reader: TastyReader,
         PickledQuotes.quotedTypeToTree(quotedType)
       }
       else {
-        val splice1 = splice.asInstanceOf[Seq[Any] => given scala.quoted.QuoteContext => quoted.Expr[?]]
+        val splice1 = splice.asInstanceOf[Seq[Any] => ImplicitFunction1[scala.quoted.QuoteContext, quoted.Expr[?]]]
         val quotedExpr = splice1(reifiedArgs) given dotty.tools.dotc.quoted.QuoteContext()
         PickledQuotes.quotedExprToTree(quotedExpr)
       }
diff --git a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
@@ -378,7 +378,7 @@ object Interactive {
    */
   def localize(symbol: Symbol, sourceDriver: InteractiveDriver, targetDriver: InteractiveDriver): Symbol = {
 
-    def in[T](driver: InteractiveDriver)(fn: given Context => T): T =
+    def in[T](driver: InteractiveDriver)(fn: ImplicitFunction1[Context, T]): T =
       fn given driver.currentCtx
 
     if (sourceDriver == targetDriver) symbol
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2594,7 +2594,7 @@ object Parsers {
       else BitSet(IMPLICIT)
 
     val funTypeMods: BitSet =
-      if allowOldGiven then BitSet(GIVEN, IMPLIED, ERASED)
+      if allowOldGiven then BitSet(IMPLIED, ERASED)
       else BitSet()
 
     /** Wrap annotation or constructor in New(...).<init> */
@@ -3710,7 +3710,7 @@ object Parsers {
         setLastStatOffset()
         if (in.token == IMPORT)
           stats ++= importClause(IMPORT, Import)
-        else if (in.token == GIVEN) {
+        else if (in.token == IMPLIED || in.token == GIVEN) {
           val start = in.offset
           val mods = modifiers(closureMods)
           mods.mods match {
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -252,7 +252,7 @@ object Formatting {
     * ex"disambiguate $tpe1 and $tpe2"
     * ```
     */
-  def explained(op: given Context => String)(implicit ctx: Context): String = {
+  def explained(op: ImplicitFunction1[Context, String])(implicit ctx: Context): String = {
     val seen = new Seen
     val msg = op given explainCtx(seen)
     val addendum = explanations(seen)
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
@@ -1908,7 +1908,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   private def optional[T <: Trees.Tree[?]](tree: T): Option[tree.type] =
     if (tree.isEmpty) None else Some(tree)
 
-  private def withDefaultPos[T <: Tree](fn: given Context => T) given (ctx: Context): T =
+  private def withDefaultPos[T <: Tree](fn: ImplicitFunction1[Context, T]) given (ctx: Context): T =
     (fn given ctx.withSource(rootPosition.source)).withSpan(rootPosition.span)
 
   private def compilerId: Int = rootContext.outersIterator.toList.last.hashCode()
diff --git a/compiler/src/dotty/tools/dotc/transform/CtxLazy.scala b/compiler/src/dotty/tools/dotc/transform/CtxLazy.scala
@@ -11,7 +11,7 @@ import core.Contexts.Context
  *  A typical use case is a lazy val in a phase object which exists once per root context where
  *  the expression intiializing the lazy val depends only on the root context, but not any changes afterwards.
  */
-class CtxLazy[T](expr: given Context => T) {
+class CtxLazy[T](expr: ImplicitFunction1[Context, T]) {
   private[this] var myValue: T = _
   private[this] var forced = false
   def apply()(implicit ctx: Context): T = {
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -35,7 +35,7 @@ object ImportInfo {
  *  @param   isRootImport  true if this is one of the implicit imports of scala, java.lang,
  *                         scala.Predef or dotty.DottyPredef in the start context, false otherwise.
  */
-class ImportInfo(symf: given Context => Symbol, val selectors: List[untpd.Tree],
+class ImportInfo(symf: ImplicitFunction1[Context, Symbol], val selectors: List[untpd.Tree],
                  symNameOpt: Option[TermName],
                  val importGiven: Boolean,
                  val isRootImport: Boolean = false) extends Showable {
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -470,7 +470,7 @@ class Typer extends Namer
       case _                  => errorTree(tree, "cannot convert to type selection") // will never be printed due to fallback
     }
 
-    def selectWithFallback(fallBack: given Context => Tree) =
+    def selectWithFallback(fallBack: ImplicitFunction1[Context, Tree]) =
       tryAlternatively(typeSelectOnTerm)(fallBack)
 
     if (tree.qualifier.isType) {
@@ -2250,7 +2250,7 @@ class Typer extends Namer
   def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, selType)(ctx addMode Mode.Pattern)
 
-  def tryEither[T](op: given Context => T)(fallBack: (T, TyperState) => T)(implicit ctx: Context): T = {
+  def tryEither[T](op: ImplicitFunction1[Context, T])(fallBack: (T, TyperState) => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setNewTyperState()
     val result = op given nestedCtx
     if (nestedCtx.reporter.hasErrors && !nestedCtx.reporter.hasStickyErrors) {
@@ -2267,7 +2267,7 @@ class Typer extends Namer
   /** Try `op1`, if there are errors, try `op2`, if `op2` also causes errors, fall back
    *  to errors and result of `op1`.
    */
-  def tryAlternatively[T](op1: given Context => T)(op2: given Context => T)(implicit ctx: Context): T =
+  def tryAlternatively[T](op1: ImplicitFunction1[Context, T])(op2: ImplicitFunction1[Context, T])(implicit ctx: Context): T =
     tryEither(op1) { (failedVal, failedState) =>
       tryEither(op2) { (_, _) =>
         failedState.commit()
diff --git a/library/src-bootstrapped/scala/quoted/Liftable.scala b/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): given QuoteContext => Expr[T]
+  def toExpr(x: T): delegate 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) = given qctx => {
+    def toExpr(x: T) = delegate 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]) = given qctx => {
+    def toExpr(x: Class[T]) = delegate 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]): given QuoteContext => Expr[ClassTag[T]] =
+    def toExpr(ct: ClassTag[T]): delegate 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]): given QuoteContext => Expr[Array[T]] =
+    def toExpr(arr: Array[T]): delegate 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]): given QuoteContext => Expr[Array[Boolean]] =
+    def toExpr(array: Array[Boolean]): delegate 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]): given QuoteContext => Expr[Array[Byte]] =
+    def toExpr(array: Array[Byte]): delegate 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]): given QuoteContext => Expr[Array[Short]] =
+    def toExpr(array: Array[Short]): delegate 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]): given QuoteContext => Expr[Array[Char]] =
+    def toExpr(array: Array[Char]): delegate 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]): given QuoteContext => Expr[Array[Int]] =
+    def toExpr(array: Array[Int]): delegate 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]): given QuoteContext => Expr[Array[Long]] =
+    def toExpr(array: Array[Long]): delegate 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]): given QuoteContext => Expr[Array[Float]] =
+    def toExpr(array: Array[Float]): delegate 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]): given QuoteContext => Expr[Array[Double]] =
+    def toExpr(array: Array[Double]): delegate 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]): given QuoteContext => Expr[IArray[T]] =
+    def toExpr(iarray: IArray[T]): delegate 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]): given QuoteContext => Expr[Seq[T]] =
+    def toExpr(xs: Seq[T]): delegate 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]): given QuoteContext => Expr[List[T]] =
+    def toExpr(xs: List[T]): delegate 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]): given QuoteContext => Expr[Set[T]] =
+    def toExpr(set: Set[T]): delegate 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]): given QuoteContext => Expr[Map[T, U]] =
+    def toExpr(map: Map[T, U]): delegate 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]): given QuoteContext => Expr[Option[T]] = x match {
+    def toExpr(x: Option[T]): delegate 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]): given QuoteContext => Expr[Either[L, R]] = x match {
+    def toExpr(x: Either[L, R]): delegate 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): given QuoteContext => Expr[H *: T] =
+    def toExpr(tup: H *: T): delegate 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): given QuoteContext => Expr[BigInt] =
+    def toExpr(x: BigInt): delegate 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): given QuoteContext => Expr[BigDecimal] =
+    def toExpr(x: BigDecimal): delegate QuoteContext => Expr[BigDecimal] =
       '{ BigDecimal(${x.toString.toExpr}) }
   }
 
diff --git a/library/src/scala/internal/Quoted.scala b/library/src/scala/internal/Quoted.scala
@@ -7,11 +7,11 @@ object Quoted {
 
   /** A term quote is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.exprQuote`")
-  def exprQuote[T](x: T): given QuoteContext => Expr[T] = ???
+  def exprQuote[T](x: T): ImplicitFunction1[QuoteContext, Expr[T]] = ???
 
   /** A term splice is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.exprSplice`")
-  def exprSplice[T](x: given QuoteContext => Expr[T]): T = ???
+  def exprSplice[T](x: ImplicitFunction1[QuoteContext, Expr[T]]): T = ???
 
   /** A type quote is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.typeQuote`")
diff --git a/library/src/scala/internal/quoted/Matcher.scala b/library/src/scala/internal/quoted/Matcher.scala
@@ -17,7 +17,7 @@ private[quoted] object Matcher {
 
     private type Env = Set[(Symbol, Symbol)]
 
-    inline private def withEnv[T](env: Env)(body: => given Env => T): T = body given env
+    inline private def withEnv[T](env: Env)(body: => ImplicitFunction1[Env, T]): T = body given env
 
     class SymBinding(val sym: Symbol, val fromAbove: Boolean)
 
diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
diff --git a/library/src/scala/runtime/quoted/Unpickler.scala b/library/src/scala/runtime/quoted/Unpickler.scala
diff --git a/library/src/scala/util/control/NonLocalReturns.scala b/library/src/scala/util/control/NonLocalReturns.scala
diff --git a/staging/src/scala/quoted/staging/staging.scala b/staging/src/scala/quoted/staging/staging.scala
diff --git a/tests/run/extmethods2.scala b/tests/run/extmethods2.scala

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ object Decorators {`
`172`	`172`
`173`	`173`	`implicit object reportDeco {`
`174`	`174`	`def (x: T) reporting[T](`
`175`		`- op: given WrappedResult[T] => String,`
	`175`	`+ op: ImplicitFunction1[WrappedResult[T], String],`
`176`	`176`	`printer: config.Printers.Printer = config.Printers.default): T = {`
`177`	`177`	`printer.println(op given WrappedResult(x))`
`178`	`178`	`x`
Original file line number	Diff line number	Diff line change
`@@ -1279,7 +1279,7 @@ class TreeUnpickler(reader: TastyReader,`
`1279`	`1279`	`PickledQuotes.quotedTypeToTree(quotedType)`
`1280`	`1280`	`}`
`1281`	`1281`	`else {`
`1282`		`- val splice1 = splice.asInstanceOf[Seq[Any] => given scala.quoted.QuoteContext => quoted.Expr[?]]`
	`1282`	`+ val splice1 = splice.asInstanceOf[Seq[Any] => ImplicitFunction1[scala.quoted.QuoteContext, quoted.Expr[?]]]`
`1283`	`1283`	`val quotedExpr = splice1(reifiedArgs) given dotty.tools.dotc.quoted.QuoteContext()`
`1284`	`1284`	`PickledQuotes.quotedExprToTree(quotedExpr)`
`1285`	`1285`	`}`