blob: da0d2375676b8b5531bffd6a03aedb4c9c1926d8 (
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/* NSC -- new scala compiler
* Copyright 2005-2010 LAMP/EPFL
* @author Martin Odersky
*/
// $Id$
package scala.tools.nsc
package symtab
import ast.Trees
import util._
abstract class SymbolTable extends Names
with Symbols
with Types
with Scopes
with Definitions
with Constants
with BaseTypeSeqs
with InfoTransformers
with StdNames
with AnnotationInfos
with AnnotationCheckers
with Trees
with Positions
{
def settings: Settings
def rootLoader: LazyType
def log(msg: AnyRef)
/** Are we compiling for Java SE ? */
def forJVM: Boolean
/** Are we compiling for .NET ? */
def forMSIL: Boolean
protected def trackTypeIDE(sym : Symbol) : Boolean = true
def compare(sym : Symbol, name : Name) = sym.name == name
def verifyAndPrioritize[T](g : Symbol => Symbol)(pt : Type)(f : => T) = f
def trackSetInfo[T <: Symbol](sym : T)(info : Type) : T = {
sym.setInfo(info); sym
}
def notifyImport(what : Name, container : Type, from : Name, to : Name) : Unit = {}
def sanitize(tree : Tree) : Tree = tree
/** A period is an ordinal number for a phase in a run.
* Phases in later runs have higher periods than phases in earlier runs.
* Later phases have higher periods than earlier phases in the same run.
*/
type Period = Int
final val NoPeriod = 0
/** An ordinal number for compiler runs. First run has number 1. */
type RunId = Int
final val NoRunId = 0
private var ph: Phase = NoPhase
private var per = NoPeriod
final def phase: Phase = ph
final def phase_=(p: Phase) {
//System.out.println("setting phase to " + p)
assert((p ne null) && p != NoPhase)
ph = p
per = (currentRunId << 8) + p.id
}
/** The current compiler run identifier. */
def currentRunId: RunId
/** The run identifier of the given period */
final def runId(period: Period): RunId = period >> 8
/** The phase identifier of the given period */
final def phaseId(period: Period): Phase#Id = period & 0xFF
/** The period at the start of run that includes `period' */
final def startRun(period: Period): Period = period & 0xFFFFFF00
/** The current period */
final def currentPeriod: Period = {
//assert(per == (currentRunId << 8) + phase.id)
per
}
/** The phase associated with given period */
final def phaseOf(period: Period): Phase = phaseWithId(phaseId(period))
final def period(rid: RunId, pid: Phase#Id): Period =
(currentRunId << 8) + pid
/** Perform given operation at given phase */
final def atPhase[T](ph: Phase)(op: => T): T = {
val current = phase
try {
phase = ph
op
} finally {
phase = current
}
}
/** Break into repl debugger if assertion is true */
// def breakIf(assertion: => Boolean, args: Any*): Unit =
// if (assertion)
// Interpreter.break(args.toList)
/** The set of all installed infotransformers */
var infoTransformers = new InfoTransformer {
val pid = NoPhase.id
val changesBaseClasses = true
def transform(sym: Symbol, tpe: Type): Type = tpe
}
/** The phase which has given index as identifier */
val phaseWithId: Array[Phase]
}
|