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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/* NSC -- new Scala compiler
* Copyright 2005-2009 LAMP/EPFL
* @author Martin Odersky
*/
// $Id$
package scala.tools.nsc
package interactive
import scala.collection._
import scala.tools.nsc.reporters.{Reporter, ConsoleReporter}
import scala.util.control.Breaks._
import dependencies._
import util.FakePos
import io.AbstractFile
/** A more defined build manager, based on change sets. For each
* updated source file, it computes the set of changes to its
* definitions, then checks all dependent units to see if the
* changes require a compilation. It repeats this process until
* a fixpoint is reached.
*/
class RefinedBuildManager(val settings: Settings) extends Changes with BuildManager {
class BuilderGlobal(settings: Settings, reporter : Reporter) extends scala.tools.nsc.Global(settings, reporter) {
def this(settings: Settings) =
this(settings, new ConsoleReporter(settings))
override def computeInternalPhases() {
super.computeInternalPhases
phasesSet += dependencyAnalysis
}
def newRun() = new Run()
}
protected def newCompiler(settings: Settings) = new BuilderGlobal(settings)
val compiler = newCompiler(settings)
import compiler.Symbol
/** Managed source files. */
private val sources: mutable.Set[AbstractFile] = new mutable.HashSet[AbstractFile]
private val definitions: mutable.Map[AbstractFile, List[Symbol]] =
new mutable.HashMap[AbstractFile, List[Symbol]] {
override def default(key: AbstractFile) = Nil
}
/** External references used by source file. */
private var references: mutable.Map[AbstractFile, immutable.Set[String]] = _
/** Add the given source files to the managed build process. */
def addSourceFiles(files: Set[AbstractFile]) {
sources ++= files
update(files)
}
/** Remove the given files from the managed build process. */
def removeFiles(files: Set[AbstractFile]) {
sources --= files
deleteClassfiles(files)
update(invalidatedByRemove(files))
}
/** Return the set of invalidated files caused by removing the given files.
*/
private def invalidatedByRemove(files: Set[AbstractFile]): Set[AbstractFile] = {
val changes = new mutable.HashMap[Symbol, List[Change]]
for (f <- files; sym <- definitions(f))
changes += sym -> List(Removed(Class(sym.fullNameString)))
invalidated(files, changes)
}
def update(added: Set[AbstractFile], removed: Set[AbstractFile]) {
sources --= removed
deleteClassfiles(removed)
update(added ++ invalidatedByRemove(removed))
}
/** The given files have been modified by the user. Recompile
* them and all files that depend on them. Only files that
* have been previously added as source files are recompiled.
* Files that were already compiled are taken out from the result
* of the dependency analysis.
*/
private def update(files: Set[AbstractFile]) = {
def update0(files: Set[AbstractFile], updated: Set[AbstractFile]): Unit = if (!files.isEmpty) {
deleteClassfiles(files)
val run = compiler.newRun()
compiler.inform("compiling " + files)
buildingFiles(files)
run.compileFiles(files.toList)
if (compiler.reporter.hasErrors) {
compiler.reporter.reset
return
}
val changesOf = new mutable.HashMap[Symbol, List[Change]]
val additionalDefs: mutable.HashSet[AbstractFile] = mutable.HashSet.empty
val defs = compiler.dependencyAnalysis.definitions
for (src <- files) {
if (definitions(src).isEmpty)
additionalDefs ++= compiler.dependencyAnalysis.
dependencies.dependentFiles(1, mutable.Set(src))
else {
val syms = defs(src)
for (sym <- syms) {
definitions(src).find(_.fullNameString == sym.fullNameString) match {
case Some(oldSym) =>
changesOf(oldSym) = changeSet(oldSym, sym)
case _ =>
// a new top level definition, no need to process
}
}
}
}
println("Changes: " + changesOf)
updateDefinitions(files)
val compiled = updated ++ files
additionalDefs -- compiled
update0(invalidated(files, changesOf) ++ additionalDefs, compiled)
}
update0(files, immutable.Set())
}
/** Return the set of source files that are invalidated by the given changes. */
def invalidated(files: Set[AbstractFile], changesOf: collection.Map[Symbol, List[Change]]): Set[AbstractFile] = {
val buf = new mutable.HashSet[AbstractFile]
var directDeps =
compiler.dependencyAnalysis.dependencies.dependentFiles(1, files)
// println("direct dependencies on " + files + " " + directDeps)
def invalidate(file: AbstractFile, reason: String, change: Change) = {
println("invalidate " + file + " because " + reason + " [" + change + "]")
buf += file
directDeps -= file
break
}
for ((oldSym, changes) <- changesOf; change <- changes) {
def checkParents(cls: Symbol, file: AbstractFile) {
val parentChange = cls.info.parents.exists(_.typeSymbol.fullNameString == oldSym.fullNameString)
// println("checkParents " + cls + " oldSym: " + oldSym + " parentChange: " + parentChange + " " + cls.info.parents)
change match {
case Changed(Class(_)) if parentChange =>
invalidate(file, "parents have changed", change)
case Changed(Definition(_)) if parentChange =>
invalidate(file, "inherited method changed", change)
case Added(Definition(_)) if parentChange =>
invalidate(file, "inherited new method", change)
case Removed(Definition(_)) if parentChange =>
invalidate(file, "inherited method removed", change)
case _ => ()
}
}
def checkInterface(cls: Symbol, file: AbstractFile) {
change match {
case Added(Definition(name)) =>
if (cls.info.decls.iterator.exists(_.fullNameString == name))
invalidate(file, "of new method with existing name", change)
case Changed(Class(name)) =>
if (cls.info.typeSymbol.fullNameString == name)
invalidate(file, "self type changed", change)
case _ =>
()
}
}
def checkReferences(file: AbstractFile) {
// println(file + ":" + references(file))
val refs = references(file)
if (refs.isEmpty)
invalidate(file, "it is a direct dependency and we don't yet have finer-grained dependency information", change)
else {
change match {
case Removed(Definition(name)) if refs(name) =>
invalidate(file, "it references deleted definition", change)
case Removed(Class(name)) if (refs(name)) =>
invalidate(file, "it references deleted class", change)
case Changed(Definition(name)) if (refs(name)) =>
invalidate(file, "it references changed definition", change)
case _ => ()
}
}
}
breakable {
for (file <- directDeps) {
for (cls <- definitions(file)) checkParents(cls, file)
for (cls <- definitions(file)) checkInterface(cls, file)
checkReferences(file)
}
}
}
buf
}
/** Update the map of definitions per source file */
private def updateDefinitions(files: Set[AbstractFile]) {
for (src <- files; val localDefs = compiler.dependencyAnalysis.definitions(src)) {
definitions(src) = (localDefs map (_.cloneSymbol))
}
this.references = compiler.dependencyAnalysis.references
}
/** Load saved dependency information. */
def loadFrom(file: AbstractFile, toFile: String => AbstractFile) : Boolean = {
val success = compiler.dependencyAnalysis.loadFrom(file, toFile)
if (success)
sources ++= compiler.dependencyAnalysis.managedFiles
success
}
/** Save dependency information to `file'. */
def saveTo(file: AbstractFile, fromFile: AbstractFile => String) {
compiler.dependencyAnalysis.dependenciesFile = file
compiler.dependencyAnalysis.saveDependencies(fromFile)
}
}
|
