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
|
/* ____ ____ ____ ____ ______ *\
** / __// __ \/ __// __ \/ ____/ SOcos COmpiles Scala **
** __\_ \/ /_/ / /__/ /_/ /\_ \ (c) 2002, LAMP/EPFL **
** /_____/\____/\___/\____/____/ **
\* */
// $Id$
package scalac.typechecker;
import ch.epfl.lamp.util.Position;
import scalac.*;
import scalac.util.*;
import scalac.ast.*;
import scalac.symtab.*;
import scalac.checkers.*;
import java.util.HashMap;
import java.util.ArrayList;
public class AnalyzerPhase extends Phase {
final Context startContext;
final Context consoleContext;
final HashMap/*<Unit,Context>*/ contexts = new HashMap();
final ArrayList/*<Unit>*/ newSources = new ArrayList();
/** Initializes this instance. */
public AnalyzerPhase(Global global, PhaseDescriptor descriptor) {
super(global, descriptor);
Definitions definitions = global.definitions;
this.startContext = new Context(
Tree.Empty,
definitions.ROOT_CLASS,
definitions.ROOT_CLASS.members(),
Context.NONE);
this.startContext.enclClass = this.startContext;
if (!global.noimports) {
TreeFactory make = global.make;
Tree java = make.Ident(Position.NOPOS, Names.java)
.setSymbol(definitions.JAVA)
.setType(Type.singleType(definitions.ROOT_TYPE, definitions.JAVA));
Tree javalang = make.Select(Position.NOPOS, java, Names.lang)
.setSymbol(definitions.JAVALANG)
.setType(Type.singleType(java.type, definitions.JAVALANG));
Tree importjavalang = make.Import(
Position.NOPOS, javalang, new Name[]{Names.IMPORT_WILDCARD})
.setSymbol(definitions.JAVALANG)
.setType(definitions.UNIT_TYPE());
startContext.imports = new ImportList(
importjavalang, startContext.scope, startContext.imports);
Tree scala = make.Ident(Position.NOPOS, Names.scala)
.setSymbol(definitions.SCALA)
.setType(Type.singleType(definitions.ROOT_TYPE, definitions.SCALA));
Tree importscala = make.Import(
Position.NOPOS, scala, new Name[]{Names.IMPORT_WILDCARD})
.setSymbol(definitions.SCALA)
.setType(definitions.UNIT_TYPE());
startContext.imports = new ImportList(
importscala, new Scope(), startContext.imports);
}
if (!global.noimports && !global.nopredefs) {
TreeFactory make = global.make;
Tree scala = make.Ident(Position.NOPOS, Names.scala)
.setSymbol(definitions.SCALA)
.setType(Type.singleType(definitions.ROOT_TYPE, definitions.SCALA));
Symbol scalaPredefSym = definitions.getModule(Names.scala_Predef);
Tree scalaPredef = make.Select(Position.NOPOS, scala, Names.Predef)
.setSymbol(scalaPredefSym)
.setType(Type.singleType(scala.type, scalaPredefSym));
Tree importscalaPredef = make.Import(
Position.NOPOS, scalaPredef, new Name[]{Names.IMPORT_WILDCARD})
.setSymbol(scalaPredefSym)
.setType(definitions.UNIT_TYPE());
startContext.imports = new ImportList(
importscalaPredef, new Scope(), startContext.imports);
}
this.consoleContext = new Context(
Tree.Empty,
definitions.ROOT_CLASS,
definitions.ROOT_CLASS.members(),
startContext);
}
public void addConsoleImport(Global global, Symbol module) {
Definitions definitions = global.definitions;
TreeFactory make = global.make;
Tree console = make.Ident(Position.NOPOS, module.name)
.setSymbol(module)
.setType(Type.singleType(definitions.ROOT_TYPE, module));
Tree importConsole = make.Import(
Position.NOPOS, console, new Name[]{Names.IMPORT_WILDCARD})
.setSymbol(module)
.setType(definitions.UNIT_TYPE());
consoleContext.imports = new ImportList(
importConsole, new Scope(), consoleContext.imports);
}
public void apply(Unit[] units) {
new Analyzer(global, this).apply(units);
}
public void lateEnter(Global global, Unit unit, Symbol symbol) {
new Analyzer(global, this).lateEnter(unit, symbol);
}
public Checker[] postCheckers(Global global) {
return new Checker[] {
new CheckSymbols(global),
new CheckTypes(global),
new CheckOwners(global),
new CheckNames(global)
};
}
}
|
