Rename ctx values

We would like to distinguish between `ctx` referring to an enclosing parameter
and `ctx` referring to a field. This is so that we can at some point drop
`ctx` as a parameter name and just use (using Context). The `ctx` would then
go to an imported def in `Contexts`. But any other use of `ctx` does does not
follow strict nesting discipline can then change meaning, so we should
get these out of the way first.

Author: odersky

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

@@ -69,7 +69,7 @@ object GenBCode {
   val name: String = "genBCode"
 }
 
-class GenBCodePipeline(val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry {
+class GenBCodePipeline(val int: DottyBackendInterface)(implicit ctx: Context) extends BCodeSyncAndTry {
 
   private var tree: Tree = _
 

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

@@ -1,8 +1,3 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2012 LAMP/EPFL
- * @author  Martin Odersky
- */
-
 package dotty.tools
 package backend.jvm
 
@@ -35,7 +30,7 @@ import scala.collection.immutable
  *
  * Inspired from the `scalac` compiler.
  */
-class DottyPrimitives(ctx: Context) {
+class DottyPrimitives(ictx: Context) {
   import dotty.tools.backend.ScalaPrimitivesOps._
 
   @threadUnsafe private lazy val primitives: immutable.Map[Symbol, Int] = init
@@ -124,7 +119,7 @@ class DottyPrimitives(ctx: Context) {
   /** Initialize the primitive map */
   private def init: immutable.Map[Symbol, Int]  = {
 
-    implicit val ctx = this.ctx
+    given Context = ictx
 
     import Symbols.defn
     val primitives = Symbols.newMutableSymbolMap[Int]
@@ -401,14 +396,14 @@ class DottyPrimitives(ctx: Context) {
     primitives.toMap
   }
 
-  def isPrimitive(fun: Tree): Boolean = {
-    (primitives contains fun.symbol(ctx)) ||
-      (fun.symbol(ctx) == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}}
-       && (fun match {
-        case Select(_, StdNames.nme.clone_) => false // but array.clone is NOT a primitive op.
-        case _ => true
-      }))
-  }
-
+  def isPrimitive(fun: Tree): Boolean =
+    given Context = ictx
+    primitives.contains(fun.symbol)
+    || (fun.symbol == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}}
+        && {
+          fun match
+            case Select(_, StdNames.nme.clone_) => false // but array.clone is NOT a primitive op.
+            case _ => true
+        })
 }
 

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

@@ -64,17 +64,17 @@ class Driver {
   protected def sourcesRequired: Boolean = true
 
   def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
-    val ctx = rootCtx.fresh
-    val summary = CompilerCommand.distill(args)(ctx)
-    ctx.setSettings(summary.sstate)
-    MacroClassLoader.init(ctx)
-    Positioned.updateDebugPos(ctx)
+    val ictx = rootCtx.fresh
+    val summary = CompilerCommand.distill(args)(ictx)
+    ictx.setSettings(summary.sstate)
+    MacroClassLoader.init(ictx)
+    Positioned.updateDebugPos(ictx)
 
-    if (!ctx.settings.YdropComments.value(ctx) || ctx.mode.is(Mode.ReadComments))
-      ctx.setProperty(ContextDoc, new ContextDocstrings)
+    if (!ictx.settings.YdropComments.value(ictx) || ictx.mode.is(Mode.ReadComments))
+      ictx.setProperty(ContextDoc, new ContextDocstrings)
 
-    val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)(ctx)
-    fromTastySetup(fileNames, ctx)
+    val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)(ictx)
+    fromTastySetup(fileNames, ictx)
   }
 
   /** Setup extra classpath and figure out class names for tasty file inputs */

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

@@ -37,7 +37,8 @@ object Definitions {
 class Definitions {
   import Definitions._
 
-  private implicit var ctx: Context = _
+  private var initCtx: Context = _
+  private given [Dummy_to_ensure_its_a_def] as Context = initCtx
 
   private def newSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) =
     ctx.newSymbol(owner, name, flags | Permanent, info)
@@ -1273,8 +1274,9 @@ class Definitions {
    *  types `As`, the result type `B` and a whether the type is an erased context function.
    */
   object ContextFunctionType:
-    def unapply(tp: Type)(using ctx: Context): Option[(List[Type], Type, Boolean)] =
-      if ctx.erasedTypes then unapply(tp)(using ctx.withPhase(ctx.erasurePhase))
+    def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
+      if ctx.erasedTypes then
+        unapply(tp)(using ctx.withPhase(ctx.erasurePhase))
       else
         val tp1 = tp.dealias
         if isContextFunctionClass(tp1.typeSymbol) then
@@ -1427,7 +1429,7 @@ class Definitions {
   private var isInitialized = false
 
   def init()(implicit ctx: Context): Unit = {
-    this.ctx = ctx
+    this.initCtx = ctx
     if (!isInitialized) {
       // Enter all symbols from the scalaShadowing package in the scala package
       for (m <- ScalaShadowingPackage.info.decls)