blob: e95ffe02e378c8cee9f51f6bde4d056a3bff113b (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
/*
* Copyright (c) 2014 Contributor. All rights reserved.
*/
package scala.tools.nsc.classpath
import scala.reflect.io.AbstractFile
import scala.tools.nsc.util.{ ClassFileLookup, ClassPath, ClassRepresentation }
/**
* A base trait for the particular flat classpath representation implementations.
*
* We call this variant of a classpath representation flat because it's possible to
* query the whole classpath using just single instance extending this trait.
*
* This is an alternative design compared to scala.tools.nsc.util.ClassPath
*/
trait FlatClassPath extends ClassFileLookup[AbstractFile] {
/** Empty string represents root package */
private[nsc] def packages(inPackage: String): Seq[PackageEntry]
private[nsc] def classes(inPackage: String): Seq[ClassFileEntry]
private[nsc] def sources(inPackage: String): Seq[SourceFileEntry]
/** Allows to get entries for packages and classes merged with sources possibly in one pass. */
private[nsc] def list(inPackage: String): FlatClassPathEntries
// A default implementation which should be overridden, if we can create the more efficient
// solution for a given type of FlatClassPath
override def findClass(className: String): Option[ClassRepresentation[AbstractFile]] = {
val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
val foundClassFromClassFiles = classes(pkg).find(_.name == simpleClassName)
def findClassInSources = sources(pkg).find(_.name == simpleClassName)
foundClassFromClassFiles orElse findClassInSources
}
override def asClassPathString: String = ClassPath.join(asClassPathStrings: _*)
def asClassPathStrings: Seq[String]
}
object FlatClassPath {
val RootPackage = ""
}
case class FlatClassPathEntries(packages: Seq[PackageEntry], classesAndSources: Seq[ClassRepClassPathEntry])
object FlatClassPathEntries {
import scala.language.implicitConversions
// to have working unzip method
implicit def entry2Tuple(entry: FlatClassPathEntries): (Seq[PackageEntry], Seq[ClassRepClassPathEntry]) = (entry.packages, entry.classesAndSources)
}
sealed trait ClassRepClassPathEntry extends ClassRepresentation[AbstractFile]
trait ClassFileEntry extends ClassRepClassPathEntry {
def file: AbstractFile
}
trait SourceFileEntry extends ClassRepClassPathEntry {
def file: AbstractFile
}
trait PackageEntry {
def name: String
}
private[nsc] case class ClassFileEntryImpl(file: AbstractFile) extends ClassFileEntry {
override def name = FileUtils.stripClassExtension(file.name) // class name
override def binary: Option[AbstractFile] = Some(file)
override def source: Option[AbstractFile] = None
}
private[nsc] case class SourceFileEntryImpl(file: AbstractFile) extends SourceFileEntry {
override def name = FileUtils.stripSourceExtension(file.name)
override def binary: Option[AbstractFile] = None
override def source: Option[AbstractFile] = Some(file)
}
private[nsc] case class ClassAndSourceFilesEntry(classFile: AbstractFile, srcFile: AbstractFile) extends ClassRepClassPathEntry {
override def name = FileUtils.stripClassExtension(classFile.name)
override def binary: Option[AbstractFile] = Some(classFile)
override def source: Option[AbstractFile] = Some(srcFile)
}
private[nsc] case class PackageEntryImpl(name: String) extends PackageEntry
private[nsc] trait NoSourcePaths {
def asSourcePathString: String = ""
private[nsc] def sources(inPackage: String): Seq[SourceFileEntry] = Seq.empty
}
private[nsc] trait NoClassPaths {
def findClassFile(className: String): Option[AbstractFile] = None
private[nsc] def classes(inPackage: String): Seq[ClassFileEntry] = Seq.empty
}
|