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
|
AST_Scope.DEFMETHOD("figure_out_scope", function(){
// This does what ast_add_scope did in UglifyJS v1.
//
// Part of it could be done at parse time, but it would complicate
// the parser (and it's already kinda complex). It's also worth
// having it separated because we might need to call it multiple
// times on the same tree.
// pass 1: setup scope chaining and handle definitions
var scope = null;
var tw = new TreeWalker(function(node, descend){
if (node instanceof AST_Scope) {
var save_scope = node.parent_scope = scope;
scope = node;
descend.call(node);
scope = save_scope;
return true; // don't descend again in TreeWalker
}
if (node instanceof AST_With) {
for (var s = scope; s; s = s.parent_scope)
s.uses_with = true;
return;
}
if (node instanceof AST_SymbolLambda) {
scope.def_function(node);
}
else if (node instanceof AST_SymbolDefun) {
// Careful here, the scope where this should be defined is
// the parent scope. The reason is that we enter a new
// scope when we encounter the AST_Defun node (which is
// instanceof AST_Scope) but we get to the symbol a bit
// later.
scope.parent_scope.def_function(node);
}
else if (node instanceof AST_SymbolVar) {
scope.def_variable(node);
}
else if (node instanceof AST_Label) {
scope.def_label(node);
}
else if (node instanceof AST_SymbolCatch) {
// XXX: this is wrong according to ECMA-262 (12.4). the
// `catch` argument name should be visible only inside the
// catch block. For a quick fix AST_Catch should inherit
// from AST_Scope.
scope.def_variable(node);
}
else if (node instanceof AST_SymbolRef) {
node.scope = scope;
}
});
this.walk(tw);
// pass 2: find back references and eval/with
var tw = new TreeWalker(function(node){
if (node instanceof AST_LabelRef) {
var sym = node.scope.find_label(node);
if (!sym) throw new Error("Undefined label " + node.name);
node.reference(sym);
}
else if (node instanceof AST_SymbolRef) {
var sym = node.scope.find_variable(node);
node.reference(sym);
if (!sym) {
if (node.name == "eval") {
for (var s = scope; s; s = s.parent_scope)
s.uses_eval = true;
}
}
}
});
this.walk(tw);
});
AST_Scope.DEFMETHOD("scope_warnings", function(options){
options = defaults(options, {
undeclared : false,
assign_to_global : true
});
var tw = new TreeWalker(function(node){
if (options.undeclared
&& node instanceof AST_SymbolRef
&& node.undeclared)
{
// XXX: this also warns about JS standard names,
// i.e. Object, Array, parseInt etc. Should add a list of
// exceptions.
AST_Node.warn("Undeclared symbol: {name} [{line},{col}]", {
name: node.name,
line: node.start.line,
col: node.start.col
});
}
if (options.assign_to_global
&& node instanceof AST_Assign
&& node.left instanceof AST_SymbolRef
&& (node.left.undeclared
|| (node.left.symbol.global
&& node.left.scope !== node.left.symbol.scope)))
{
AST_Node.warn("{msg}: {name} [{line},{col}]", {
msg: node.left.undeclared ? "Accidental global?" : "Assignment to global",
name: node.left.name,
line: node.start.line,
col: node.start.col
});
}
});
this.walk(tw);
});
AST_SymbolRef.DEFMETHOD("reference", function(symbol) {
if (symbol) {
this.symbol = symbol;
var origin = symbol.scope;
symbol.references.push(this);
for (var s = this.scope; s; s = s.parent_scope) {
push_uniq(s.enclosed, symbol);
if (s === origin) break;
}
} else {
this.undeclared = true;
for (var s = this.scope; s; s = s.parent_scope) {
push_uniq(s.enclosed, this);
}
}
});
AST_Scope.DEFMETHOD("find_variable", function(name){
if (name instanceof AST_Symbol) name = name.name;
return this.variables[name] ||
(this.name && this.name.name == name && this.name) ||
(this.parent_scope && this.parent_scope.find_variable(name));
});
AST_Scope.DEFMETHOD("find_label", function(name){
if (name instanceof AST_Symbol) name = name.name;
return this.labels[name];
});
AST_Scope.DEFMETHOD("def_function", function(symbol){
this.def_variable(symbol);
this.functions[symbol.name] = symbol;
symbol.scope = this;
});
AST_Scope.DEFMETHOD("def_variable", function(symbol){
symbol.global = !this.parent_scope;
this.variables[symbol.name] = symbol;
delete this.functions[symbol.name];
symbol.scope = this;
});
AST_Scope.DEFMETHOD("def_label", function(symbol){
this.labels[symbol.name] = symbol;
symbol.scope = this;
});
AST_Scope.DEFMETHOD("next_mangled", function(for_label){
var ext = this.enclosed, n = ext.length;
out: for (;;) {
var m = base54(for_label
? (++this.lname)
: (++this.cname));
if (!is_identifier(m)) continue; // skip over "do"
// labels are easy, since they can't be referenced from nested
// scopes. XXX: not sure that will be the case when the `let`
// keyword is to be supported.
if (for_label) return m;
// if it's for functions or variables, we must ensure that the
// mangled name does not shadow a name from some parent scope
// that is referenced in this or in inner scopes.
for (var i = n; --i >= 0;) {
var sym = ext[i];
var name = sym.mangled_name || sym.name;
if (m == name) continue out;
}
return m;
}
});
AST_SymbolDeclaration.DEFMETHOD("mangle", function(){
if (!this.global)
this.mangled_name = this.scope.next_mangled(false);
});
AST_Label.DEFMETHOD("mangle", function(){
this.mangled_name = this.scope.next_mangled(true);
});
AST_Scope.DEFMETHOD("mangle_names", function(){
var tw = new TreeWalker(function(node){
// We only need to mangle declarations. Special logic wired
// into the code generator will display the mangled name if
// it's present (and for AST_SymbolRef-s it'll use the mangled
// name of the AST_SymbolDeclaration that it points to).
if (node instanceof AST_SymbolDeclaration) {
node.mangle();
}
});
this.walk(tw);
});
|
