Change implicit to using

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

@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Symbols._
  * the compiler cake (Global).
  */
 final class BCodeAsmCommon[I <: DottyBackendInterface](val interface: I) {
-  import interface._
+  import interface.{_, given _}
   import DottyBackendInterface.symExtensions
 
   /**

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

@@ -19,6 +19,8 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.Erasure
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
+import dotty.tools.dotc.core.Phases._
 
 /*
  *
@@ -30,7 +32,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
   // import global._
   // import definitions._
   import tpd._
-  import int._
+  import int.{_, given _}
   import DottyBackendInterface.symExtensions
   import bTypes._
   import coreBTypes._
@@ -1460,7 +1462,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       // TODO specialization
       val constrainedType = new MethodBType(lambdaParamTypes.map(p => toTypeKind(p)), toTypeKind(lambdaTarget.info.resultType)).toASMType
 
-      val abstractMethod = ctx.atPhase(ctx.erasurePhase) {
+      val abstractMethod = atPhase(erasurePhase) {
         val samMethods = toDenot(functionalInterface).info.possibleSamMethods.toList
         samMethods match {
           case x :: Nil => x.symbol

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

@@ -13,7 +13,8 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc.core.Annotations._
 import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, atPhase}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Names.Name
@@ -45,7 +46,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   import bTypes._
   import tpd._
   import coreBTypes._
-  import int._
+  import int.{_, given _}
   import DottyBackendInterface._
 
   def ScalaATTRName: String = "Scala"
@@ -360,7 +361,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       val narg = normalizeArgument(arg)
       // Transformation phases are not run on annotation trees, so we need to run
       // `constToLiteral` at this point.
-      val t = constToLiteral(narg)(ctx.withPhase(ctx.erasurePhase))
+      val t = atPhase(erasurePhase)(constToLiteral(narg))
       t match {
         case Literal(const @ Constant(_)) =>
           const.tag match {
@@ -464,7 +465,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   } // end of trait BCAnnotGen
 
   trait BCJGenSigGen {
-    import int._
+    import int.{_, given _}
 
     def getCurrentCUnit(): CompilationUnit
 
@@ -478,7 +479,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
      */
     def getGenericSignature(sym: Symbol, owner: Symbol): String = {
-      ctx.atPhase(ctx.erasurePhase) {
+      atPhase(erasurePhase) {
         val memberTpe =
           if (sym.is(Method)) sym.denot.info
           else owner.denot.thisType.memberInfo(sym)
@@ -844,7 +845,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(implicit ctx: Context): Option[String] = {
+  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context): Option[String] = {
     if (needsGenericSignature(sym)) {
       val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol
       if (erasedTypeSym.isPrimitiveValueClass) {
@@ -864,7 +865,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
   }
 
-  private def verifySignature(sym: Symbol, sig: String)(implicit ctx: Context): Unit = {
+  private def verifySignature(sym: Symbol, sig: String)(using Context): Unit = {
     import scala.tools.asm.util.CheckClassAdapter
     def wrap(body: => Unit): Unit = {
       try body
@@ -913,7 +914,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
     // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
 
-    val memberTpe = ctx.atPhase(ctx.erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
+    val memberTpe = atPhase(erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
     val erasedMemberType = TypeErasure.erasure(memberTpe)
     if (erasedMemberType =:= sym.denot.info)
       getGenericSignatureHelper(sym, moduleClass, memberTpe).orNull

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

@@ -19,7 +19,7 @@ trait BCodeIdiomatic {
   val int: DottyBackendInterface
   final lazy val bTypes = new BTypesFromSymbols[int.type](int)
 
-  import int._
+  import int.{_, given _}
   import bTypes._
   import coreBTypes._
 

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

@@ -26,7 +26,7 @@ import dotty.tools.dotc.util.Spans._
  *
  */
 trait BCodeSkelBuilder extends BCodeHelpers {
-  import int._
+  import int.{_, given _}
   import DottyBackendInterface.{symExtensions, _}
   import tpd._
   import bTypes._

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

@@ -18,7 +18,7 @@ import dotty.tools.dotc.ast.tpd.TreeOps
  *
  */
 trait BCodeSyncAndTry extends BCodeBodyBuilder {
-  import int._
+  import int.{_, given _}
   import tpd._
   import bTypes._
   import coreBTypes._

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

@@ -15,7 +15,7 @@ import scala.tools.asm
 abstract class BTypes {
 
   val int: DottyBackendInterface
-  import int._
+  import int.{_, given _}
   /**
    * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its
    * construction.

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

@@ -8,6 +8,8 @@ import scala.collection.mutable
 import scala.collection.generic.Clearable
 
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
@@ -26,7 +28,7 @@ import dotty.tools.dotc.util.WeakHashSet
  * not have access to the compiler instance.
  */
 class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
-  import int._
+  import int.{_, given _}
   import DottyBackendInterface.{symExtensions, _}
 
   lazy val TransientAttr = requiredClass[scala.transient]
@@ -202,16 +204,16 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
   /** For currently compiled classes: All locally defined classes including local classes.
    *  The empty list for classes that are not currently compiled.
    */
-  private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, ctx.flattenPhase)
+  private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, flattenPhase)
 
   /** For currently compiled classes: All classes that are declared as members of this class
    *  (but not inherited ones). The empty list for classes that are not currently compiled.
    */
-  private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, ctx.lambdaLiftPhase)
+  private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, lambdaLiftPhase)
 
   private def definedClasses(sym: Symbol, phase: Phase) =
     if (sym.isDefinedInCurrentRun)
-      ctx.atPhase(phase) {
+      atPhase(phase) {
         toDenot(sym).info.decls.filter(_.isClass)
       }
     else Nil
@@ -228,10 +230,11 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
         if (innerClassSym.isClass) {
-          val ct = ctx.withPhase(ctx.flattenPhase.prev)
-          toDenot(innerClassSym)(ct).owner.enclosingClass(ct)
+          atPhase(flattenPhase.prev) {
+            toDenot(innerClassSym).owner.enclosingClass
+          }
         }
-        else innerClassSym.enclosingClass(ctx.withPhase(ctx.flattenPhase.prev))
+        else atPhase(flattenPhase.prev)(innerClassSym.enclosingClass)
       } //todo is handled specially for JavaDefined symbols in scalac
 
       val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym)
@@ -255,7 +258,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
         if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
         else {
           val original = innerClassSym.initial
-          Some(innerClassSym.name(ctx.withPhase(original.validFor.phaseId)).mangledString) // moduleSuffix for module classes
+          Some(atPhase(original.validFor.phaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes
         }
       }
 

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

@@ -16,7 +16,7 @@ class FileConflictException(msg: String, val file: AbstractFile) extends IOExcep
  */
 trait BytecodeWriters {
   val int: DottyBackendInterface
-  import int._
+  import int.{_, given _}
 
   /**
    * @param clsName cls.getName

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

@@ -1,7 +1,8 @@
 package dotty.tools.backend.jvm
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, ctx}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Flags.Trait
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
@@ -21,7 +22,7 @@ class CollectSuperCalls extends MiniPhase {
 
   def phaseName: String = "collectSuperCalls"
 
-  override def transformSelect(tree: Select)(implicit ctx: Context): Tree = {
+  override def transformSelect(tree: Select)(using Context): Tree = {
     tree.qualifier match {
       case sup: Super =>
         if (tree.symbol.owner.is(Trait))
@@ -31,8 +32,8 @@ class CollectSuperCalls extends MiniPhase {
     tree
   }
 
-  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(implicit ctx: Context) = {
-    ctx.genBCodePhase match {
+  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context) = {
+    genBCodePhase match {
       case genBCodePhase: GenBCode =>
         genBCodePhase.registerSuperCall(sym, calls)
       case _ =>

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

@@ -33,7 +33,7 @@ import dotty.tools.dotc.transform.Erasure
  */
 class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTypes: BTFS) {
   import bTypes._
-  import int._
+  import int.{_, given _}
   import DottyBackendInterface._
 
   //import global._

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

@@ -34,7 +34,7 @@ import Names.TermName
 import Annotations.Annotation
 import Names.Name
 
-class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])(implicit val ctx: Context) {
+class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
 
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 
@@ -107,10 +107,10 @@ object DottyBackendInterface {
     else clazz.getName
   }
 
-  def requiredClass[T](implicit evidence: ClassTag[T], ctx: Context): Symbol =
+  def requiredClass[T](using evidence: ClassTag[T], ctx: Context): Symbol =
     ctx.requiredClass(erasureString(evidence.runtimeClass))
 
-  def requiredModule[T](implicit evidence: ClassTag[T], ctx: Context): Symbol = {
+  def requiredModule[T](using evidence: ClassTag[T], ctx: Context): Symbol = {
     val moduleName = erasureString(evidence.runtimeClass)
     val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
     ctx.requiredModule(className)
@@ -137,8 +137,9 @@ object DottyBackendInterface {
         // for example by specialization
         val original = toDenot(sym).initial
         val validity = original.validFor
-        val shiftedContext = ctx.withPhase(validity.phaseId)
-        toDenot(sym)(shiftedContext).isStatic(shiftedContext)
+        atPhase(validity.phaseId) {
+          toDenot(sym).isStatic
+        }
       }
 
 
@@ -148,8 +149,9 @@ object DottyBackendInterface {
       // it is very tricky in presence of classes(and annonymous classes) defined inside supper calls.
       if (sym.exists) {
         val validity = toDenot(sym).initial.validFor
-        val shiftedContext = ctx.withPhase(validity.phaseId)
-        toDenot(sym)(shiftedContext).lexicallyEnclosingClass(shiftedContext)
+        atPhase(validity.phaseId) {
+          toDenot(sym).lexicallyEnclosingClass
+        }
       } else NoSymbol
 
     /**
@@ -158,7 +160,7 @@ object DottyBackendInterface {
      */
     def isTopLevelModuleClass(using Context): Boolean =
       sym.is(ModuleClass) &&
-      ctx.atPhase(ctx.flattenPhase) {
+      atPhase(flattenPhase) {
         toDenot(sym).owner.is(PackageClass)
       }
 

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

@@ -15,6 +15,7 @@ import java.util.Optional
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.sbt.ExtractDependencies
 import Contexts._
+import Phases._
 import Symbols._
 import Decorators._
 
@@ -40,18 +41,21 @@ class GenBCode extends Phase {
 
   private var myOutput: AbstractFile = _
 
-  private def outputDir(implicit ctx: Context): AbstractFile = {
+  private def outputDir(using Context): AbstractFile = {
     if (myOutput eq null)
       myOutput = ctx.settings.outputDir.value
     myOutput
   }
 
-  def run(implicit ctx: Context): Unit = {
-    new GenBCodePipeline(new DottyBackendInterface(
-      outputDir, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
-  }
+  def run(using Context): Unit =
+    new GenBCodePipeline(
+      new DottyBackendInterface(
+        outputDir, superCallsMap.toMap
+      )
+    ).run(ctx.compilationUnit.tpdTree)
+
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
     try super.runOn(units)
     finally myOutput match {
       case jar: JarArchive =>
@@ -69,7 +73,7 @@ object GenBCode {
   val name: String = "genBCode"
 }
 
-class GenBCodePipeline(val int: DottyBackendInterface)(implicit ctx: Context) extends BCodeSyncAndTry {
+class GenBCodePipeline(val int: DottyBackendInterface)(using ctx: Context) extends BCodeSyncAndTry {
   import DottyBackendInterface.symExtensions
 
   private var tree: Tree = _
@@ -163,7 +167,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(implicit ctx: Context) ex
             if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
             else (dupClassSym, classSymbol)
           val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
-          ctx.atPhase(ctx.typerPhase) {
+          atPhase(typerPhase) {
             if (same)
               summon[Context].warning( // FIXME: This should really be an error, but then FromTasty tests fail
                 s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
@@ -268,7 +272,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(implicit ctx: Context) ex
 
       // ----------- compiler and sbt's callbacks
 
-      val (fullClassName, isLocal) = ctx.atPhase(ctx.sbtExtractDependenciesPhase) {
+      val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
         (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
       }
 

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(implicit ctx: Context): Boolean =
+  override def isRunnable(using Context): Boolean =
     super.isRunnable && ctx.settings.scalajs.value
 
-  def run(implicit ctx: Context): Unit =
+  def run(using Context): Unit =
     new JSCodeGen().run()
 }