make TyperState#test take an IFT argument

Author: odersky

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: 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/TyperState.scala

@@ -96,9 +96,9 @@ 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: Context => T)(implicit ctx: Context): T =
+  def test[T](op: given Context => T)(implicit ctx: Context): T =
     if (isShared)
-      op(ctx.fresh.setExploreTyperState())
+      op given ctx.fresh.setExploreTyperState()
     else {
       val savedConstraint = myConstraint
       val savedReporter = myReporter
@@ -114,7 +114,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
         testReporter.inUse = true
         testReporter
       }
-      try op(ctx)
+      try op given ctx
       finally {
         testReporter.inUse = false
         resetConstraintTo(savedConstraint)

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1153,20 +1153,20 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   def isApplicableMethodRef(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type, keepConstraint: Boolean)(implicit ctx: Context): Boolean = {
     def isApp(implicit ctx: Context): Boolean =
       new ApplicableToTrees(methRef, targs, args, resultType).success
-    if (keepConstraint) isApp else ctx.test(implicit ctx => isApp)
+    if (keepConstraint) isApp else ctx.test(isApp)
   }
 
   /** Is given method reference applicable to type arguments `targs` and argument trees `args` without inferring views?
     *  @param  resultType   The expected result type of the application
     */
   def isDirectlyApplicableMethodRef(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean =
-    ctx.test(implicit ctx => new ApplicableToTreesDirectly(methRef, targs, args, resultType).success)
+    ctx.test(new ApplicableToTreesDirectly(methRef, targs, args, resultType).success)
 
   /** Is given method reference applicable to argument types `args`?
    *  @param  resultType   The expected result type of the application
    */
   def isApplicableMethodRef(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean =
-    ctx.test(implicit ctx => new ApplicableToTypes(methRef, args, resultType).success)
+    ctx.test(new ApplicableToTypes(methRef, args, resultType).success)
 
   /** Is given type applicable to type arguments `targs` and argument trees `args`,
    *  possibly after inserting an `apply`?
@@ -1287,7 +1287,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case tp2: MethodType => true // (3a)
           case tp2: PolyType if tp2.resultType.isInstanceOf[MethodType] => true // (3a)
           case tp2: PolyType => // (3b)
-            ctx.test(implicit ctx => isAsSpecificValueType(tp1, constrained(tp2).resultType))
+            ctx.test(isAsSpecificValueType(tp1, constrained(tp2).resultType))
           case _ => // (3b)
             isAsSpecificValueType(tp1, tp2)
         }
@@ -1481,9 +1481,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      *  do they prune much, on average.
      */
     def adaptByResult(chosen: TermRef, alts: List[TermRef]) = pt match {
-      case pt: FunProto if !ctx.test(implicit ctx => resultConforms(chosen.symbol, chosen, pt.resultType)) =>
+      case pt: FunProto if !ctx.test(resultConforms(chosen.symbol, chosen, pt.resultType)) =>
         val conformingAlts = alts.filter(alt =>
-          (alt ne chosen) && ctx.test(implicit ctx => resultConforms(alt.symbol, alt, pt.resultType)))
+          (alt ne chosen) && ctx.test(resultConforms(alt.symbol, alt, pt.resultType)))
         conformingAlts match {
           case Nil => chosen
           case alt2 :: Nil => alt2

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -102,7 +102,7 @@ object Implicits {
             else if (mt.paramInfos.lengthCompare(1) == 0 && {
                   var formal = widenSingleton(mt.paramInfos.head)
                   if (approx) formal = wildApprox(formal)
-                  ctx.test(implicit ctx => argType relaxed_<:< formal.widenExpr)
+                  ctx.test(argType relaxed_<:< formal.widenExpr)
                 })
               Candidate.Conversion
             else
@@ -216,7 +216,7 @@ object Implicits {
         val nestedCtx = ctx.fresh.addMode(Mode.TypevarsMissContext)
 
         def matchingCandidate(ref: ImplicitRef): Option[Candidate] =
-          nestedCtx.test(implicit ctx => candidateKind(ref.underlyingRef)) match {
+          nestedCtx.test(candidateKind(ref.underlyingRef)) match {
             case Candidate.None => None
             case ckind => Some(new Candidate(ref, ckind, level))
           }
@@ -808,7 +808,7 @@ trait Implicits { self: Typer =>
           if (canComparePredefined(arg1, arg2)
               ||
               !strictEquality &&
-              ctx.test(implicit ctx => validEqAnyArgs(arg1, arg2)))
+              ctx.test(validEqAnyArgs(arg1, arg2)))
             ref(defn.Eql_eqlAny).appliedToTypes(args).withSpan(span)
           else EmptyTree
         case _ =>
@@ -1391,7 +1391,7 @@ trait Implicits { self: Typer =>
       def compareCandidate(prev: SearchSuccess, ref: TermRef, level: Int): Int =
         if (prev.ref eq ref) 0
         else if (prev.level != level) prev.level - level
-        else nestedContext().test(implicit ctx => compare(prev.ref, ref))
+        else nestedContext().test(compare(prev.ref, ref))
 
       /** If `alt1` is also a search success, try to disambiguate as follows:
        *    - If alt2 is preferred over alt1, pick alt2, otherwise return an

compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -56,7 +56,7 @@ object ProtoTypes {
             normalizedCompatible(tp, pt, keepConstraint = false)
           case _ => testCompat
         }
-      else ctx.test(implicit ctx => testCompat)
+      else ctx.test(testCompat)
     }
 
     private def disregardProto(pt: Type)(implicit ctx: Context): Boolean = pt.dealias match {