remove recursive classpath implementation

1 files changed, 17 insertions, 103 deletions

diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 847c4cb2d1..7509437e79 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -13,7 +13,7 @@ import java.nio.charset.{Charset, CharsetDecoder, IllegalCharsetNameException, U
 import scala.collection.{immutable, mutable}
 import io.{AbstractFile, Path, SourceReader}
 import reporters.Reporter
-import util.{ClassFileLookup, ClassPath, StatisticsInfo, returning}
+import util.{ClassFileLookup, StatisticsInfo, returning}
 import scala.reflect.ClassTag
 import scala.reflect.internal.util.{BatchSourceFile, NoSourceFile, ScalaClassLoader, ScriptSourceFile, SourceFile}
 import scala.reflect.internal.pickling.PickleBuffer
@@ -54,12 +54,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   class GlobalMirror extends Roots(NoSymbol) {
     val universe: self.type = self
-    def rootLoader: LazyType = {
-      settings.YclasspathImpl.value match {
-        case ClassPathRepresentationType.Flat => new loaders.PackageLoaderUsingFlatClassPath(FlatClassPath.RootPackage, flatClassPath)
-        case ClassPathRepresentationType.Recursive => new loaders.PackageLoader(recursiveClassPath)
-      }
-    }
+    def rootLoader: LazyType = new loaders.PackageLoaderUsingFlatClassPath(FlatClassPath.RootPackage, flatClassPath)
     override def toString = "compiler mirror"
   }
   implicit val MirrorTag: ClassTag[Mirror] = ClassTag[Mirror](classOf[GlobalMirror])
@@ -102,12 +97,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   type ThisPlatform = JavaPlatform { val global: Global.this.type }
   lazy val platform: ThisPlatform  = new GlobalPlatform
 
-  def classPath: ClassFileLookup[AbstractFile] = settings.YclasspathImpl.value match {
-    case ClassPathRepresentationType.Flat => flatClassPath
-    case ClassPathRepresentationType.Recursive => recursiveClassPath
-  }
-
-  private def recursiveClassPath: ClassPath[AbstractFile] = platform.classPath
+  def classPath: ClassFileLookup = platform.flatClassPath
 
   private def flatClassPath: FlatClassPath = platform.flatClassPath
 
@@ -768,17 +758,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   /** Extend classpath of `platform` and rescan updated packages. */
   def extendCompilerClassPath(urls: URL*): Unit = {
-    if (settings.YclasspathImpl.value == ClassPathRepresentationType.Flat) {
-      val urlClasspaths = urls.map(u => FlatClassPathFactory.newClassPath(AbstractFile.getURL(u), settings))
-      val newClassPath = AggregateFlatClassPath.createAggregate(platform.flatClassPath +: urlClasspaths : _*)
-      platform.currentFlatClassPath = Some(newClassPath)
-      invalidateClassPathEntries(urls.map(_.getPath): _*)
-    } else {
-      val newClassPath = platform.classPath.mergeUrlsIntoClassPath(urls: _*)
-      platform.currentClassPath = Some(newClassPath)
-      // Reload all specified jars into this compiler instance
-      invalidateClassPathEntries(urls.map(_.getPath): _*)
-    }
+    val urlClasspaths = urls.map(u => FlatClassPathFactory.newClassPath(AbstractFile.getURL(u), settings))
+    val newClassPath = AggregateFlatClassPath.createAggregate(platform.flatClassPath +: urlClasspaths : _*)
+    platform.currentFlatClassPath = Some(newClassPath)
+    invalidateClassPathEntries(urls.map(_.getPath): _*)
   }
 
   // ------------ Invalidations ---------------------------------
@@ -810,28 +793,26 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
    *                entries on the classpath.
    */
   def invalidateClassPathEntries(paths: String*): Unit = {
-    implicit object ClassPathOrdering extends Ordering[ClassFileLookup[AbstractFile]] {
-      def compare(a:ClassFileLookup[AbstractFile], b:ClassFileLookup[AbstractFile]) = a.asClassPathString compare b.asClassPathString
+    implicit object ClassPathOrdering extends Ordering[FlatClassPath] {
+      def compare(a: FlatClassPath, b: FlatClassPath): Int = a.asClassPathString compareTo b.asClassPathString
     }
     val invalidated, failed = new mutable.ListBuffer[ClassSymbol]
 
-    def assoc(path: String): Option[(ClassFileLookup[AbstractFile], ClassFileLookup[AbstractFile])] = {
-      def origin(lookup: ClassFileLookup[AbstractFile]): Option[String] = lookup match {
-        case cp: ClassPath[_] => cp.origin
+    def assoc(path: String): Option[(FlatClassPath, FlatClassPath)] = {
+      def origin(lookup: ClassFileLookup): Option[String] = lookup match {
         case cp: JFileDirectoryLookup[_] => Some(cp.dir.getPath)
         case cp: ZipArchiveFileLookup[_] => Some(cp.zipFile.getPath)
         case _ => None
       }
 
-      def entries(lookup: ClassFileLookup[AbstractFile]): Seq[ClassFileLookup[AbstractFile]] = lookup match {
-        case cp: ClassPath[_] => cp.entries
+      def entries(lookup: ClassFileLookup): Seq[FlatClassPath] = lookup match {
         case cp: AggregateFlatClassPath => cp.aggregates
         case cp: FlatClassPath => Seq(cp)
       }
 
       val dir = AbstractFile.getDirectory(path) // if path is a `jar`, this is a FileZipArchive (isDirectory is true)
       val canonical = dir.canonicalPath         // this is the canonical path of the .jar
-      def matchesCanonical(e: ClassFileLookup[AbstractFile]) = origin(e) match {
+      def matchesCanonical(e: ClassFileLookup) = origin(e) match {
         case Some(opath) =>
           AbstractFile.getDirectory(opath).canonicalPath == canonical
         case None =>
@@ -839,7 +820,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       }
       entries(classPath) find matchesCanonical match {
         case Some(oldEntry) =>
-          Some(oldEntry -> ClassFileLookup.createForFile(dir, classPath, settings))
+          Some(oldEntry -> FlatClassPathFactory.newClassPath(dir, settings))
         case None =>
           error(s"Error adding entry to classpath. During invalidation, no entry named $path in classpath $classPath")
           None
@@ -849,19 +830,15 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     if (subst.nonEmpty) {
       platform updateClassPath subst
       informProgress(s"classpath updated on entries [${subst.keys mkString ","}]")
-      def mkClassPath(elems: Iterable[ClassFileLookup[AbstractFile]]): ClassFileLookup[AbstractFile] =
+      def mkClassPath(elems: Iterable[FlatClassPath]): FlatClassPath =
         if (elems.size == 1) elems.head
-        else ClassFileLookup.createAggregate(elems, classPath)
+        else AggregateFlatClassPath.createAggregate(elems.toSeq: _*)
       val oldEntries = mkClassPath(subst.keys)
       val newEntries = mkClassPath(subst.values)
       classPath match {
-        case rcp: ClassPath[_] => mergeNewEntriesRecursive(
-          newEntries.asInstanceOf[ClassPath[AbstractFile]], RootClass, Some(rcp), Some(oldEntries.asInstanceOf[ClassPath[AbstractFile]]),
-          invalidated, failed)
-
         case fcp: FlatClassPath => mergeNewEntriesFlat(
           RootClass, "",
-          oldEntries.asInstanceOf[FlatClassPath], newEntries.asInstanceOf[FlatClassPath], fcp,
+          oldEntries, newEntries, fcp,
           invalidated, failed)
       }
     }
@@ -872,69 +849,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     show("could not invalidate system packages", failed)
   }
 
-  /** Merges new classpath entries into the symbol table
-   *
-   *  @param newEntries   The new classpath entries
-   *  @param root         The root symbol to be resynced (a package class)
-   *  @param allEntries   Optionally, the corresponding package in the complete current classpath
-   *  @param oldEntries   Optionally, the corresponding package in the old classpath entries
-   *  @param invalidated  A listbuffer collecting the invalidated package classes
-   *  @param failed       A listbuffer collecting system package classes which could not be invalidated
-   *
-   * The merging strategy is determined by the absence or presence of classes and packages.
-   *
-   * If either oldEntries or newEntries contains classes, root is invalidated provided that a corresponding package
-   * exists in allEntries. Otherwise it is removed.
-   * Otherwise, the action is determined by the following matrix, with columns:
-   *
-   *      old sym   action
-   *       +   +    recurse into all child packages of newEntries
-   *       -   +    invalidate root
-   *       -   -    create and enter root
-   *
-   *  Here, old means classpath, and sym means symboltable. + is presence of an entry in its column, - is absence.
-   */
-  private def mergeNewEntriesRecursive(newEntries: ClassPath[AbstractFile], root: ClassSymbol,
-             allEntries: Option[ClassPath[AbstractFile]], oldEntries: Option[ClassPath[AbstractFile]],
-             invalidated: mutable.ListBuffer[ClassSymbol], failed: mutable.ListBuffer[ClassSymbol]) {
-    ifDebug(informProgress(s"syncing $root, $oldEntries -> $newEntries"))
-
-    val getPackageName: ClassPath[AbstractFile] => String = _.name
-    def hasClasses(cp: Option[ClassPath[AbstractFile]]) = cp.isDefined && cp.get.classes.nonEmpty
-    def invalidateOrRemove(root: ClassSymbol) = {
-      allEntries match {
-        case Some(cp) => root setInfo new loaders.PackageLoader(cp)
-        case None => root.owner.info.decls unlink root.sourceModule
-      }
-      invalidated += root
-    }
-    def subPackage(cp: ClassPath[AbstractFile], name: String): Option[ClassPath[AbstractFile]] =
-      cp.packages find (cp1 => getPackageName(cp1) == name)
-
-    val classesFound = hasClasses(oldEntries) || newEntries.classes.nonEmpty
-    if (classesFound && !isSystemPackageClass(root)) {
-      invalidateOrRemove(root)
-    } else {
-      if (classesFound) {
-        if (root.isRoot) invalidateOrRemove(EmptyPackageClass)
-        else failed += root
-      }
-      if (oldEntries.isEmpty) invalidateOrRemove(root)
-      else
-        for (pstr <- newEntries.packages.map(getPackageName)) {
-          val pname = newTermName(pstr)
-          val pkg = (root.info decl pname) orElse {
-            // package does not exist in symbol table, create symbol to track it
-            assert(subPackage(oldEntries.get, pstr).isEmpty)
-            loaders.enterPackage(root, pstr, new loaders.PackageLoader(allEntries.get))
-          }
-          mergeNewEntriesRecursive(subPackage(newEntries, pstr).get, pkg.moduleClass.asClass,
-                          subPackage(allEntries.get, pstr), subPackage(oldEntries.get, pstr),
-                          invalidated, failed)
-        }
-    }
-  }
-
   /**
    * Merges new classpath entries into the symbol table
    *