Rename withContext -> inContext

Author: odersky

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -1236,7 +1236,7 @@ object Trees {
 
     abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
       def transform(tree: Tree)(using Context): Tree = {
-        withContext(
+        inContext(
           if tree.source != ctx.source && tree.source.exists
           then ctx.withSource(tree.source)
           else ctx
@@ -1300,7 +1300,7 @@ object Trees {
             case AppliedTypeTree(tpt, args) =>
               cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
             case LambdaTypeTree(tparams, body) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
               }
             case MatchTypeTree(bound, selector, cases) =>
@@ -1318,17 +1318,17 @@ object Trees {
             case EmptyValDef =>
               tree
             case tree @ ValDef(name, tpt, _) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 val tpt1 = transform(tpt)
                 val rhs1 = transform(tree.rhs)
                 cpy.ValDef(tree)(name, tpt1, rhs1)
               }
             case tree @ DefDef(name, tparams, vparamss, tpt, _) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 cpy.DefDef(tree)(name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(tree.rhs))
               }
             case tree @ TypeDef(name, rhs) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 cpy.TypeDef(tree)(name, transform(rhs))
               }
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
@@ -1429,7 +1429,7 @@ object Trees {
             case AppliedTypeTree(tpt, args) =>
               this(this(x, tpt), args)
             case LambdaTypeTree(tparams, body) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 this(this(x, tparams), body)
               }
             case MatchTypeTree(bound, selector, cases) =>
@@ -1445,15 +1445,15 @@ object Trees {
             case UnApply(fun, implicits, patterns) =>
               this(this(this(x, fun), implicits), patterns)
             case tree @ ValDef(_, tpt, _) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 this(this(x, tpt), tree.rhs)
               }
             case tree @ DefDef(_, tparams, vparamss, tpt, _) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 this(this(vparamss.foldLeft(this(x, tparams))(apply), tpt), tree.rhs)
               }
             case TypeDef(_, rhs) =>
-              withContext(localCtx) {
+              inContext(localCtx) {
                 this(x, rhs)
               }
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>

compiler/src/dotty/tools/dotc/config/PathResolver.scala

@@ -142,7 +142,7 @@ object PathResolver {
       println(Environment)
       println(Defaults)
     }
-    else withContext(ContextBase().initialCtx) {
+    else inContext(ContextBase().initialCtx) {
       val ArgsSummary(sstate, rest, errors, warnings) =
         ctx.settings.processArguments(args.toList, true)
       errors.foreach(println)

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

@@ -53,7 +53,7 @@ object Contexts {
   def ctx(using ctx: Context): Context = ctx
 
   /** Run `op` with given context */
-  inline def withContext[T](c: Context)(inline op: Context ?=> T): T =
+  inline def inContext[T](c: Context)(inline op: Context ?=> T): T =
     op(using c)
 
   /** A context is passed basically everywhere in dotc.

compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala

@@ -100,7 +100,7 @@ object ContextFunctionResults:
    *  parameter count.
    */
   def contextFunctionResultTypeCovering(meth: Symbol, paramCount: Int)(using Context) =
-    withContext(ctx.withPhase(ctx.erasurePhase)) {
+    inContext(ctx.withPhase(ctx.erasurePhase)) {
       // Recursive instances return pairs of context types and the
       // # of parameters they represent.
       def missingCR(tp: Type, crCount: Int): (Type, Int) =

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -454,7 +454,7 @@ object Erasure {
                 else implType.derivedLambdaType(resType = samResultType)
               val bridge = ctx.newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method, bridgeType)
               Closure(bridge, bridgeParamss =>
-                withContext(ctx.withOwner(bridge)) {
+                inContext(ctx.withOwner(bridge)) {
                   val List(bridgeParams) = bridgeParamss
                   assert(ctx.typer.isInstanceOf[Erasure.Typer])
                   val rhs = Apply(meth, bridgeParams.lazyZip(implParamTypes).map(ctx.typer.adapt(_, _)))

compiler/src/dotty/tools/dotc/transform/Splicer.scala

@@ -43,7 +43,7 @@ object Splicer {
       val interpreter = new Interpreter(pos, classLoader)
       val macroOwner = ctx.newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
-        withContext(ctx.withOwner(macroOwner)) {
+        inContext(ctx.withOwner(macroOwner)) {
           // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
           val interpretedExpr = interpreter.interpret[scala.quoted.QuoteContext => scala.quoted.Expr[Any]](tree)
           val interpretedTree = interpretedExpr.fold(tree)(macroClosure => PickledQuotes.quotedExprToTree(macroClosure(QuoteContext())))

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

@@ -149,7 +149,7 @@ trait ImportSuggestions:
      */
     def shallowTest(ref: TermRef): Boolean =
       System.currentTimeMillis < deadLine
-      && withContext(ctx.fresh.setExploreTyperState()) {
+      && inContext(ctx.fresh.setExploreTyperState()) {
         def test(pt: Type): Boolean = pt match
           case ViewProto(argType, OrType(rt1, rt2)) =>
             // Union types do not constrain results, since comparison with a union

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

@@ -13,7 +13,7 @@ import Constants._
 import StagingContext._
 import StdNames._
 import transform.SymUtils._
-import Contexts.{Context, withContext, ctx}
+import Contexts.{Context, inContext, ctx}
 import Names.{Name, TermName}
 import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName, BodyRetainerName}
 import ProtoTypes.selectionProto
@@ -1341,7 +1341,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           ctx.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", call.sourcePos)
       ctx.compilationUnit.suspend() // this throws a SuspendException
 
-    val evaluatedSplice = withContext(tastyreflect.MacroExpansion.context(inlinedFrom)) {
+    val evaluatedSplice = inContext(tastyreflect.MacroExpansion.context(inlinedFrom)) {
       Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)
     }
     val inlinedNormailizer = new TreeMap {

compiler/test/dotty/tools/AnnotationsTests.scala

@@ -19,7 +19,7 @@ class AnnotationsTest:
         "public @interface Annot { String[] values() default {}; }"),
       VirtualJavaSource("A.java",
         "@Annot(values = {}) public class A {}")) { javaOutputDir =>
-      withCompilerContext(javaOutputDir.toString + File.pathSeparator + TestConfiguration.basicClasspath) {
+      inCompilerContext(javaOutputDir.toString + File.pathSeparator + TestConfiguration.basicClasspath) {
         (using ctx: Context) =>
         val defn = ctx.definitions
         val cls = ctx.requiredClass("A")

compiler/test/dotty/tools/compilerSupport.scala

@@ -13,7 +13,7 @@ import dotc.core.Comments.{ContextDoc, ContextDocstrings}
 /** Initialize a compiler context with the given classpath and
  *  pass it to `op`.
  */
-def withCompilerContext[T](classpath: String)(op: Context ?=> T): T =
+def inCompilerContext[T](classpath: String)(op: Context ?=> T): T =
   val compiler = Compiler()
   val run = compiler.newRun(initCtx(classpath))
   run.compileUnits(Nil) // Initialize phases