Abstract over ClassPath and ClassRep

This commit is intended to create the possibility to plug in into
the compiler an alternative classpath representation which would be
possibly more efficient, use less memory etc. Such an implementation
- at least at the beginning - should exist next to the currently
existing one and be possible to turn on using a flag.

Several places in the compiler have a direct dependency on the
classpath implementation. Examples include backend's icode generator
and reader, SymbolLoaders, ClassfileParser. After closer inspection,
one realizes that all those places depend only on a very small subset
of classpath logic: they need to lookup classes from classpath. Hence
there's introduced ClassFileLookup trait that encapsulates that
functionality. The ClassPath extends that trait and an alternative
one also must do it.

There's also added ClassRepresentation - the base trait for ClassRep
(the inner class of ClassPath). Thanks to that the compiler uses
a type which is not directly related to the particular classpath
representation as it was doing until now.

2 files changed, 68 insertions, 17 deletions

diff --git a/src/compiler/scala/tools/nsc/util/ClassFileLookup.scala b/src/compiler/scala/tools/nsc/util/ClassFileLookup.scala
new file mode 100644
index 0000000000..b36580e6c4
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/util/ClassFileLookup.scala
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.util
+
+import scala.tools.nsc.io.AbstractFile
+import java.net.URL
+
+/**
+ * Simple interface that allows us to abstract over how class file lookup is performed
+ * in different classpath representations.
+ */
+// TODO at the end, after the possible removal of the old classpath representation, this class shouldn't be generic
+// T should be just changed to AbstractFile
+trait ClassFileLookup[T] {
+  def findClassFile(name: String): Option[AbstractFile]
+
+  /**
+   * It returns both classes from class file and source files (as our base ClassRepresentation).
+   * So note that it's not so strictly related to findClassFile.
+   */
+  def findClass(name: String): Option[ClassRepresentation[T]]
+
+  /**
+   * A sequence of URLs representing this classpath.
+   */
+  def asURLs: Seq[URL]
+
+  /** The whole classpath in the form of one String.
+    */
+  def asClassPathString: String
+
+  /** The whole sourcepath in the form of one String.
+    */
+  def asSourcePathString: String
+}
+
+/**
+ * Represents classes which can be loaded with a ClassfileLoader and/or SourcefileLoader.
+ */
+// TODO at the end, after the possible removal of the old classpath implementation, this class shouldn't be generic
+// T should be just changed to AbstractFile
+trait ClassRepresentation[T] {
+  def binary: Option[T]
+  def source: Option[AbstractFile]
+
+  def name: String
+}
+
+object ClassRepresentation {
+  def unapply[T](classRep: ClassRepresentation[T]): Option[(Option[T], Option[AbstractFile])] =
+    Some((classRep.binary, classRep.source))
+}
diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala
index e78dee5eee..6c8bd9a59b 100644
--- a/src/compiler/scala/tools/nsc/util/ClassPath.scala
+++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala
@@ -165,9 +165,7 @@ import ClassPath._
 /**
  * Represents a package which contains classes and other packages
  */
-abstract class ClassPath[T] {
-  type AnyClassRep = ClassPath[T]#ClassRep
-
+abstract class ClassPath[T] extends ClassFileLookup[T] {
   /**
    * The short name of the package (without prefix)
    */
@@ -179,10 +177,6 @@ abstract class ClassPath[T] {
    */
   def origin: Option[String] = None
 
-  /** A list of URLs representing this classpath.
-   */
-  def asURLs: List[URL]
-
   /** The whole classpath in the form of one String.
    */
   def asClasspathString: String
@@ -193,7 +187,7 @@ abstract class ClassPath[T] {
 
   /** Lists of entities.
    */
-  def classes: IndexedSeq[AnyClassRep]
+  def classes: IndexedSeq[ClassRepresentation[T]]
   def packages: IndexedSeq[ClassPath[T]]
   def sourcepaths: IndexedSeq[AbstractFile]
 
@@ -217,7 +211,7 @@ abstract class ClassPath[T] {
   /**
    * Represents classes which can be loaded with a ClassfileLoader and/or SourcefileLoader.
    */
-  case class ClassRep(binary: Option[T], source: Option[AbstractFile]) {
+  case class ClassRep(binary: Option[T], source: Option[AbstractFile]) extends ClassRepresentation[T] {
     def name: String = binary match {
       case Some(x)  => context.toBinaryName(x)
       case _        =>
@@ -236,24 +230,28 @@ abstract class ClassPath[T] {
    * Find a ClassRep given a class name of the form "package.subpackage.ClassName".
    * Does not support nested classes on .NET
    */
-  def findClass(name: String): Option[AnyClassRep] =
+  override def findClass(name: String): Option[ClassRepresentation[T]] =
     splitWhere(name, _ == '.', doDropIndex = true) match {
       case Some((pkg, rest)) =>
         val rep = packages find (_.name == pkg) flatMap (_ findClass rest)
         rep map {
-          case x: ClassRep  => x
+          case x: ClassRepresentation[T] => x
           case x            => throw new FatalError("Unexpected ClassRep '%s' found searching for name '%s'".format(x, name))
         }
       case _ =>
         classes find (_.name == name)
     }
 
-  def findClassFile(name: String): Option[AbstractFile] =
+  override def findClassFile(name: String): Option[AbstractFile] =
     findClass(name) match {
-      case Some(ClassRep(Some(x: AbstractFile), _)) => Some(x)
+      case Some(ClassRepresentation(Some(x: AbstractFile), _)) => Some(x)
       case _                                        => None
     }
 
+  override def asClassPathString: String = asClasspathString
+
+  override def asSourcePathString: String = sourcepaths.mkString(pathSeparator)
+
   def sortString = join(split(asClasspathString).sorted: _*)
   override def equals(that: Any) = that match {
     case x: ClassPath[_]  => this.sortString == x.sortString
@@ -352,10 +350,10 @@ extends ClassPath[T] {
   override def origin = Some(entries map (x => x.origin getOrElse x.name) mkString ("Merged(", ", ", ")"))
   override def asClasspathString: String = join(entries map (_.asClasspathString) : _*)
 
-  lazy val classes: IndexedSeq[AnyClassRep] = {
+  lazy val classes: IndexedSeq[ClassRepresentation[T]] = {
     var count   = 0
     val indices = mutable.HashMap[String, Int]()
-    val cls     = new mutable.ArrayBuffer[AnyClassRep](1024)
+    val cls     = new mutable.ArrayBuffer[ClassRepresentation[T]](1024)
 
     for (e <- entries; c <- e.classes) {
       val name = c.name
@@ -364,9 +362,9 @@ extends ClassPath[T] {
         val existing = cls(idx)
 
         if (existing.binary.isEmpty && c.binary.isDefined)
-          cls(idx) = existing.copy(binary = c.binary)
+          cls(idx) = ClassRep(binary = c.binary, source = existing.source)
         if (existing.source.isEmpty && c.source.isDefined)
-          cls(idx) = existing.copy(source = c.source)
+          cls(idx) = ClassRep(binary = existing.binary, source = c.source)
       }
       else {
         indices(name) = count