Don't write (using ctx: Context)

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -4,7 +4,7 @@ package backend.jvm
 import dotc.ast.Trees.Select
 import dotc.ast.tpd._
 import dotc.core._
-import Contexts.Context
+import Contexts.{Context, ctx}
 import Names.TermName, StdNames._
 import Types.{JavaArrayType, UnspecifiedErrorType, Type}
 import Symbols.{Symbol, NoSymbol}
@@ -49,7 +49,7 @@ class DottyPrimitives(ictx: Context) {
    * @param tpe The type of the receiver object. It is used only for array
    *            operations
    */
-  def getPrimitive(app: Apply, tpe: Type)(implicit ctx: Context): Int = {
+  def getPrimitive(app: Apply, tpe: Type)(using Context): Int = {
     val fun = app.fun.symbol
     val defn = ctx.definitions
     val code = app.fun match {
@@ -130,7 +130,7 @@ class DottyPrimitives(ictx: Context) {
       primitives(s) = code
     }
 
-    def addPrimitives(cls: Symbol, method: TermName, code: Int)(implicit ctx: Context): Unit = {
+    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
       val alts = cls.info.member(method).alternatives.map(_.symbol)
       if (alts.isEmpty)
         ctx.error(s"Unknown primitive method $cls.$method")

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -1,18 +1,18 @@
 package dotty.tools
 package dotc
 
-import util.{FreshNameCreator, SourceFile}
+import core._
+import Contexts.{Context, ctx}
+import SymDenotations.ClassDenotation
+import Symbols._
+import util.{FreshNameCreator, SourceFile, NoSource}
+import util.Spans.Span
 import ast.{tpd, untpd}
 import tpd.{Tree, TreeTraverser}
 import typer.PrepareInlineable.InlineAccessors
 import typer.Nullables
-import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.SymDenotations.ClassDenotation
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.transform.SymUtils._
-import util.{NoSource, SourceFile}
-import util.Spans.Span
-import core.Decorators._
+import transform.SymUtils._
+import core.Decorators.{given _}
 
 class CompilationUnit protected (val source: SourceFile) {
 
@@ -43,7 +43,7 @@ class CompilationUnit protected (val source: SourceFile) {
 
   var suspended: Boolean = false
 
-  def suspend()(using ctx: Context): Nothing =
+  def suspend()(using Context): Nothing =
     if !suspended then
       if (ctx.settings.XprintSuspension.value)
         ctx.echo(i"suspended: $this")

compiler/src/dotty/tools/dotc/Run.scala

@@ -60,7 +60,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       .setTyperState(new TyperState(ctx.typerState))
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, rootRef: ImportInfo.RootRef) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef)(ctx))
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef))
     defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 

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

@@ -919,7 +919,7 @@ object desugar {
    *      <extension> def g[Ts](x: T)(using C)(z: T) = f(z)
    */
   def collectiveExtensionBody(stats: List[Tree],
-      tparams: List[TypeDef], vparamss: List[List[ValDef]])(using ctx: Context): List[Tree] =
+      tparams: List[TypeDef], vparamss: List[List[ValDef]])(using Context): List[Tree] =
     for stat <- stats yield
       stat match
         case mdef: DefDef =>
@@ -968,7 +968,7 @@ object desugar {
   }
 
   /** Invent a name for an anonympus given or extension of type or template `impl`. */
-  def inventGivenOrExtensionName(impl: Tree)(using ctx: Context): SimpleName =
+  def inventGivenOrExtensionName(impl: Tree)(using Context): SimpleName =
     val str = impl match
       case impl: Template =>
         if impl.parents.isEmpty then

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

@@ -40,7 +40,7 @@ object MainProxies {
   }
 
   import untpd._
-  def mainProxy(mainFun: Symbol)(using ctx: Context): List[TypeDef] = {
+  def mainProxy(mainFun: Symbol)(using Context): List[TypeDef] = {
     val mainAnnotSpan = mainFun.getAnnotation(defn.MainAnnot).get.tree.span
     def pos = mainFun.sourcePos
     val argsRef = Ident(nme.args)

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

@@ -48,7 +48,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
             case stat: Import => ctx.importContext(stat, stat.symbol)
             case _ => ctx
           }
-          val stat1 = transform(stat)(statCtx)
+          val stat1 = transform(stat)(using statCtx)
           if (stat1 ne stat) recur(stats, stat1, rest)(restCtx)
           else traverse(rest)(restCtx)
         case nil =>
@@ -81,37 +81,37 @@ class TreeMapWithImplicits extends tpd.TreeMap {
     nestedCtx
   }
 
-  override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+  override def transform(tree: Tree)(using Context): Tree = {
     def localCtx =
       if (tree.hasType && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
     try tree match {
       case tree: Block =>
-        super.transform(tree)(nestedScopeCtx(tree.stats))
+        super.transform(tree)(using nestedScopeCtx(tree.stats))
       case tree: DefDef =>
-        implicit val ctx = localCtx
+        given Context = localCtx
         cpy.DefDef(tree)(
           tree.name,
           transformSub(tree.tparams),
           tree.vparamss mapConserve (transformSub(_)),
           transform(tree.tpt),
-          transform(tree.rhs)(nestedScopeCtx(tree.vparamss.flatten)))
+          transform(tree.rhs)(using nestedScopeCtx(tree.vparamss.flatten)))
       case EmptyValDef =>
         tree
       case _: PackageDef | _: MemberDef =>
-        super.transform(tree)(localCtx)
+        super.transform(tree)(using localCtx)
       case impl @ Template(constr, parents, self, _) =>
         cpy.Template(tree)(
           transformSub(constr),
-          transform(parents)(ctx.superCallContext),
+          transform(parents)(using ctx.superCallContext),
           Nil,
           transformSelf(self),
           transformStats(impl.body, tree.symbol))
       case tree: CaseDef =>
-        val patCtx = patternScopeCtx(tree.pat)(ctx)
+        val patCtx = patternScopeCtx(tree.pat)(using ctx)
         cpy.CaseDef(tree)(
           transform(tree.pat),
-          transform(tree.guard)(patCtx),
-          transform(tree.body)(patCtx)
+          transform(tree.guard)(using patCtx),
+          transform(tree.body)(using patCtx)
         )
       case _ =>
         super.transform(tree)