Clean up impl

Author: aherlihy

Diff for: compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -33,7 +33,11 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
     packageIndex.getOrElseUpdate(pkg.dottedString, aggregates.filter(_.hasPackage(pkg)))
   }
 
-  override def asURLs: Seq[URL] = aggregates.flatMap(_.asURLs)
+  override def asURLs: Seq[URL] =
+    aggregates.flatMap {
+      case v: VirtualDirectoryClassPath => Seq()
+      case a => a.asURLs
+    }
 
   override def asClassPathStrings: Seq[String] = aggregates.map(_.asClassPathString).distinct
 

Diff for: compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -27,14 +27,14 @@ class JavaPlatform extends Platform {
       case _ => false
     })
 
-  def addToClassPath(cPath: ClassPath): Unit = currentClassPath.get match {
+  def addToClassPath(cPath: ClassPath)(using Context): Unit = classPath match {
     case AggregateClassPath(entries) =>
       currentClassPath = Some(AggregateClassPath(entries :+ cPath))
     case cp: ClassPath =>
       currentClassPath = Some(AggregateClassPath(cp :: cPath :: Nil))
   }
   /** Update classpath with a substituted subentry */
-  def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit = currentClassPath.get match {
+  def updateClassPath(subst: Map[ClassPath, ClassPath])(using Context): Unit = classPath match {
     case AggregateClassPath(entries) =>
       currentClassPath = Some(AggregateClassPath(entries map (e => subst.getOrElse(e, e))))
     case cp: ClassPath =>

Diff for: compiler/src/dotty/tools/dotc/config/Platform.scala

@@ -19,8 +19,10 @@ abstract class Platform {
   def classPath(using Context): ClassPath
 
   /** Update classpath with a substitution that maps entries to entries */
-  def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit
-  def addToClassPath(cPath: ClassPath): Unit
+  def updateClassPath(subst: Map[ClassPath, ClassPath])(using Context): Unit
+
+  /** Add new entry to classpath */
+  def addToClassPath(cPath: ClassPath)(using Context): Unit
 
   /** Any platform-specific phases. */
   //def platformPhases: List[SubComponent]

Diff for: compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -36,6 +36,7 @@ import scala.annotation.internal.sharable
 import DenotTransformers.DenotTransformer
 import dotty.tools.dotc.profile.Profiler
 import dotty.tools.dotc.sbt.interfaces.{IncrementalCallback, ProgressCallback}
+import dotty.tools.dotc.classpath.ClassPathFactory
 import util.Property.Key
 import util.Store
 import plugins.*
@@ -918,8 +919,11 @@ object Contexts {
     /** Initializes the `ContextBase` with a starting context.
      *  This initializes the `platform` and the `definitions`.
      */
-    def initialize()(using Context): Unit = {
+    def initialize(previousOutputDir: Option[AbstractFile] = None)(using Context): Unit = {
       _platform = newPlatform
+      previousOutputDir.foreach(cp =>
+        _platform.nn.addToClassPath(ClassPathFactory.newClassPath(cp))
+      )
       definitions.init()
     }
 

Diff for: compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -2220,7 +2220,7 @@ class Definitions {
 
   private var isInitialized = false
 
-  def init()(using Context): Unit = {
+  def init(require: Boolean = false)(using Context): Unit = {
     this.initCtx = ctx
     if (!isInitialized) {
       // force initialization of every symbol that is synthesized or hijacked by the compiler

Diff for: compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -1,16 +1,16 @@
 package dotty.tools.repl
 
 import scala.language.unsafeNulls
-import java.io.{PrintStream, File as JFile}
+import java.io.{File => JFile, PrintStream}
 import java.nio.charset.StandardCharsets
 import dotty.tools.dotc.ast.Trees.*
 import dotty.tools.dotc.ast.{tpd, untpd}
-import dotty.tools.dotc.classpath.{AggregateClassPath, ClassPathFactory, ZipAndJarClassPathFactory}
+import dotty.tools.dotc.classpath.ClassPathFactory
 import dotty.tools.dotc.config.CommandLineParser.tokenize
 import dotty.tools.dotc.config.Properties.{javaVersion, javaVmName, simpleVersionString}
 import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Decorators.*
-import dotty.tools.dotc.core.Phases.{typerPhase, unfusedPhases}
+import dotty.tools.dotc.core.Phases.{unfusedPhases, typerPhase}
 import dotty.tools.dotc.core.Denotations.Denotation
 import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Mode
@@ -94,7 +94,7 @@ class ReplDriver(settings: Array[String],
     initCtx.settings.YwithBestEffortTasty.name
   )
 
-  private def setupRootCtx(settings: Array[String], rootCtx: Context) = {
+  private def setupRootCtx(settings: Array[String], rootCtx: Context, previousOutputDir: Option[AbstractFile] = None) = {
     val incompatible = settings.intersect(incompatibleOptions)
     val filteredSettings =
       if !incompatible.isEmpty then
@@ -107,7 +107,7 @@ class ReplDriver(settings: Array[String],
       case Some((files, ictx)) => inContext(ictx) {
         shouldStart = true
         if files.nonEmpty then out.println(i"Ignoring spurious arguments: $files%, %")
-        ictx.base.initialize()
+        ictx.base.initialize(previousOutputDir)
         ictx
       }
       case None =>
@@ -523,44 +523,49 @@ class ReplDriver(settings: Array[String],
 
         val entries = flatten(jarFile)
 
-        def classNameOf(classFile: AbstractFile): String = {
+        def tryClassLoad(classFile: AbstractFile): Option[String] = {
           val input = classFile.input
           try {
             val reader = new ClassReader(input)
-            reader.getClassName.replace('/', '.')
-          } finally {
+            val clsName = reader.getClassName.replace('/', '.')
+            rendering.myClassLoader.loadClass(clsName)
+            Some(clsName)
+          } catch
+            case _: ClassNotFoundException => None
+          finally {
             input.close()
           }
         }
 
-        def alreadyDefined(clsName: String) = state.context.platform.classPath(using state.context).findClassFile(clsName).isDefined
-        val existingClass = entries.filter(_.ext.isClass).map(classNameOf).find(alreadyDefined)
+        val existingClass = entries.filter(_.ext.isClass).find(tryClassLoad(_).isDefined)
         if (existingClass.nonEmpty)
           out.println(s"The path '$f' cannot be loaded, it contains a classfile that already exists on the classpath: ${existingClass.get}")
           state
         else
           val cp = state.context.platform.classPath(using state.context).asClassPathString
-//          println(s"CURRENT CP STRING: $cp")
           val newCP = s"$cp${JFile.pathSeparator}$path"
-          println(s"UPDATED CP: $newCP")
 
           // add to compiler class path
-//          println(s"INIT state classPath = ${state.context.platform.classPath(using state.context).asClassPathString}")
-//          val cpCP = ClassPathFactory.newClassPath(jarFile)(using state.context)
-//          state.context.platform.addToClassPath(cpCP)
-//          println(s"classPath after add = ${state.context.platform.classPath(using state.context).asClassPathString}")
-
-          // recreate initial context
-          resetToInitial(List("-classpath", newCP))
-//          rootCtx = setupRootCtx(Array(), rootCtx.fresh.setSetting(rootCtx.settings.classpath, newCP))
+          val prevOutputDir = rootCtx.settings.outputDir.valueIn(rootCtx.settingsState)
+          val ctxToUse = initCtx.fresh.setSetting(rootCtx.settings.classpath, newCP)
+          rootCtx = setupRootCtx(
+            Array(),
+            ctxToUse,
+            previousOutputDir = Some(prevOutputDir)
+          )
           val s = state.copy(context = rootCtx)
 
-          // new class loader
-          val oldCL = rendering.classLoader()(using state.context)
-          val newCL = fromURLsParallelCapable(s.context.platform.classPath(using s.context).asURLs, oldCL)
-          rendering.myClassLoader = new AbstractFileClassLoader(state.context.settings.outputDir.default, newCL)
-//          out.println(s"Added '$path' to classpath.")
+          // new class loader with previous output dir and specified jar
+          val prevClassLoader = rendering.classLoader()(using state.context)
+          val jarClassLoader = fromURLsParallelCapable(
+            ClassPathFactory.newClassPath(jarFile)(using rootCtx).asURLs, prevClassLoader)
+          val replOutputClassLoader = new AbstractFileClassLoader(
+            prevOutputDir, jarClassLoader)
+          rendering.myClassLoader = new AbstractFileClassLoader(
+            rootCtx.settings.outputDir.valueIn(rootCtx.settingsState), replOutputClassLoader)
+          out.println(s"Added '$path' to classpath.")
           s
+
     case TypeOf(expr) =>
       expr match {
         case "" => out.println(s":type <expression>")