New helper method: withContext

Prefer this over defining contexts locally. It's less sensitive to
accidental recursions.

Rename withContext -> withCompilerContext in compilerSupport

Author: odersky

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

@@ -52,6 +52,10 @@ object Contexts {
   /** The current context */
   def ctx(using ctx: Context): Context = ctx
 
+  /** Run `op` with given context */
+  inline def withContext[T](c: Context)(inline op: Context ?=> T): T =
+    op(using c)
+
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
    *  objects that turn into space leaks. To combat this risk, here are some

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

@@ -99,21 +99,20 @@ object ContextFunctionResults:
    *  Erased parameters are ignored; they contribute nothing to the
    *  parameter count.
    */
-  def contextFunctionResultTypeCovering(meth: Symbol, paramCount: Int)(using preCtx: Context) =
-    given Context = preCtx.withPhase(preCtx.erasurePhase)
-
-    // Recursive instances return pairs of context types and the
-    // # of parameters they represent.
-    def missingCR(tp: Type, crCount: Int): (Type, Int) =
-      if crCount == 0 then (tp, 0)
-      else
-        val defn.ContextFunctionType(formals, resTpe, isErased): @unchecked = tp
-        val result @ (rt, nparams) = missingCR(resTpe, crCount - 1)
-        assert(nparams <= paramCount)
-        if nparams == paramCount || isErased then result
-        else (tp, nparams + formals.length)
-    missingCR(meth.info.finalResultType, contextResultCount(meth))._1
-  end contextFunctionResultTypeCovering
+  def contextFunctionResultTypeCovering(meth: Symbol, paramCount: Int)(using Context) =
+    withContext(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) =
+        if crCount == 0 then (tp, 0)
+        else
+          val defn.ContextFunctionType(formals, resTpe, isErased): @unchecked = tp
+          val result @ (rt, nparams) = missingCR(resTpe, crCount - 1)
+          assert(nparams <= paramCount)
+          if nparams == paramCount || isErased then result
+          else (tp, nparams + formals.length)
+      missingCR(meth.info.finalResultType, contextResultCount(meth))._1
+    }
 
   /** Should selection `tree` be eliminated since it refers to an `apply`
    *  node of a context function type whose parameters will end up being

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

@@ -453,9 +453,8 @@ object Erasure {
                   else implType.derivedLambdaType(paramInfos = samParamTypes)
                 else implType.derivedLambdaType(resType = samResultType)
               val bridge = ctx.newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method, bridgeType)
-              val bridgeCtx = ctx.withOwner(bridge)
-              Closure(bridge, bridgeParamss => {
-                  given Context = bridgeCtx
+              Closure(bridge, bridgeParamss =>
+                withContext(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

@@ -37,18 +37,18 @@ object Splicer {
    *
    *  See: `Staging`
    */
-  def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(using ctx: Context): Tree = tree match {
+  def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(using Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
     case _ =>
       val interpreter = new Interpreter(pos, classLoader)
       val macroOwner = ctx.newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
-      try {
-        given Context = 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())))
-        checkEscapedVariables(interpretedTree, macroOwner).changeOwner(macroOwner, ctx.owner)
-      }
+      try
+        withContext(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())))
+          checkEscapedVariables(interpretedTree, macroOwner)
+        }.changeOwner(macroOwner, ctx.owner)
       catch {
         case ex: CompilationUnit.SuspendException =>
           throw ex
@@ -70,7 +70,7 @@ object Splicer {
   }
 
   /** Checks that no symbol that whas generated within the macro expansion has an out of scope reference */
-  def checkEscapedVariables(tree: Tree, expansionOwner: Symbol)(using ctx: Context): tree.type =
+  def checkEscapedVariables(tree: Tree, expansionOwner: Symbol)(using Context): tree.type =
     new TreeTraverser {
       private[this] var locals = Set.empty[Symbol]
       private def markSymbol(sym: Symbol)(implicit ctx: Context): Unit =
@@ -79,7 +79,7 @@ object Splicer {
         case tree: DefTree => markSymbol(tree.symbol)
         case _ =>
       }
-      def traverse(tree: Tree)(using ctx: Context): Unit =
+      def traverse(tree: Tree)(using Context): Unit =
         def traverseOver(lastEntered: Set[Symbol]) =
           try traverseChildren(tree)
           finally locals = lastEntered
@@ -98,7 +98,7 @@ object Splicer {
           case _ =>
             markDef(tree)
             traverseChildren(tree)
-      private def isEscapedVariable(sym: Symbol)(using ctx: Context): Boolean =
+      private def isEscapedVariable(sym: Symbol)(using Context): Boolean =
         sym.exists && !sym.is(Package)
         && sym.owner.ownersIterator.exists(x =>
           x == expansionOwner || // symbol was generated within this macro expansion
@@ -412,7 +412,7 @@ object Splicer {
       }
 
     private object MissingClassDefinedInCurrentRun {
-      def unapply(targetException: NoClassDefFoundError)(using ctx: Context): Option[Symbol] = {
+      def unapply(targetException: NoClassDefFoundError)(using Context): Option[Symbol] = {
         val className = targetException.getMessage
         if (className eq null) None
         else {

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

@@ -149,8 +149,7 @@ trait ImportSuggestions:
      */
     def shallowTest(ref: TermRef): Boolean =
       System.currentTimeMillis < deadLine
-      && {
-        given Context = ctx.fresh.setExploreTyperState()
+      && withContext(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
+import Contexts.{Context, withContext, ctx}
 import Names.{Name, TermName}
 import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName, BodyRetainerName}
 import ProtoTypes.selectionProto
@@ -1341,8 +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 = {
-      given Context = tastyreflect.MacroExpansion.context(inlinedFrom)(using ctx)
+    val evaluatedSplice = withContext(tastyreflect.MacroExpansion.context(inlinedFrom)) {
       Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)
     }
     val inlinedNormailizer = new TreeMap {

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

@@ -1068,13 +1068,14 @@ class Typer extends Namer
             case untpd.TypedSplice(expr1) =>
               expr1.tpe
             case _ =>
+              val curCtx = ctx
               given nestedCtx as Context = ctx.fresh.setNewTyperState()
               val protoArgs = args map (_ withType WildcardType)
               val callProto = FunProto(protoArgs, WildcardType)(this, app.isUsingApply)
               val expr1 = typedExpr(expr, callProto)
               if nestedCtx.reporter.hasErrors then NoType
               else
-                given Context = ctx
+                given Context = curCtx
                 nestedCtx.typerState.commit()
                 fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
                 expr1.tpe

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 =>
-      withContext(javaOutputDir.toString + File.pathSeparator + TestConfiguration.basicClasspath) {
+      withCompilerContext(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 withContext[T](classpath: String)(op: Context ?=> T): T =
+def withCompilerContext[T](classpath: String)(op: Context ?=> T): T =
   val compiler = Compiler()
   val run = compiler.newRun(initCtx(classpath))
   run.compileUnits(Nil) // Initialize phases