Rename using Context, CState to using Ctx, CState

This a blind to renming. Fixes in next commit, to better see
what the change set is.

Author: odersky

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

@@ -846,7 +846,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context, CState): Option[String] = {
+  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Ctx, CState): Option[String] = {
     if (needsGenericSignature(sym)) {
       val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol
       if (erasedTypeSym.isPrimitiveValueClass) {
@@ -866,7 +866,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def verifySignature(sym: Symbol, sig: String)(using Context, CState): Unit = {
+  private def verifySignature(sym: Symbol, sig: String)(using Ctx, CState): Unit = {
     import scala.tools.asm.util.CheckClassAdapter
     def wrap(body: => Unit): Unit = {
       try body
@@ -927,7 +927,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     throw new RuntimeException(msg)
   }
 
-  private def compilingArray(using Context, CState) =
+  private def compilingArray(using Ctx, CState) =
     ctx.compilationUnit.source.file.name == "Array.scala"
 }
 

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

@@ -22,7 +22,7 @@ class CollectSuperCalls extends MiniPhase {
 
   def phaseName: String = "collectSuperCalls"
 
-  override def transformSelect(tree: Select)(using Context, CState): Tree = {
+  override def transformSelect(tree: Select)(using Ctx, CState): Tree = {
     tree.qualifier match {
       case sup: Super =>
         if (tree.symbol.owner.is(Trait))
@@ -32,7 +32,7 @@ class CollectSuperCalls extends MiniPhase {
     tree
   }
 
-  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context, CState) = {
+  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Ctx, CState) = {
     genBCodePhase match {
       case genBCodePhase: GenBCode =>
         genBCodePhase.registerSuperCall(sym, calls)

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

@@ -37,7 +37,7 @@ import Annotations.Annotation
 import Names.Name
 
 class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])
-  (using val ctx: Context, val cs: CState) {
+  (using val ctx: Ctx, val cs: CState) {
 
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 
@@ -110,16 +110,16 @@ object DottyBackendInterface {
     else clazz.getName
   }
 
-  def requiredClass(str: String)(using Context, CState): ClassSymbol =
+  def requiredClass(str: String)(using Ctx, CState): ClassSymbol =
     Symbols.requiredClass(str)
 
-  def requiredClass[T](using evidence: ClassTag[T], ctx: Context, cs: CState): Symbol =
+  def requiredClass[T](using evidence: ClassTag[T], ctx: Ctx, cs: CState): Symbol =
     requiredClass(erasureString(evidence.runtimeClass))
 
-  def requiredModule(str: String)(using Context, CState): Symbol =
+  def requiredModule(str: String)(using Ctx, CState): Symbol =
     Symbols.requiredModule(str)
 
-  def requiredModule[T](using evidence: ClassTag[T], ctx: Context, cs: CState): Symbol = {
+  def requiredModule[T](using evidence: ClassTag[T], ctx: Ctx, cs: CState): Symbol = {
     val moduleName = erasureString(evidence.runtimeClass)
     val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
     requiredModule(className)
@@ -128,19 +128,19 @@ object DottyBackendInterface {
   given symExtensions as AnyRef:
     extension (sym: Symbol):
 
-      def isInterface(using Context, CState): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
+      def isInterface(using Ctx, CState): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
 
-      def isStaticConstructor(using Context, CState): Boolean = (sym.isStaticMember && sym.isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
+      def isStaticConstructor(using Ctx, CState): Boolean = (sym.isStaticMember && sym.isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
 
-      def isStaticMember(using Context, CState): Boolean = (sym ne NoSymbol) &&
+      def isStaticMember(using Ctx, CState): Boolean = (sym ne NoSymbol) &&
         (sym.is(JavaStatic) || sym.isScalaStatic)
         // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
       /**
       * True for module classes of modules that are top-level or owned only by objects. Module classes
       * for such objects will get a MODULE$ flag and a corresponding static initializer.
       */
-      def isStaticModuleClass(using Context, CState): Boolean =
+      def isStaticModuleClass(using Ctx, CState): Boolean =
         (sym.is(Module)) && {
           // scalac uses atPickling here
           // this would not work if modules are created after pickling
@@ -154,7 +154,7 @@ object DottyBackendInterface {
 
 
 
-      def originalLexicallyEnclosingClass(using Context, CState): Symbol =
+      def originalLexicallyEnclosingClass(using Ctx, CState): Symbol =
         // used to populate the EnclosingMethod attribute.
         // it is very tricky in presence of classes(and annonymous classes) defined inside supper calls.
         if (sym.exists) {
@@ -168,15 +168,15 @@ object DottyBackendInterface {
       * True for module classes of package level objects. The backend will generate a mirror class for
       * such objects.
       */
-      def isTopLevelModuleClass(using Context, CState): Boolean =
+      def isTopLevelModuleClass(using Ctx, CState): Boolean =
         sym.is(ModuleClass) &&
         atPhase(flattenPhase) {
           toDenot(sym).owner.is(PackageClass)
         }
 
-      def javaSimpleName(using Context, CState): String = toDenot(sym).name.mangledString
-      def javaClassName(using Context, CState): String = toDenot(sym).fullName.mangledString
-      def javaBinaryName(using Context, CState): String = javaClassName.replace('.', '/')
+      def javaSimpleName(using Ctx, CState): String = toDenot(sym).name.mangledString
+      def javaClassName(using Ctx, CState): String = toDenot(sym).fullName.mangledString
+      def javaBinaryName(using Ctx, CState): String = javaClassName.replace('.', '/')
 
     end extension
 
@@ -198,7 +198,7 @@ object DottyBackendInterface {
    * True if the current compilation unit is of a primitive class (scala.Boolean et al).
    * Used only in assertions.
    */
-  def isCompilingPrimitive(using Context, CState) = {
+  def isCompilingPrimitive(using Ctx, CState) = {
     primitiveCompilationUnits(ctx.compilationUnit.source.file.name)
   }
 

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

@@ -43,13 +43,13 @@ class GenBCode extends Phase {
 
   private var myOutput: AbstractFile = _
 
-  private def outputDir(using Context, CState): AbstractFile = {
+  private def outputDir(using Ctx, CState): AbstractFile = {
     if (myOutput eq null)
       myOutput = ctx.settings.outputDir.value
     myOutput
   }
 
-  def run(using Context, CState): Unit =
+  def run(using Ctx, CState): Unit =
     new GenBCodePipeline(
       new DottyBackendInterface(
         outputDir, superCallsMap.toMap
@@ -76,7 +76,7 @@ object GenBCode {
   val name: String = "genBCode"
 }
 
-class GenBCodePipeline(val int: DottyBackendInterface)(using Context, CState) extends BCodeSyncAndTry {
+class GenBCodePipeline(val int: DottyBackendInterface)(using Ctx, CState) extends BCodeSyncAndTry {
   import DottyBackendInterface.symExtensions
 
   private var tree: Tree = _

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

@@ -50,7 +50,7 @@ class DottyPrimitives(ictx: Context, cs: CState) {
    * @param tpe The type of the receiver object. It is used only for array
    *            operations
    */
-  def getPrimitive(app: Apply, tpe: Type)(using Context, CState): Int = {
+  def getPrimitive(app: Apply, tpe: Type)(using Ctx, CState): Int = {
     val fun = app.fun.symbol
     val defn = ctx.definitions
     val code = app.fun match {
@@ -132,7 +132,7 @@ class DottyPrimitives(ictx: Context, cs: CState) {
       primitives(s) = code
     }
 
-    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context, CState): Unit = {
+    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Ctx, CState): Unit = {
       val alts = cls.info.member(method).alternatives.map(_.symbol)
       if (alts.isEmpty)
         report.error(s"Unknown primitive method $cls.$method")

compiler/src/dotty/tools/backend/sjs/GenSJSIR.scala

@@ -8,9 +8,9 @@ import Phases._
 class GenSJSIR extends Phase {
   def phaseName: String = "genSJSIR"
 
-  override def isRunnable(using Context): Boolean =
+  override def isRunnable(using Ctx): Boolean =
     super.isRunnable && ctx.settings.scalajs.value
 
-  def run(using Context, CState): Unit =
+  def run(using Ctx, CState): Unit =
     new JSCodeGen().run()
 }

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -56,7 +56,7 @@ import ScopedVar.withScopedVars
  *  - `genMethod()` and similar methods generate the declarations of methods.
  *  - `genStatOrExpr()` and everything else generate the bodies of methods.
  */
-class JSCodeGen()(using genCtx: Context, cs: CState) {
+class JSCodeGen()(using genCtx: Ctx, cs: CState) {
   import JSCodeGen._
   import tpd._
 
@@ -2733,7 +2733,7 @@ class JSCodeGen()(using genCtx: Context, cs: CState) {
   private def genActualJSArgs(sym: Symbol, args: List[Tree])(
       implicit pos: Position): List[js.TreeOrJSSpread] = {
 
-    def paramNamesAndTypes(using Context, CState): List[(Names.TermName, Type)] =
+    def paramNamesAndTypes(using Ctx, CState): List[(Names.TermName, Type)] =
       sym.info.paramNamess.flatten.zip(sym.info.paramInfoss.flatten)
 
     val wereRepeated = atPhase(elimRepeatedPhase) {