Expose AbstractFile only in Run

Author: adpi2

bench/src/main/scala/Benchmarks.scala

@@ -93,11 +93,11 @@ class CompilerOptions {
 
 class Worker extends Driver {
   // override to avoid printing summary information
-  override  def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter =
+  override  def doCompile(compiler: Compiler, files: List[AbstractFile])(implicit ctx: Context): Reporter =
     if (fileNames.nonEmpty)
       try {
         val run = compiler.newRun
-        run.compile(fileNames)
+        run.compile(files)
         ctx.reporter
       }
       catch {

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

@@ -3,6 +3,7 @@ package dotc
 
 import core.Contexts._
 import reporting.Reporter
+import io.AbstractFile
 
 import scala.annotation.internal.sharable
 
@@ -19,12 +20,12 @@ object Bench extends Driver:
 
   @sharable private var times: Array[Int] = _
 
-  override def doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
+  override def doCompile(compiler: Compiler, files: List[AbstractFile])(using Context): Reporter =
     times = new Array[Int](numRuns)
     var reporter: Reporter = emptyReporter
     for i <- 0 until numRuns do
       val start = System.nanoTime()
-      reporter = super.doCompile(compiler, fileNames)
+      reporter = super.doCompile(compiler, files)
       times(i) = ((System.nanoTime - start) / 1000000).toInt
       println(s"time elapsed: ${times(i)}ms")
       if ctx.settings.Xprompt.value then

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

@@ -9,7 +9,7 @@ import core.Contexts._
 import core.{MacroClassLoader, Mode, TypeError}
 import core.StdNames.nme
 import dotty.tools.dotc.ast.Positioned
-import dotty.tools.io.{File, AbstractFile}
+import dotty.tools.io.AbstractFile
 import reporting._
 import core.Decorators._
 import config.Feature
@@ -32,28 +32,11 @@ class Driver {
 
   protected def emptyReporter: Reporter = new StoreReporter(null)
 
-  protected def doCompile(compiler: Compiler, fileNames: List[String])(using ctx: Context): Reporter =
-    if fileNames.nonEmpty then
-      try
-        val run = compiler.newRun
-        run.compile(fileNames)
-        finish(compiler, run)
-      catch
-        case ex: FatalError =>
-          report.error(ex.getMessage) // signals that we should fail compilation.
-        case ex: TypeError =>
-          println(s"${ex.toMessage} while compiling ${fileNames.mkString(", ")}")
-          throw ex
-        case ex: Throwable =>
-          println(s"$ex while compiling ${fileNames.mkString(", ")}")
-          throw ex
-    ctx.reporter
-
-  protected def doCompileFiles(compiler: Compiler,  files: List[AbstractFile])(using Context): Reporter =
+  protected def doCompile(compiler: Compiler,  files: List[AbstractFile])(using Context): Reporter =
     if files.nonEmpty then
       try
         val run = compiler.newRun
-        run.compileFiles(files)
+        run.compile(files)
         finish(compiler, run)
       catch
         case ex: FatalError =>
@@ -81,7 +64,7 @@ class Driver {
 
   protected def sourcesRequired: Boolean = true
 
-  def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
+  def setup(args: Array[String], rootCtx: Context): (List[AbstractFile], Context) = {
     val ictx = rootCtx.fresh
     val summary = CompilerCommand.distill(args)(using ictx)
     ictx.setSettings(summary.sstate)
@@ -92,43 +75,35 @@ class Driver {
       if !ctx.settings.YdropComments.value || ctx.mode.is(Mode.ReadComments) then
         ictx.setProperty(ContextDoc, new ContextDocstrings)
       val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)
-      fromTastySetup(fileNames, ctx)
+      val files = fileNames.map(ctx.getFile)
+      (files, fromTastySetup(files))
     }
   }
 
-  /** Setup extra classpath and figure out class names for tasty file inputs */
-  protected def fromTastySetup(fileNames0: List[String], ctx0: Context): (List[String], Context) =
-    given Context = ctx0
-    if (ctx0.settings.fromTasty.value) {
-      val fromTastyIgnoreList = ctx0.settings.YfromTastyIgnoreList.value.toSet
-      // Resolve classpath and class names of tasty files
-      val (classPaths, classNames) = fileNames0.flatMap { name =>
-        val path = Paths.get(name)
-        if !Files.exists(path) then
-          report.error(s"File does not exist: $name")
-          Nil
-        else if name.endsWith(".jar") then
-          new dotty.tools.io.Jar(File(name)).toList.collect {
-            case e if e.getName.endsWith(".tasty") && !fromTastyIgnoreList(e.getName) =>
-              (name, e.getName.stripSuffix(".tasty").replace("/", "."))
-          }
-        else if name.endsWith(".tasty") then
-          TastyFileUtil.getClassName(path) match
-            case Some(res) => res :: Nil
+  /** Setup extra classpath of tasty and jar files */
+  protected def fromTastySetup(files: List[AbstractFile])(using Context): Context =
+    if ctx.settings.fromTasty.value then
+      val newEntries: List[String] = files
+        .filter(_.exists)
+        .flatMap { file =>
+          file.extension match
+            case "jar" => Some(file.path)
+            case "tasty" =>
+              TastyFileUtil.getClassPath(file) match
+                case Some(classpath) => Some(classpath)
+                case _ =>
+                  report.error(s"Could not load classname from: ${file.path}")
+                  None
             case _ =>
-              report.error(s"Could not load classname from: $name")
-              Nil
-        else
-          report.error(s"File extension is not `tasty` or `jar`: $name")
-          Nil
-      }.unzip
-      val ctx1 = ctx0.fresh
-      val classPaths1 = classPaths.distinct.filter(_ != "")
-      val fullClassPath = (classPaths1 :+ ctx1.settings.classpath.value(using ctx1)).mkString(java.io.File.pathSeparator)
+              report.error(s"File extension is not `tasty` or `jar`: ${file.path}")
+              None
+        }
+        .distinct
+      val ctx1 = ctx.fresh
+      val fullClassPath =
+        (newEntries :+ ctx.settings.classpath.value).mkString(java.io.File.pathSeparator)
       ctx1.setSetting(ctx1.settings.classpath, fullClassPath)
-      (classNames, ctx1)
-    }
-    else (fileNames0, ctx0)
+    else ctx
 
   /** Entry point to the compiler that can be conveniently used with Java reflection.
    *
@@ -205,8 +180,9 @@ class Driver {
    *                    if compilation succeeded.
    */
   def process(args: Array[String], rootCtx: Context): Reporter = {
-    val (fileNames, compileCtx) = setup(args, rootCtx)
-    doCompile(newCompiler(using compileCtx), fileNames)(using compileCtx)
+    println(getClass.getName)
+    val (files, compileCtx) = setup(args, rootCtx)
+    doCompile(newCompiler(using compileCtx), files)(using compileCtx)
   }
 
   def main(args: Array[String]): Unit = {

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

@@ -40,8 +40,8 @@ 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)
-      inContext(ctx){doCompile(residentCompiler, fileNames)}
+      var (files, ctx) = setup(args, prevCtx)
+      inContext(ctx) { doCompile(residentCompiler, files) }
       var nextCtx = ctx
       var line = getLine()
       while (line == reset) {

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

@@ -124,13 +124,15 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** Actions that need to be performed at the end of the current compilation run */
   private var finalizeActions = mutable.ListBuffer[() => Unit]()
 
-  def compile(fileNames: List[String]): Unit =
-    val sources = fileNames.map(runContext.getSource(_))
-    compileSources(sources)
-
-  def compileFiles(files: List[AbstractFile]): Unit =
-    val sources = files.map(runContext.getSource(_))
-    compileSources(sources)
+  def compile(files: List[AbstractFile]): Unit =
+    try
+      val sources = files.map(runContext.getSource(_))
+      compileSources(sources)
+    catch
+      case NonFatal(ex) =>
+        if units != null then report.echo(i"exception occurred while compiling $units%, %")
+        else report.echo(s"exception occurred while compiling ${files.map(_.name).mkString(", ")}")
+        throw ex
 
   /** TODO: There's a fundamental design problem here: We assemble phases using `fusePhases`
    *  when we first build the compiler. But we modify them with -Yskip, -Ystop
@@ -139,15 +141,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  account. I think the latter would be preferable.
    */
   def compileSources(sources: List[SourceFile]): Unit =
-    try
-      if sources forall (_.exists) then
-        units = sources.map(CompilationUnit(_))
-        compileUnits()
-    catch
-      case NonFatal(ex) =>
-        if units != null then report.echo(i"exception occurred while compiling $units%, %")
-        else report.echo(s"exception occurred while compiling ${sources.map(_.name).mkString(", ")}")
-        throw ex
+    if (sources forall (_.exists)) {
+      units = sources.map(CompilationUnit(_))
+      compileUnits()
+    }
+
 
   def compileUnits(us: List[CompilationUnit]): Unit = {
     units = us

compiler/src/dotty/tools/dotc/config/CompilerCommand.scala

@@ -33,7 +33,7 @@ object CompilerCommand {
 
   def versionMsg: String = s"Scala compiler $versionString -- $copyrightString"
 
-  def shouldStopWithInfo(using ctx: Context) = {
+  def shouldStopWithInfo(using Context): Boolean = {
     val settings = ctx.settings
     import settings._
     Set(help, Xhelp, Yhelp, showPlugins, XshowPhases) exists (_.value)

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

@@ -266,25 +266,36 @@ object Contexts {
       base.sources.getOrElseUpdate(file, new SourceFile(file, codec))
     }
 
-    /** Sourcefile with given path name, memoized */
-    def getSource(path: TermName): SourceFile = base.sourceNamed.get(path) match {
+    /** SourceFile with given path name, memoized */
+    def getSource(path: TermName): SourceFile = base.sourceNamed.get(path) match
       case Some(source) =>
         source
-      case None => try {
-        val f = new PlainFile(Path(path.toString))
-        val src = getSource(f)
-        base.sourceNamed(path) = src
-        src
-      } catch {
-        case ex: InvalidPathException =>
-          report.error(s"invalid file path: ${ex.getMessage}")
-          NoSource
-      }
-    }
+      case None =>
+        getFile(path) match
+          case NoAbstractFile => NoSource
+          case file => getSource(file)
 
-    /** Sourcefile with given path, memoized */
+    /** SourceFile with given path, memoized */
     def getSource(path: String): SourceFile = getSource(path.toTermName)
 
+    /** AbstraFile with given path name, memoized */
+    def getFile(name: TermName): AbstractFile = base.files.get(name) match
+      case Some(file) =>
+        file
+      case None =>
+        try
+          val file = new PlainFile(Path(name.toString))
+          base.files(name) = file
+          file
+        catch
+          case ex: InvalidPathException =>
+            report.error(s"invalid file path: ${ex.getMessage}")
+            NoAbstractFile
+
+    /** AbstractFile with given path, memoized */
+    def getFile(name: String): AbstractFile = getFile(name.toTermName)
+
+
     private var related: SimpleIdentityMap[Phase | SourceFile, Context] = null
 
     private def lookup(key: Phase | SourceFile): Context =
@@ -842,9 +853,10 @@ object Contexts {
     private var _nextSymId: Int = 0
     def nextSymId: Int = { _nextSymId += 1; _nextSymId }
 
-    /** Sources that were loaded */
+    /** Sources and Files that were loaded */
     val sources: util.HashMap[AbstractFile, SourceFile] = util.HashMap[AbstractFile, SourceFile]()
     val sourceNamed: util.HashMap[TermName, SourceFile] = util.HashMap[TermName, SourceFile]()
+    val files: util.HashMap[TermName, AbstractFile] = util.HashMap()
 
     // Types state
     /** A table for hash consing unique types */
@@ -929,6 +941,7 @@ object Contexts {
       errorTypeMsg.clear()
       sources.clear()
       sourceNamed.clear()
+      files.clear()
       comparers.clear()  // forces re-evaluation of top and bottom classes in TypeComparer
 
     // Test that access is single threaded

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

@@ -6,6 +6,7 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.core.tasty.TastyHTMLPrinter
 import dotty.tools.dotc.reporting._
+import dotty.tools.io.AbstractFile
 
 import scala.quoted.runtime.impl.QuotesImpl
 
@@ -25,13 +26,13 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
 
   private val decompiler = new PartialTASTYDecompiler
 
-  def run(className: String): (String, String) = {
+  def run(tastyFile: AbstractFile): (String, String) = {
     val reporter = new StoreReporter(null) with HideNonSensicalMessages
 
     val run = decompiler.newRun(using myInitCtx.fresh.setReporter(reporter))
 
     inContext(run.runContext) {
-      run.compile(List(className))
+      run.compile(List(tastyFile))
       run.printSummary()
       val unit = ctx.run.units.head
 

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

@@ -4,6 +4,7 @@ import java.nio.file.Files
 
 import dotty.tools.dotc
 import dotty.tools.dotc.core.Contexts._
+import dotty.tools.io.AbstractFile
 
 /** Main class of the `dotc -decompiler` decompiler.
  *
@@ -17,7 +18,7 @@ object Main extends dotc.Driver {
     new TASTYDecompiler
   }
 
-  override def setup(args0: Array[String], rootCtx: Context): (List[String], Context) = {
+  override def setup(args0: Array[String], rootCtx: Context): (List[AbstractFile], Context) = {
     var args = args0.filter(a => a != "-decompile")
     if (!args.contains("-from-tasty")) args = "-from-tasty" +: args
     if (args.contains("-d")) args = "-color:never" +: args

compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala

@@ -2,11 +2,29 @@ package dotty.tools
 package dotc
 package fromtasty
 
+import io.{JarArchive, AbstractFile, Path}
 import core.Contexts._
 
 class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
-  override def compile(classNames: List[String]): Unit = {
-    val units = classNames.map(new TASTYCompilationUnit(_))
+  override def compile(files: List[AbstractFile]): Unit = {
+    val units = tastyUnits(files)
     compileUnits(units)
   }
+
+  private def tastyUnits(files: List[AbstractFile]): List[TASTYCompilationUnit] =
+    val fromTastyIgnoreList = ctx.settings.YfromTastyIgnoreList.value.toSet
+    // Resolve class names of tasty and jar files
+    val classNames = files.flatMap { file =>
+      file.extension match
+        case "jar" =>
+          JarArchive.open(Path(file.path), create = false).iterator()
+            .filter(e => e.extension == "tasty" && !fromTastyIgnoreList(e.name))
+            .map(e => e.name.stripSuffix(".tasty").replace("/", "."))
+            .toList
+        case "tasty" => TastyFileUtil.getClassName(file)
+        case _ =>
+          report.error(s"File extension is not `tasty` or `jar`: ${file.path}")
+          Nil
+    }
+    classNames.map(new TASTYCompilationUnit(_))
 }