Expose AbstractFile only in Run

Author: adpi2

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

@@ -32,28 +32,15 @@ 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 doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
+    val files = fileNames.map(ctx.getFile)
+    doCompileFiles(compiler, files)
 
   protected def doCompileFiles(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 =>

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

@@ -124,11 +124,7 @@ 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 =
+  def compile(files: List[AbstractFile]): Unit =
     val sources = files.map(runContext.getSource(_))
     compileSources(sources)
 

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(path: TermName): AbstractFile = base.files.get(path) match
+      case Some(file) =>
+        file
+      case None =>
+        try
+          val file = new PlainFile(Path(path.toString))
+          base.files(path) = file
+          file
+        catch
+          case ex: InvalidPathException =>
+            report.error(s"invalid file path: ${ex.getMessage}")
+            NoAbstractFile
+
+    /** AbstractFile with given path, memoized */
+    def getFile(path: String): AbstractFile = getFile(path.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

@@ -31,7 +31,8 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
     val run = decompiler.newRun(using myInitCtx.fresh.setReporter(reporter))
 
     inContext(run.runContext) {
-      run.compile(List(className))
+      val classFile = ctx.getFile(className)
+      run.compile(List(classFile))
       run.printSummary()
       val unit = ctx.run.units.head
 

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

@@ -2,11 +2,12 @@ package dotty.tools
 package dotc
 package fromtasty
 
+import io.AbstractFile
 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(classFiles: List[AbstractFile]): Unit = {
+    val units = classFiles.map(file => new TASTYCompilationUnit(file.path))
     compileUnits(units)
   }
 }