Merge pull request #7251 from dotty-staging/given-cleanups

Given cleanups

Author: anatoliykmetyuk

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: ImplicitFunction1[Context, Tree])(implicit ctx: Context): Annotation =
+    def deferred(sym: Symbol)(treeFn: (given 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: ImplicitFunction1[Context, Symbol])(treeFn: ImplicitFunction1[Context, Tree])(implicit ctx: Context): Annotation =
+    def deferredSymAndTree(symf: (given Context) => Symbol)(treeFn: (given 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: ImplicitFunction1[Context, Symbol], span: Span)(implicit ctx: Context): Annotation = {
+      def later(delayedSym: (given 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)

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: ImplicitFunction1[Context, T]): T = typerState.test(op)(this)
+    final def test[T](op: (given Context) => T): T = typerState.test(op)(this)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =

compiler/src/dotty/tools/dotc/core/Decorators.scala

@@ -172,7 +172,7 @@ object Decorators {
 
   implicit object reportDeco {
     def (x: T) reporting[T](
-        op: ImplicitFunction1[WrappedResult[T], String],
+        op: (given WrappedResult[T]) => String,
         printer: config.Printers.Printer = config.Printers.default): T = {
       printer.println(op(given WrappedResult(x)))
       x

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: ImplicitFunction1[Context, T]): T =
+  def atPhase[T](pid: PhaseId)(op: (given Context) => T): T =
     op(given ctx.withPhase(pid))
 
   /** The period containing the current period where denotations do not change.

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: ImplicitFunction1[Context, T]): T =
+  def atPhase[T](phase: Phase)(op: (given Context) => T): T =
     atPhase(phase.id)(op)
 
-  def atNextPhase[T](op: ImplicitFunction1[Context, T]): T = atPhase(phase.next)(op)
+  def atNextPhase[T](op: (given Context) => T): T = atPhase(phase.next)(op)
 
-  def atPhaseNotLaterThan[T](limit: Phase)(op: ImplicitFunction1[Context, T]): T =
+  def atPhaseNotLaterThan[T](limit: Phase)(op: (given Context) => T): T =
     if (!limit.exists || phase <= limit) op(given this) else atPhase(limit)(op)
 
   def isAfterTyper: Boolean = base.isAfterTyper(phase)

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: ImplicitFunction1[Context, T])(implicit ctx: Context): T = {
+  def explaining[T](say: String => Unit)(op: (given 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: ImplicitFunction1[Context, T])(implicit ctx: Context): String = {
+  def explained[T](op: (given Context) => T)(implicit ctx: Context): String = {
     var trace: String = null
     try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace

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: ImplicitFunction1[Context, T])(implicit ctx: Context): T =
+  def test[T](op: (given Context) => T)(implicit ctx: Context): T =
     if (isShared)
       op(given ctx.fresh.setExploreTyperState())
     else {

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] => ImplicitFunction1[scala.quoted.QuoteContext, quoted.Expr[?]]]
+        val splice1 = splice.asInstanceOf[Seq[Any] => (given scala.quoted.QuoteContext) => quoted.Expr[?]]
         val quotedExpr = splice1(reifiedArgs)(given dotty.tools.dotc.quoted.QuoteContext())
         PickledQuotes.quotedExprToTree(quotedExpr)
       }

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: ImplicitFunction1[Context, T]): T =
+    def in[T](driver: InteractiveDriver)(fn: (given Context) => T): T =
       fn(given driver.currentCtx)
 
     if (sourceDriver == targetDriver) symbol

compiler/src/dotty/tools/dotc/printing/Formatting.scala

@@ -252,7 +252,7 @@ object Formatting {
     * ex"disambiguate $tpe1 and $tpe2"
     * ```
     */
-  def explained(op: ImplicitFunction1[Context, String])(implicit ctx: Context): String = {
+  def explained(op: (given Context) => String)(implicit ctx: Context): String = {
     val seen = new Seen
     val msg = op(given explainCtx(seen))
     val addendum = explanations(seen)