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
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
|
package scala.tools.nsc.interactive
import java.io.{ PrintWriter, StringWriter }
import scala.collection.mutable.{LinkedHashMap, SynchronizedMap}
import scala.concurrent.SyncVar
import scala.util.control.ControlException
import scala.tools.nsc.io.AbstractFile
import scala.tools.nsc.util.{SourceFile, Position, RangePosition, OffsetPosition, NoPosition, WorkScheduler}
import scala.tools.nsc.reporters._
import scala.tools.nsc.symtab._
import scala.tools.nsc.ast._
/** The main class of the presentation compiler in an interactive environment such as an IDE
*/
class Global(settings: Settings, reporter: Reporter)
extends nsc.Global(settings, reporter)
with CompilerControl
with RangePositions
with ContextTrees
with RichCompilationUnits {
self =>
import definitions._
override def onlyPresentation = true
/** A list indicating in which order some units should be typechecked.
* All units in firsts are typechecked before any unit not in this list
* Modified by askToDoFirst, reload, typeAtTree.
*/
var firsts: List[SourceFile] = List()
/** A map of all loaded files to the rich compilation units that correspond to them.
*/
val unitOfFile = new LinkedHashMap[AbstractFile, RichCompilationUnit] with
SynchronizedMap[AbstractFile, RichCompilationUnit]
/** The currently active typer run */
private var currentTyperRun: TyperRun = _
/** Is a background compiler run needed? */
private var outOfDate = false
/** Is a reload/background compiler currently running? */
private var acting = false
/** The status value of a unit that has not yet been loaded */
final val NotLoaded = -1
/** The status value of a unit that has not yet been typechecked */
final val JustParsed = 0
// ----------- Overriding hooks in nsc.Global -----------------------
/** Called from typechecker, which signal hereby that a node has been completely typechecked.
* If the node is included in unit.targetPos, abandons run and returns newly attributed tree.
* Otherwise, if there's some higher priority work to be done, also abandons run with a FreshRunReq.
* @param context The context that typechecked the node
* @param old The original node
* @param result The transformed node
*/
override def signalDone(context: Context, old: Tree, result: Tree) {
def integrateNew() {
context.unit.body = new TreeReplacer(old, result) transform context.unit.body
}
if (activeLocks == 0) {
if (context.unit != null &&
!result.pos.isSynthetic &&
!isTransparent(result.pos) &&
(result.pos includes context.unit.targetPos)) {
integrateNew()
var located = new Locator(context.unit.targetPos) locateIn result
if (located == EmptyTree) {
println("something's wrong: no "+context.unit+" in "+result+result.pos)
located = result
}
throw new TyperResult(located)
}
val typerRun = currentTyperRun
while(true)
try {
pollForWork()
if (typerRun == currentTyperRun)
return
integrateNew()
throw new FreshRunReq
} catch {
case ex : ValidateError => // Ignore, this will have been reported elsewhere
case t : Throwable => throw t
}
}
}
/** Called from typechecker every time a context is created.
* Registers the context in a context tree
*/
override def registerContext(c: Context) = c.unit match {
case u: RichCompilationUnit => addContext(u.contexts, c)
case _ =>
}
// ----------------- Polling ---------------------------------------
/** Called from runner thread and signalDone:
* Poll for exeptions.
* Poll for work reload/typedTreeAt/doFirst commands during background checking.
*/
def pollForWork() {
scheduler.pollException() match {
case Some(ex: CancelActionReq) => if (acting) throw ex
case Some(ex: FreshRunReq) => if (outOfDate) throw ex
case Some(ex: Throwable) => throw ex
case _ =>
}
scheduler.nextWorkItem() match {
case Some(action) =>
try {
acting = true
println("picked up work item: "+action)
action()
println("done with work item: "+action)
} catch {
case ex: CancelActionReq =>
println("cancelled work item: "+action)
} finally {
println("quitting work item: "+action)
acting = false
}
case None =>
}
}
def debugInfo(source : SourceFile, start : Int, length : Int): String = {
println("DEBUG INFO "+source+"/"+start+"/"+length)
val end = start+length
val pos = rangePos(source, start, start, end)
val tree = locateTree(pos)
val sw = new StringWriter
val pw = new PrintWriter(sw)
treePrinters.create(pw).print(tree)
pw.flush
val typed = new Response[Tree]
askTypeAt(pos, typed)
val typ = typed.get.left.toOption match {
case Some(tree) =>
val sw = new StringWriter
val pw = new PrintWriter(sw)
treePrinters.create(pw).print(tree)
pw.flush
sw.toString
case None => "<None>"
}
val completionResponse = new Response[List[Member]]
askCompletion(pos, completionResponse)
val completion = completionResponse.get.left.toOption match {
case Some(members) =>
members mkString "\n"
case None => "<None>"
}
source.content.view.drop(start).take(length).mkString+" : "+source.path+" ("+start+", "+end+
")\n\nlocateTree:\n"+sw.toString+"\n\naskTypeAt:\n"+typ+"\n\ncompletion:\n"+completion
}
// ----------------- The Background Runner Thread -----------------------
/** The current presentation compiler runner */
private var compileRunner = newRunnerThread
/** Create a new presentation compiler runner.
*/
def newRunnerThread: Thread = new Thread("Scala Presentation Compiler") {
override def run() {
try {
while (true) {
scheduler.waitForMoreWork()
pollForWork()
while (outOfDate) {
try {
backgroundCompile()
outOfDate = false
} catch {
case ex: FreshRunReq =>
}
}
}
} catch {
case ex: ShutdownReq =>
;
case ex =>
ex.printStackTrace()
outOfDate = false
inform("Fatal Error: "+ex)
compileRunner = newRunnerThread
}
}
start()
}
/** Compile all given units
*/
private def backgroundCompile() {
inform("Starting new presentation compiler type checking pass")
reporter.reset
firsts = firsts filter (s => unitOfFile contains (s.file))
val prefix = firsts map unitOf
val units = prefix ::: (unitOfFile.values.toList diff prefix)
recompile(units)
inform("Everything is now up to date")
}
/** Reset unit to just-parsed state */
def reset(unit: RichCompilationUnit): Unit =
if (unit.status > JustParsed) {
unit.depends.clear()
unit.defined.clear()
unit.synthetics.clear()
unit.toCheck.clear()
unit.targetPos = NoPosition
unit.contexts.clear()
unit.body = EmptyTree
unit.status = NotLoaded
}
/** Parse unit and create a name index. */
def parse(unit: RichCompilationUnit): Unit = {
currentTyperRun.compileLate(unit)
validatePositions(unit.body)
//println("parsed: [["+unit.body+"]]")
unit.status = JustParsed
}
/** Make sure symbol and type attributes are reset and recompile units.
*/
def recompile(units: List[RichCompilationUnit]) {
for (unit <- units) {
reset(unit)
inform("parsing: "+unit)
parse(unit)
}
for (unit <- units) {
inform("type checking: "+unit)
activeLocks = 0
currentTyperRun.typeCheck(unit)
unit.status = currentRunId
}
}
/** Move list of files to front of firsts */
def moveToFront(fs: List[SourceFile]) {
firsts = fs ::: (firsts diff fs)
}
// ----------------- Implementations of client commmands -----------------------
def respond[T](result: Response[T])(op: => T): Unit = try {
result set Left(op)
} catch {
case ex =>
result set Right(ex)
throw ex
}
/** Make sure a set of compilation units is loaded and parsed */
def reloadSources(sources: List[SourceFile]) {
currentTyperRun = new TyperRun()
for (source <- sources) {
val unit = new RichCompilationUnit(source)
unitOfFile(source.file) = unit
parse(unit)
if (settings.Xprintpos.value) treePrinter.print(unit)
}
moveToFront(sources)
}
/** Make sure a set of compilation units is loaded and parsed */
def reload(sources: List[SourceFile], result: Response[Unit]) {
respond(result)(reloadSources(sources))
if (outOfDate) throw new FreshRunReq
else outOfDate = true
}
/** A fully attributed tree located at position `pos` */
def typedTreeAt(pos: Position): Tree = {
val unit = unitOf(pos)
val sources = List(unit.source)
if (unit.status == NotLoaded) reloadSources(sources)
moveToFront(sources)
val typedTree = currentTyperRun.typedTreeAt(pos)
new Locator(pos) locateIn typedTree
}
/** Set sync var `result` to a fully attributed tree located at position `pos` */
def getTypedTreeAt(pos: Position, result: Response[Tree]) {
respond(result)(typedTreeAt(pos))
}
def stabilizedType(tree: Tree): Type = tree match {
case Ident(_) if tree.symbol.isStable => singleType(NoPrefix, tree.symbol)
case Select(qual, _) if tree.symbol.isStable => singleType(qual.tpe, tree.symbol)
case _ => tree.tpe
}
import analyzer.{SearchResult, ImplicitSearch}
def completion(pos: Position, result: Response[List[Member]]) {
respond(result) {
val tree = typedTreeAt(pos)
locateContext(pos) match {
case Some(context) =>
val superAccess = tree.isInstanceOf[Super]
val pre = stabilizedType(tree)
def member(sym: Symbol, inherited: Boolean) = new Member(
sym,
pre memberType sym,
context.isAccessible(sym, pre, superAccess),
inherited,
NoSymbol
)
def implicitMembers(s: SearchResult): List[Member] = {
val vtree = viewApply(s, tree, context)
val vpre = stabilizedType(vtree)
vtree.tpe.members map { sym => new Member(
sym,
vpre memberType sym,
context.isAccessible(sym, vpre, false),
false,
s.tree.symbol
)}
}
println("completion at "+tree+" "+tree.tpe)
val decls = tree.tpe.decls.toList map (member(_, false))
val inherited = tree.tpe.members.toList diff decls map (member(_, true))
val implicits = applicableViews(tree, context) flatMap implicitMembers
def isVisible(m: Member) =
!(decls exists (_.shadows(m))) && !(inherited exists (_.shadows(m)))
decls ::: inherited ::: (implicits filter isVisible)
case None =>
throw new FatalError("no context found for "+pos)
}
}
}
def applicableViews(tree: Tree, context: Context): List[SearchResult] =
new ImplicitSearch(tree, functionType(List(tree.tpe), AnyClass.tpe), true, context.makeImplicit(false))
.allImplicits
def viewApply(view: SearchResult, tree: Tree, context: Context): Tree = {
assert(view.tree != EmptyTree)
try {
analyzer.newTyper(context.makeImplicit(false)).typed(Apply(view.tree, List(tree)) setPos tree.pos)
} catch {
case ex: TypeError => EmptyTree
}
}
// ---------------- Helper classes ---------------------------
/** A transformer that replaces tree `from` with tree `to` in a given tree */
class TreeReplacer(from: Tree, to: Tree) extends Transformer {
override def transform(t: Tree): Tree = {
if (t == from) to
else if ((t.pos includes from.pos) || isTransparent(t.pos)) super.transform(t)
else t
}
}
/** A traverser that resets all type and symbol attributes in a tree
object ResetAttrs extends Transformer {
override def transform(t: Tree): Tree = {
if (t.hasSymbol) t.symbol = NoSymbol
t match {
case EmptyTree =>
t
case tt: TypeTree =>
if (tt.original != null) tt.original
else t
case _ =>
t.tpe = null
super.transform(t)
}
}
}
*/
/** The typer run */
class TyperRun extends Run {
// units is always empty
// symSource, symData are ignored
override def compiles(sym: Symbol) = false
def typeCheck(unit: CompilationUnit): Unit = applyPhase(typerPhase, unit)
def enterNames(unit: CompilationUnit): Unit = applyPhase(namerPhase, unit)
/** Return fully attributed tree at given position
* (i.e. largest tree that's contained by position)
*/
def typedTreeAt(pos: Position): Tree = {
println("starting typedTreeAt")
val tree = locateTree(pos)
println("at pos "+pos+" was found: "+tree+tree.pos.show)
if (tree.tpe ne null) {
println("already attributed")
tree
} else {
val unit = unitOf(pos)
assert(unit.status >= JustParsed)
unit.targetPos = pos
try {
println("starting type targetted check")
typeCheck(unit)
throw new FatalError("tree not found")
} catch {
case ex: TyperResult =>
ex.tree
} finally {
unit.targetPos = NoPosition
}
}
}
/** Apply a phase to a compilation unit
* @return true iff typechecked correctly
*/
private def applyPhase(phase: Phase, unit: CompilationUnit) {
val oldSource = reporter.getSource
try {
reporter.setSource(unit.source)
atPhase(phase) { phase.asInstanceOf[GlobalPhase] applyPhase unit }
} finally {
reporter setSource oldSource
}
}
}
class TyperResult(val tree: Tree) extends Exception with ControlException
assert(globalPhase.id == 0)
}
|