Drop usages of ImplicitFunction1

odersky · odersky · commit 8d3e20b42714 · 2019-09-23T11:52:56.000+02:00
These were needed for the bootstrap since explicitly naming ImplictFunction1 was
the only way to define an implicit function type that worked for all Dotty versions.
Can be replaced with  now.
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: 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)
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: 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 =
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: ImplicitFunction1[WrappedResult[T], String],
+        op: (given 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: 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.
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: 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)
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: 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
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: 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 {
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] => 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)
       }
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: ImplicitFunction1[Context, T]): T =
+    def in[T](driver: InteractiveDriver)(fn: (given Context) => T): T =
       fn(given driver.currentCtx)
 
     if (sourceDriver == targetDriver) symbol
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: 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)
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
@@ -1904,8 +1904,8 @@ 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: ImplicitFunction1[Context, T])(given ctx: Context): T =
-    (fn(given ctx.withSource(rootPosition.source)).withSpan(rootPosition.span))
+  private def withDefaultPos[T <: Tree](fn: (given 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: ImplicitFunction1[Context, T]) {
+class CtxLazy[T](expr: (given 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
@@ -43,7 +43,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: ImplicitFunction1[Context, Symbol],
+class ImportInfo(symf: (given Context) => Symbol,
                  val selectors: List[untpd.ImportSelector],
                  symNameOpt: Option[TermName],
                  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
@@ -463,7 +463,7 @@ class Typer extends Namer
       case _                  => errorTree(tree, "cannot convert to type selection") // will never be printed due to fallback
     }
 
-    def selectWithFallback(fallBack: ImplicitFunction1[Context, Tree]) =
+    def selectWithFallback(fallBack: (given Context) => Tree) =
       tryAlternatively(typeSelectOnTerm)(fallBack)
 
     if (tree.qualifier.isType) {
@@ -2244,7 +2244,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: ImplicitFunction1[Context, T])(fallBack: (T, TyperState) => T)(implicit ctx: Context): T = {
+  def tryEither[T](op: (given 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) {
@@ -2261,7 +2261,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: ImplicitFunction1[Context, T])(op2: ImplicitFunction1[Context, T])(implicit ctx: Context): T =
+  def tryAlternatively[T](op1: (given Context) => T)(op2: (given Context) => T)(implicit ctx: Context): T =
     tryEither(op1) { (failedVal, failedState) =>
       tryEither(op2) { (_, _) =>
         failedState.commit()
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): ImplicitFunction1[QuoteContext, Expr[T]] = ???
+  def exprQuote[T](x: T): (given 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: ImplicitFunction1[QuoteContext, Expr[T]]): T = ???
+  def exprSplice[T](x: (given 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: => ImplicitFunction1[Env, T]): T = body(given env)
+    inline private def withEnv[T](env: Env)(body: => (given 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
@@ -26,7 +26,7 @@ package quoted {
     import scala.internal.quoted._
 
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
-    type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, [X] =>> ImplicitFunction1[QuoteContext, Expr[X]]]
+    type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, [X] =>> (given QuoteContext) => Expr[X]]
 
     implicit class AsFunction[F, Args <: Tuple, R](f: Expr[F])(given tf: TupledFunction[F, Args => R], qctx: QuoteContext) {
       /** Beta-reduces the function appication. Generates the an expression only containing the body of the function */
@@ -36,7 +36,7 @@ package quoted {
       }
     }
 
-    implicit class AsContextualFunction[F, Args <: Tuple, R](f: Expr[F])(given tf: TupledFunction[F, ImplicitFunction1[Args, R]], qctx: QuoteContext) {
+    implicit class AsContextualFunction[F, Args <: Tuple, R](f: Expr[F])(given tf: TupledFunction[F, (given Args) => R], qctx: QuoteContext) {
       /** Beta-reduces the function appication. Generates the an expression only containing the body of the function */
       def apply[G](given tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]]): G = {
         import qctx.tasty._
@@ -45,13 +45,13 @@ package quoted {
     }
 
     /** Returns a null expresssion equivalent to `'{null}` */
-    def nullExpr: ImplicitFunction1[QuoteContext, Expr[Null]] = (given qctx) => {
+    def nullExpr: (given QuoteContext) => Expr[Null] = (given qctx) => {
       import qctx.tasty._
       Literal(Constant(null)).seal.asInstanceOf[Expr[Null]]
     }
 
     /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
-    def unitExpr: ImplicitFunction1[QuoteContext, Expr[Unit]] = (given qctx) => {
+    def unitExpr: (given QuoteContext) => Expr[Unit] = (given qctx) => {
       import qctx.tasty._
       Literal(Constant(())).seal.asInstanceOf[Expr[Unit]]
     }
diff --git a/library/src/scala/runtime/quoted/Unpickler.scala b/library/src/scala/runtime/quoted/Unpickler.scala
@@ -6,19 +6,19 @@ import scala.quoted.{Expr, QuoteContext, Type}
 object Unpickler {
 
   type PickledQuote = List[String]
-  type PickledExprArgs = Seq[Seq[Any] => ((ImplicitFunction1[QuoteContext, Expr[Any]]) | Type[_])]
+  type PickledExprArgs = Seq[Seq[Any] => (((given QuoteContext) => Expr[Any]) | Type[_])]
   type PickledTypeArgs = Seq[Seq[Any] => Type[_]]
 
   /** Unpickle `repr` which represents a pickled `Expr` tree,
    *  replacing splice nodes with `args`
    */
-  def unpickleExpr[T](repr: PickledQuote, args: PickledExprArgs): ImplicitFunction1[QuoteContext, Expr[T]] =
+  def unpickleExpr[T](repr: PickledQuote, args: PickledExprArgs): (given QuoteContext) => Expr[T] =
     summon[QuoteContext].tasty.internal.unpickleExpr(repr, args).asInstanceOf[Expr[T]]
 
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `args`
    */
-  def unpickleType[T](repr: PickledQuote, args: PickledTypeArgs): ImplicitFunction1[QuoteContext, Type[T]] =
+  def unpickleType[T](repr: PickledQuote, args: PickledTypeArgs): (given QuoteContext) => Type[T] =
     summon[QuoteContext].tasty.internal.unpickleType(repr, args).asInstanceOf[Type[T]]
 
 
diff --git a/library/src/scala/util/control/NonLocalReturns.scala b/library/src/scala/util/control/NonLocalReturns.scala
@@ -23,7 +23,7 @@ object NonLocalReturns {
     returner.throwReturn(result)
 
   /** Enable nonlocal returns in `op`. */
-  def returning[T](op: ImplicitFunction1[ReturnThrowable[T], T]): T = {
+  def returning[T](op: (given ReturnThrowable[T]) => T): T = {
     val returner = new ReturnThrowable[T]
     try op(given returner)
     catch {
diff --git a/staging/src/scala/quoted/staging/staging.scala b/staging/src/scala/quoted/staging/staging.scala
@@ -16,7 +16,7 @@ package object staging {
    *  This method should not be called in a context where there is already has a `QuoteContext`
    *  such as within a `run` or a `withQuoteContext`.
    */
-  def run[T](expr: ImplicitFunction1[QuoteContext, Expr[T]])(given toolbox: Toolbox): T = toolbox.run(expr(given _))
+  def run[T](expr: (given QuoteContext) => Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr(given _))
 
   /** Provide a new quote context within the scope of the argument that is only valid within the scope the argument.
    *  Return the result of the argument.
@@ -32,7 +32,7 @@ package object staging {
    *  This method should not be called in a context where there is already has a `QuoteContext`
    *  such as within a `run` or a `withQuoteContext`.
    */
-  def withQuoteContext[T](thunk: ImplicitFunction1[QuoteContext, T])(given toolbox: Toolbox): T = {
+  def withQuoteContext[T](thunk: (given QuoteContext) => T)(given toolbox: Toolbox): T = {
     val noResult = new Object
     var result: T = noResult.asInstanceOf[T]
     def dummyRun(given QuoteContext): Expr[Unit] = {
diff --git a/tests/neg/i2006.scala b/tests/neg/i2006.scala
@@ -1,7 +1,7 @@
 object Test {
 
-  inline def foo(f: ImplicitFunction1[Int, Int]): AnyRef = f // error
-  inline def bar(f: ImplicitFunction1[Int, Int]) = f // error
+  inline def foo(f: (given Int) => Int): AnyRef = f // error
+  inline def bar(f: (given Int) => Int) = f // error
 
   def main(args: Array[String]) = {
     foo((given thisTransaction) => 43)

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: ImplicitFunction1[WrappedResult[T], String],`
	`175`	`+ op: (given 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] => ImplicitFunction1[scala.quoted.QuoteContext, quoted.Expr[?]]]`
	`1282`	`+ val splice1 = splice.asInstanceOf[Seq[Any] => (given scala.quoted.QuoteContext) => quoted.Expr[?]]`
`1283`	`1283`	`val quotedExpr = splice1(reifiedArgs)(given dotty.tools.dotc.quoted.QuoteContext())`
`1284`	`1284`	`PickledQuotes.quotedExprToTree(quotedExpr)`
`1285`	`1285`	`}`