ugly WIP

Author: aherlihy

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

@@ -33,7 +33,7 @@ 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.filter(a => !a.isInstanceOf[VirtualDirectoryClassPath]).flatMap(_.asURLs)
 
   override def asClassPathStrings: Seq[String] = aggregates.map(_.asClassPathString).distinct
 

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

@@ -27,7 +27,7 @@ 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 =>

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

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

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

@@ -33,7 +33,7 @@ object Settings:
     private val changed: mutable.Set[Int] = initialChanged.to(mutable.Set)
     private var _wasRead: Boolean = false
 
-    override def toString: String = s"SettingsState(values: ${values.toList})"
+    override def toString: String = s"SettingsState(values: ${values.toList.zipWithIndex.mkString("[", ",\n\t", "]")})"
 
     def value(idx: Int): Any =
       _wasRead = true

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

@@ -14,31 +14,33 @@ import Uniques.*
 import ast.Trees.*
 import Flags.ParamAccessor
 import ast.untpd
-import util.{NoSource, SimpleIdentityMap, SourceFile, HashSet, ReusableInstance}
-import typer.{Implicits, ImportInfo, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
+import util.{HashSet, NoSource, ReusableInstance, SimpleIdentityMap, SourceFile}
+import typer.{Implicits, ImportInfo, Nullables, SearchHistory, SearchRoot, TypeAssigner, Typer}
 import inlines.Inliner
 import Nullables.*
 import Implicits.ContextualImplicits
 import config.Settings.*
 import config.Config
 import reporting.*
-import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
+import io.{AbstractFile, ClassPath, NoAbstractFile, Path, PlainFile}
+
 import scala.io.Codec
 import collection.mutable
 import printing.*
-import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
+import config.{JavaPlatform, Platform, SJSPlatform, ScalaSettings}
 import classfile.ReusableDataReader
 import StdNames.nme
-import compiletime.uninitialized
 
+import compiletime.uninitialized
 import scala.annotation.internal.sharable
-
 import DenotTransformers.DenotTransformer
+import dotty.tools.dotc.classpath.ClassPathFactory
 import dotty.tools.dotc.profile.Profiler
 import dotty.tools.dotc.sbt.interfaces.{IncrementalCallback, ProgressCallback}
 import util.Property.Key
 import util.Store
 import plugins.*
+
 import java.util.concurrent.atomic.AtomicInteger
 import java.nio.file.InvalidPathException
 
@@ -917,8 +919,12 @@ object Contexts {
     /** Initializes the `ContextBase` with a starting context.
      *  This initializes the `platform` and the `definitions`.
      */
-    def initialize()(using Context): Unit = {
+    def initialize(oldCP: Option[AbstractFile] = None)(using Context): Unit = {
       _platform = newPlatform
+      oldCP.foreach(cp =>
+        _platform.nn.addToClassPath(ClassPathFactory.newClassPath(cp))
+        println(s"adding to CP old outputDir: ${_platform.nn.classPath}")
+      )
       definitions.init()
     }
 

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

@@ -2205,7 +2205,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

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -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, oldCP: 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(oldCP)
         ictx
       }
       case None =>
@@ -537,7 +537,7 @@ class ReplDriver(settings: Array[String],
           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")
+//          println(s"UPDATED CP: $newCP")
 
           // add to compiler class path
 //          println(s"INIT state classPath = ${state.context.platform.classPath(using state.context).asClassPathString}")
@@ -546,15 +546,37 @@ class ReplDriver(settings: Array[String],
 //          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))
+//          resetToInitial(List("-classpath", newCP))
+//          rootCtx = initialCtx(List("-classpath", newCP))
+
+//          println(s"init@7 = ${initCtx.fresh.settings.allSettings(7).name}, value = ${initCtx.fresh.settingsState.value(7)}")
+//          println(s"root@7 = ${rootCtx.fresh.settings.allSettings(7).name}, value = ${rootCtx.fresh.settingsState.value(7)}")
+
+          println(s"settings.outputDir.default = ${rootCtx.settings.outputDir.default}, settingsState.value=${rootCtx.settingsState.value(7)}, ? = ${rootCtx.settings.outputDir.valueIn(rootCtx.settingsState)}")
+          val oldOutputDir = rootCtx.settings.outputDir.valueIn(rootCtx.settingsState)
+          val ctxToUse =
+            initCtx.fresh
+              .setSetting(rootCtx.settings.classpath, newCP)
+//              .setSetting(rootCtx.settings.outputDir, oldOutputDir)
+//            rootCtx.fresh
+//              .setSetting(rootCtx.settings.classpath, newCP)
+//          ctxToUse.platform.addToClassPath(ClassPathFactory.newClassPath(rootCtx.settings.outputDir.default)(using ctxToUse))
+
+          println(s"USED@7 = ${ctxToUse.settings.allSettings(7).name}, value = ${ctxToUse.settingsState.value(7)}")
+          rootCtx = setupRootCtx(
+            Array(),
+            ctxToUse,
+            oldCP = Some(oldOutputDir)
+          )
           val s = state.copy(context = rootCtx)
+//          println(s"VERIFY: ${s.context.platform.classPath(using s.context).hasPackage("mylibrary")}")
 
           // 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.")
+          val innerCL = new AbstractFileClassLoader(oldOutputDir, newCL)
+          rendering.myClassLoader = new AbstractFileClassLoader(s.context.settings.outputDir.default, innerCL)
+          out.println(s"Added '$path' to classpath.")
           s
     case TypeOf(expr) =>
       expr match {