Convert other dotc classes (1)

Author: odersky

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

@@ -235,8 +235,8 @@ class JUnitBootstrappers extends MiniPhase {
             if timeoutName.toString == "timeout" => Some(timeoutLiteral)
           case other => {
             val shownName = other match {
-              case NamedArg(name, _) => name.show(ctx)
-              case other => other.show(ctx)
+              case NamedArg(name, _) => name.show(using ctx)
+              case other => other.show(using ctx)
             }
             ctx.error(s"$shownName is an unsupported argument for the JUnit @Test annotation in this position", other.sourcePos)
             None

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

@@ -17,7 +17,7 @@ object Bench extends Driver {
   private def ntimes(n: Int)(op: => Reporter): Reporter =
     (0 until n).foldLeft(emptyReporter)((_, _) => op)
 
-  override def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter =
+  override def doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
     ntimes(numRuns) {
       val start = System.nanoTime()
       val r = super.doCompile(compiler, fileNames)

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

@@ -79,11 +79,11 @@ object CompilationUnit {
   class SuspendException extends Exception
 
   /** Make a compilation unit for top class `clsd` with the contents of the `unpickled` tree */
-  def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
+  def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit =
     apply(new SourceFile(clsd.symbol.associatedFile, Array.empty[Char]), unpickled, forceTrees)
 
   /** Make a compilation unit, given picked bytes and unpickled tree */
-  def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {
+  def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit = {
     assert(!unpickled.isEmpty, unpickled)
     val unit1 = new CompilationUnit(source)
     unit1.tpdTree = unpickled
@@ -98,7 +98,7 @@ object CompilationUnit {
   /** Create a compilation unit corresponding to `source`.
    *  If `mustExist` is true, this will fail if `source` does not exist.
    */
-  def apply(source: SourceFile, mustExist: Boolean = true)(implicit ctx: Context): CompilationUnit = {
+  def apply(source: SourceFile, mustExist: Boolean = true)(using Context): CompilationUnit = {
     val src =
       if (!mustExist)
         source
@@ -117,7 +117,7 @@ object CompilationUnit {
   /** Force the tree to be loaded */
   private class Force extends TreeTraverser {
     var needsStaging = false
-    def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+    def traverse(tree: Tree)(using Context): Unit = {
       if (tree.symbol.isQuote)
         needsStaging = true
       traverseChildren(tree)

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

@@ -138,12 +138,12 @@ class Compiler {
     runId += 1; runId
   }
 
-  def reset()(implicit ctx: Context): Unit = {
+  def reset()(using Context): Unit = {
     ctx.base.reset()
     if (ctx.run != null) ctx.run.reset()
   }
 
-  def newRun(implicit ctx: Context): Run = {
+  def newRun(using Context): Run = {
     reset()
     val rctx =
       if ctx.settings.Ysemanticdb.value

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

@@ -25,13 +25,13 @@ import fromtasty.{TASTYCompiler, TastyFileUtil}
  */
 class Driver {
 
-  protected def newCompiler(implicit ctx: Context): Compiler =
+  protected def newCompiler(using Context): Compiler =
     if (ctx.settings.fromTasty.value) new TASTYCompiler
     else new Compiler
 
   protected def emptyReporter: Reporter = new StoreReporter(null)
 
-  protected def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter =
+  protected def doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
     if (fileNames.nonEmpty)
       try
         val run = compiler.newRun
@@ -191,7 +191,7 @@ class Driver {
    */
   def process(args: Array[String], rootCtx: Context): Reporter = {
     val (fileNames, compileCtx) = setup(args, rootCtx)
-    doCompile(newCompiler(compileCtx), fileNames)(compileCtx)
+    doCompile(newCompiler(using compileCtx), fileNames)(using compileCtx)
   }
 
   def main(args: Array[String]): Unit = {

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

@@ -41,7 +41,7 @@ class Resident extends Driver {
   final override def process(args: Array[String], rootCtx: Context): Reporter = {
     @tailrec def loop(args: Array[String], prevCtx: Context): Reporter = {
       var (fileNames, ctx) = setup(args, prevCtx)
-      doCompile(residentCompiler, fileNames)(ctx)
+      doCompile(residentCompiler, fileNames)(using ctx)
       var nextCtx = ctx
       var line = getLine()
       while (line == reset) {

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

@@ -59,7 +59,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *                 for type checking.
    *    imports      For each element of RootImports, an import context
    */
-  protected def rootContext(implicit ctx: Context): Context = {
+  protected def rootContext(using Context): Context = {
     ctx.initialize()
     ctx.base.setPhasePlan(comp.phases)
     val rootScope = new MutableScope
@@ -80,7 +80,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   private var compiling = false
 
-  private var myCtx = rootContext(ictx)
+  private var myCtx = rootContext(using ictx)
 
   /** The context created for this run */
   given runContext[Dummy_so_its_a_def] as Context = myCtx
@@ -152,7 +152,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     compileUnits()(using ctx)
   }
 
-  private def compileUnits()(implicit ctx: Context) = Stats.maybeMonitored {
+  private def compileUnits()(using Context) = Stats.maybeMonitored {
     if (!ctx.mode.is(Mode.Interactive)) // IDEs might have multi-threaded access, accesses are synchronized
       ctx.base.checkSingleThreaded()
 
@@ -168,7 +168,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.base.usePhases(phases)
 
-    def runPhases(implicit ctx: Context) = {
+    def runPhases(using Context) = {
       var lastPrintedTree: PrintedTree = NoPrintedTree
       val profiler = ctx.profiler
 
@@ -182,7 +182,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
             if (ctx.settings.Xprint.value.containsPhase(phase))
               for (unit <- units)
                 lastPrintedTree =
-                  printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+                  printTree(lastPrintedTree)(using ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
             ctx.informTime(s"$phase ", start)
             Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
             for (unit <- units)
@@ -195,7 +195,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     val runCtx = ctx.fresh
     runCtx.setProfiler(Profiler())
     ctx.phases.foreach(_.initContext(runCtx))
-    runPhases(runCtx)
+    runPhases(using runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
     while (finalizeActions.nonEmpty) {
       val action = finalizeActions.remove(0)
@@ -209,11 +209,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  If `typeCheck = true`, also run typer on the compilation unit, and set
    *  `rootTreeOrProvider`.
    */
-  def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
+  def lateCompile(file: AbstractFile, typeCheck: Boolean)(using Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
       val unit = CompilationUnit(ctx.getSource(file.path))
-      def process()(implicit ctx: Context) = {
+      def process()(using Context) = {
         unit.untpdTree =
           if (unit.isJava) new JavaParser(unit.source).parse()
           else new Parser(unit.source).parse()
@@ -226,18 +226,18 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
         if (typeCheck)
           if (compiling) finalizeActions += (() => processUnit()) else processUnit()
       }
-      process()(runContext.fresh.setCompilationUnit(unit))
+      process()(using runContext.fresh.setCompilationUnit(unit))
     }
 
   private sealed trait PrintedTree
   private /*final*/ case class SomePrintedTree(phase: String, tree: String) extends PrintedTree
   private object NoPrintedTree extends PrintedTree
 
-  private def printTree(last: PrintedTree)(implicit ctx: Context): PrintedTree = {
+  private def printTree(last: PrintedTree)(using Context): PrintedTree = {
     val unit = ctx.compilationUnit
     val prevPhase = ctx.phase.prev // can be a mini-phase
     val squashedPhase = ctx.base.squashed(prevPhase)
-    val treeString = unit.tpdTree.show(ctx.withProperty(XprintMode, Some(())))
+    val treeString = unit.tpdTree.show(using ctx.withProperty(XprintMode, Some(())))
 
     ctx.echo(s"result of $unit after $squashedPhase:")
 

compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala

@@ -16,12 +16,12 @@ class ClassPathFactory {
   /**
     * Create a new classpath based on the abstract file.
     */
-  def newClassPath(file: AbstractFile)(implicit ctx: Context): ClassPath = ClassPathFactory.newClassPath(file)
+  def newClassPath(file: AbstractFile)(using Context): ClassPath = ClassPathFactory.newClassPath(file)
 
   /**
     * Creators for sub classpaths which preserve this context.
     */
-  def sourcesInPath(path: String)(implicit ctx: Context): List[ClassPath] =
+  def sourcesInPath(path: String)(using Context): List[ClassPath] =
     for {
       file <- expandPath(path, expandStar = false)
       dir <- Option(AbstractFile getDirectory file)
@@ -33,25 +33,25 @@ class ClassPathFactory {
 
   def expandDir(extdir: String): List[String] = dotty.tools.io.ClassPath.expandDir(extdir)
 
-  def contentsOfDirsInPath(path: String)(implicit ctx: Context): List[ClassPath] =
+  def contentsOfDirsInPath(path: String)(using Context): List[ClassPath] =
     for {
       dir <- expandPath(path, expandStar = false)
       name <- expandDir(dir)
       entry <- Option(AbstractFile.getDirectory(name))
     }
     yield newClassPath(entry)
 
-  def classesInExpandedPath(path: String)(implicit ctx: Context): IndexedSeq[ClassPath] =
+  def classesInExpandedPath(path: String)(using Context): IndexedSeq[ClassPath] =
     classesInPathImpl(path, expand = true).toIndexedSeq
 
-  def classesInPath(path: String)(implicit ctx: Context): List[ClassPath] = classesInPathImpl(path, expand = false)
+  def classesInPath(path: String)(using Context): List[ClassPath] = classesInPathImpl(path, expand = false)
 
-  def classesInManifest(useManifestClassPath: Boolean)(implicit ctx: Context): List[ClassPath] =
+  def classesInManifest(useManifestClassPath: Boolean)(using Context): List[ClassPath] =
     if (useManifestClassPath) dotty.tools.io.ClassPath.manifests.map(url => newClassPath(AbstractFile getResources url))
     else Nil
 
   // Internal
-  protected def classesInPathImpl(path: String, expand: Boolean)(implicit ctx: Context): List[ClassPath] =
+  protected def classesInPathImpl(path: String, expand: Boolean)(using Context): List[ClassPath] =
     for {
       file <- expandPath(path, expand)
       dir <- {
@@ -61,7 +61,7 @@ class ClassPathFactory {
     }
     yield newClassPath(dir)
 
-  private def createSourcePath(file: AbstractFile)(implicit ctx: Context): ClassPath =
+  private def createSourcePath(file: AbstractFile)(using Context): ClassPath =
     if (file.isJarOrZip)
       ZipAndJarSourcePathFactory.create(file)
     else if (file.isDirectory)
@@ -71,7 +71,7 @@ class ClassPathFactory {
 }
 
 object ClassPathFactory {
-  def newClassPath(file: AbstractFile)(implicit ctx: Context): ClassPath = file match {
+  def newClassPath(file: AbstractFile)(using Context): ClassPath = file match {
     case vd: VirtualDirectory => VirtualDirectoryClassPath(vd)
     case _ =>
       if (file.isJarOrZip)

compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala

@@ -21,7 +21,7 @@ import FileUtils._
 sealed trait ZipAndJarFileLookupFactory {
   private val cache = new FileBasedCache[ClassPath]
 
-  def create(zipFile: AbstractFile)(implicit ctx: Context): ClassPath =
+  def create(zipFile: AbstractFile)(using Context): ClassPath =
     if (ctx.settings.YdisableFlatCpCaching.value || zipFile.file == null) createForZipFile(zipFile)
     else createUsingCache(zipFile)
 

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -19,7 +19,7 @@ class DecompilationPrinter extends Phase {
 
   override def phaseName: String = "decompilationPrinter"
 
-  override def run(implicit ctx: Context): Unit =
+  override def run(using Context): Unit =
     if (ctx.settings.outputDir.isDefault) printToOutput(System.out)
     else {
       val outputDir = ctx.settings.outputDir.value
@@ -36,7 +36,7 @@ class DecompilationPrinter extends Phase {
       }
     }
 
-  private def printToOutput(out: PrintStream)(implicit ctx: Context): Unit = {
+  private def printToOutput(out: PrintStream)(using Context): Unit = {
     val unit = ctx.compilationUnit
     if (ctx.settings.printTasty.value)
       println(new TastyPrinter(unit.pickled.head._2).printContents())