Line data Source code
1 : // Copyright 2015 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/ast/ast-expression-rewriter.h"
6 : #include "src/ast/ast.h"
7 : #include "src/objects-inl.h"
8 :
9 : namespace v8 {
10 : namespace internal {
11 :
12 : // ----------------------------------------------------------------------------
13 : // Implementation of AstExpressionRewriter
14 : // The AST is traversed but no actual rewriting takes place, unless the
15 : // Visit methods are overriden in subclasses.
16 :
17 : #define REWRITE_THIS(node) \
18 : do { \
19 : if (!RewriteExpression(node)) return; \
20 : } while (false)
21 : #define NOTHING() DCHECK_NULL(replacement_)
22 :
23 0 : void AstExpressionRewriter::VisitDeclarations(Declaration::List* declarations) {
24 0 : for (Declaration::List::Iterator it = declarations->begin();
25 : it != declarations->end(); ++it) {
26 0 : AST_REWRITE(Declaration, *it, it = replacement);
27 : }
28 : }
29 :
30 :
31 0 : void AstExpressionRewriter::VisitStatements(ZoneList<Statement*>* statements) {
32 0 : for (int i = 0; i < statements->length(); i++) {
33 0 : AST_REWRITE_LIST_ELEMENT(Statement, statements, i);
34 : // Not stopping when a jump statement is found.
35 : }
36 : }
37 :
38 :
39 3324 : void AstExpressionRewriter::VisitExpressions(
40 8749 : ZoneList<Expression*>* expressions) {
41 24146 : for (int i = 0; i < expressions->length(); i++) {
42 : // The variable statement visiting code may pass NULL expressions
43 : // to this code. Maybe this should be handled by introducing an
44 : // undefined expression or literal? Revisit this code if this
45 : // changes
46 20822 : if (expressions->at(i) != nullptr) {
47 20822 : AST_REWRITE_LIST_ELEMENT(Expression, expressions, i);
48 : }
49 : }
50 : }
51 :
52 :
53 0 : void AstExpressionRewriter::VisitVariableDeclaration(
54 : VariableDeclaration* node) {
55 : // Not visiting `proxy_`.
56 : NOTHING();
57 0 : }
58 :
59 :
60 0 : void AstExpressionRewriter::VisitFunctionDeclaration(
61 0 : FunctionDeclaration* node) {
62 : // Not visiting `proxy_`.
63 0 : AST_REWRITE_PROPERTY(FunctionLiteral, node, fun);
64 : }
65 :
66 :
67 0 : void AstExpressionRewriter::VisitBlock(Block* node) {
68 0 : VisitStatements(node->statements());
69 0 : }
70 :
71 :
72 0 : void AstExpressionRewriter::VisitExpressionStatement(
73 0 : ExpressionStatement* node) {
74 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
75 : }
76 :
77 :
78 0 : void AstExpressionRewriter::VisitEmptyStatement(EmptyStatement* node) {
79 : NOTHING();
80 0 : }
81 :
82 :
83 0 : void AstExpressionRewriter::VisitSloppyBlockFunctionStatement(
84 0 : SloppyBlockFunctionStatement* node) {
85 0 : AST_REWRITE_PROPERTY(Statement, node, statement);
86 : }
87 :
88 :
89 0 : void AstExpressionRewriter::VisitIfStatement(IfStatement* node) {
90 0 : AST_REWRITE_PROPERTY(Expression, node, condition);
91 0 : AST_REWRITE_PROPERTY(Statement, node, then_statement);
92 0 : AST_REWRITE_PROPERTY(Statement, node, else_statement);
93 : }
94 :
95 :
96 0 : void AstExpressionRewriter::VisitContinueStatement(ContinueStatement* node) {
97 : NOTHING();
98 0 : }
99 :
100 :
101 0 : void AstExpressionRewriter::VisitBreakStatement(BreakStatement* node) {
102 : NOTHING();
103 0 : }
104 :
105 :
106 0 : void AstExpressionRewriter::VisitReturnStatement(ReturnStatement* node) {
107 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
108 : }
109 :
110 :
111 0 : void AstExpressionRewriter::VisitWithStatement(WithStatement* node) {
112 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
113 0 : AST_REWRITE_PROPERTY(Statement, node, statement);
114 : }
115 :
116 :
117 0 : void AstExpressionRewriter::VisitSwitchStatement(SwitchStatement* node) {
118 0 : AST_REWRITE_PROPERTY(Expression, node, tag);
119 : ZoneList<CaseClause*>* clauses = node->cases();
120 0 : for (int i = 0; i < clauses->length(); i++) {
121 0 : AST_REWRITE_LIST_ELEMENT(CaseClause, clauses, i);
122 : }
123 : }
124 :
125 :
126 0 : void AstExpressionRewriter::VisitDoWhileStatement(DoWhileStatement* node) {
127 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
128 0 : AST_REWRITE_PROPERTY(Statement, node, body);
129 : }
130 :
131 :
132 0 : void AstExpressionRewriter::VisitWhileStatement(WhileStatement* node) {
133 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
134 0 : AST_REWRITE_PROPERTY(Statement, node, body);
135 : }
136 :
137 :
138 0 : void AstExpressionRewriter::VisitForStatement(ForStatement* node) {
139 0 : if (node->init() != nullptr) {
140 0 : AST_REWRITE_PROPERTY(Statement, node, init);
141 : }
142 0 : if (node->cond() != nullptr) {
143 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
144 : }
145 0 : if (node->next() != nullptr) {
146 0 : AST_REWRITE_PROPERTY(Statement, node, next);
147 : }
148 0 : AST_REWRITE_PROPERTY(Statement, node, body);
149 : }
150 :
151 :
152 0 : void AstExpressionRewriter::VisitForInStatement(ForInStatement* node) {
153 0 : AST_REWRITE_PROPERTY(Expression, node, each);
154 0 : AST_REWRITE_PROPERTY(Expression, node, subject);
155 0 : AST_REWRITE_PROPERTY(Statement, node, body);
156 : }
157 :
158 :
159 0 : void AstExpressionRewriter::VisitForOfStatement(ForOfStatement* node) {
160 0 : AST_REWRITE_PROPERTY(Expression, node, assign_iterator);
161 0 : AST_REWRITE_PROPERTY(Expression, node, next_result);
162 0 : AST_REWRITE_PROPERTY(Expression, node, result_done);
163 0 : AST_REWRITE_PROPERTY(Expression, node, assign_each);
164 0 : AST_REWRITE_PROPERTY(Statement, node, body);
165 : }
166 :
167 :
168 0 : void AstExpressionRewriter::VisitTryCatchStatement(TryCatchStatement* node) {
169 0 : AST_REWRITE_PROPERTY(Block, node, try_block);
170 : // Not visiting the variable.
171 0 : AST_REWRITE_PROPERTY(Block, node, catch_block);
172 : }
173 :
174 :
175 0 : void AstExpressionRewriter::VisitTryFinallyStatement(
176 0 : TryFinallyStatement* node) {
177 0 : AST_REWRITE_PROPERTY(Block, node, try_block);
178 0 : AST_REWRITE_PROPERTY(Block, node, finally_block);
179 : }
180 :
181 :
182 0 : void AstExpressionRewriter::VisitDebuggerStatement(DebuggerStatement* node) {
183 : NOTHING();
184 0 : }
185 :
186 :
187 0 : void AstExpressionRewriter::VisitFunctionLiteral(FunctionLiteral* node) {
188 0 : REWRITE_THIS(node);
189 0 : VisitDeclarations(node->scope()->declarations());
190 : ZoneList<Statement*>* body = node->body();
191 0 : if (body != nullptr) VisitStatements(body);
192 : }
193 :
194 :
195 0 : void AstExpressionRewriter::VisitClassLiteral(ClassLiteral* node) {
196 0 : REWRITE_THIS(node);
197 : // Not visiting `class_variable_proxy_`.
198 0 : if (node->extends() != nullptr) {
199 0 : AST_REWRITE_PROPERTY(Expression, node, extends);
200 : }
201 0 : AST_REWRITE_PROPERTY(FunctionLiteral, node, constructor);
202 : ZoneList<typename ClassLiteral::Property*>* properties = node->properties();
203 0 : for (int i = 0; i < properties->length(); i++) {
204 0 : VisitLiteralProperty(properties->at(i));
205 : }
206 : }
207 :
208 0 : void AstExpressionRewriter::VisitNativeFunctionLiteral(
209 : NativeFunctionLiteral* node) {
210 0 : REWRITE_THIS(node);
211 : NOTHING();
212 : }
213 :
214 :
215 0 : void AstExpressionRewriter::VisitConditional(Conditional* node) {
216 0 : REWRITE_THIS(node);
217 0 : AST_REWRITE_PROPERTY(Expression, node, condition);
218 0 : AST_REWRITE_PROPERTY(Expression, node, then_expression);
219 0 : AST_REWRITE_PROPERTY(Expression, node, else_expression);
220 : }
221 :
222 :
223 978 : void AstExpressionRewriter::VisitVariableProxy(VariableProxy* node) {
224 978 : REWRITE_THIS(node);
225 : NOTHING();
226 : }
227 :
228 :
229 2343 : void AstExpressionRewriter::VisitLiteral(Literal* node) {
230 2343 : REWRITE_THIS(node);
231 : NOTHING();
232 : }
233 :
234 :
235 0 : void AstExpressionRewriter::VisitRegExpLiteral(RegExpLiteral* node) {
236 0 : REWRITE_THIS(node);
237 : NOTHING();
238 : }
239 :
240 :
241 0 : void AstExpressionRewriter::VisitObjectLiteral(ObjectLiteral* node) {
242 0 : REWRITE_THIS(node);
243 : ZoneList<typename ObjectLiteral::Property*>* properties = node->properties();
244 0 : for (int i = 0; i < properties->length(); i++) {
245 0 : VisitLiteralProperty(properties->at(i));
246 : }
247 : }
248 :
249 0 : void AstExpressionRewriter::VisitLiteralProperty(LiteralProperty* property) {
250 0 : if (property == nullptr) return;
251 0 : AST_REWRITE_PROPERTY(Expression, property, key);
252 0 : AST_REWRITE_PROPERTY(Expression, property, value);
253 : }
254 :
255 :
256 3324 : void AstExpressionRewriter::VisitArrayLiteral(ArrayLiteral* node) {
257 6648 : REWRITE_THIS(node);
258 0 : VisitExpressions(node->values());
259 : }
260 :
261 :
262 0 : void AstExpressionRewriter::VisitAssignment(Assignment* node) {
263 0 : REWRITE_THIS(node);
264 0 : AST_REWRITE_PROPERTY(Expression, node, target);
265 0 : AST_REWRITE_PROPERTY(Expression, node, value);
266 : }
267 :
268 0 : void AstExpressionRewriter::VisitSuspend(Suspend* node) {
269 0 : REWRITE_THIS(node);
270 0 : AST_REWRITE_PROPERTY(Expression, node, generator_object);
271 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
272 : }
273 :
274 :
275 0 : void AstExpressionRewriter::VisitThrow(Throw* node) {
276 0 : REWRITE_THIS(node);
277 0 : AST_REWRITE_PROPERTY(Expression, node, exception);
278 : }
279 :
280 :
281 0 : void AstExpressionRewriter::VisitProperty(Property* node) {
282 0 : REWRITE_THIS(node);
283 0 : if (node == nullptr) return;
284 0 : AST_REWRITE_PROPERTY(Expression, node, obj);
285 0 : AST_REWRITE_PROPERTY(Expression, node, key);
286 : }
287 :
288 :
289 21 : void AstExpressionRewriter::VisitCall(Call* node) {
290 21 : REWRITE_THIS(node);
291 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
292 0 : VisitExpressions(node->arguments());
293 : }
294 :
295 :
296 0 : void AstExpressionRewriter::VisitCallNew(CallNew* node) {
297 0 : REWRITE_THIS(node);
298 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
299 0 : VisitExpressions(node->arguments());
300 : }
301 :
302 :
303 0 : void AstExpressionRewriter::VisitCallRuntime(CallRuntime* node) {
304 0 : REWRITE_THIS(node);
305 0 : VisitExpressions(node->arguments());
306 : }
307 :
308 :
309 0 : void AstExpressionRewriter::VisitUnaryOperation(UnaryOperation* node) {
310 0 : REWRITE_THIS(node);
311 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
312 : }
313 :
314 :
315 0 : void AstExpressionRewriter::VisitCountOperation(CountOperation* node) {
316 0 : REWRITE_THIS(node);
317 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
318 : }
319 :
320 :
321 0 : void AstExpressionRewriter::VisitBinaryOperation(BinaryOperation* node) {
322 0 : REWRITE_THIS(node);
323 0 : AST_REWRITE_PROPERTY(Expression, node, left);
324 0 : AST_REWRITE_PROPERTY(Expression, node, right);
325 : }
326 :
327 :
328 0 : void AstExpressionRewriter::VisitCompareOperation(CompareOperation* node) {
329 0 : REWRITE_THIS(node);
330 0 : AST_REWRITE_PROPERTY(Expression, node, left);
331 0 : AST_REWRITE_PROPERTY(Expression, node, right);
332 : }
333 :
334 :
335 5397 : void AstExpressionRewriter::VisitSpread(Spread* node) {
336 5397 : REWRITE_THIS(node);
337 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
338 : }
339 :
340 :
341 0 : void AstExpressionRewriter::VisitThisFunction(ThisFunction* node) {
342 0 : REWRITE_THIS(node);
343 : NOTHING();
344 : }
345 :
346 :
347 0 : void AstExpressionRewriter::VisitSuperPropertyReference(
348 0 : SuperPropertyReference* node) {
349 0 : REWRITE_THIS(node);
350 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
351 0 : AST_REWRITE_PROPERTY(Expression, node, home_object);
352 : }
353 :
354 :
355 0 : void AstExpressionRewriter::VisitSuperCallReference(SuperCallReference* node) {
356 0 : REWRITE_THIS(node);
357 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
358 0 : AST_REWRITE_PROPERTY(VariableProxy, node, new_target_var);
359 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_function_var);
360 : }
361 :
362 :
363 0 : void AstExpressionRewriter::VisitCaseClause(CaseClause* node) {
364 0 : if (!node->is_default()) {
365 0 : AST_REWRITE_PROPERTY(Expression, node, label);
366 : }
367 0 : VisitStatements(node->statements());
368 : }
369 :
370 :
371 0 : void AstExpressionRewriter::VisitEmptyParentheses(EmptyParentheses* node) {
372 : NOTHING();
373 0 : }
374 :
375 0 : void AstExpressionRewriter::VisitGetIterator(GetIterator* node) {
376 0 : AST_REWRITE_PROPERTY(Expression, node, iterable);
377 : }
378 :
379 0 : void AstExpressionRewriter::VisitImportCallExpression(
380 0 : ImportCallExpression* node) {
381 0 : REWRITE_THIS(node);
382 0 : AST_REWRITE_PROPERTY(Expression, node, argument);
383 : }
384 :
385 10 : void AstExpressionRewriter::VisitDoExpression(DoExpression* node) {
386 10 : REWRITE_THIS(node);
387 0 : AST_REWRITE_PROPERTY(Block, node, block);
388 0 : AST_REWRITE_PROPERTY(VariableProxy, node, result);
389 : }
390 :
391 :
392 3324 : void AstExpressionRewriter::VisitRewritableExpression(
393 6648 : RewritableExpression* node) {
394 3324 : REWRITE_THIS(node);
395 9972 : AST_REWRITE(Expression, node->expression(), node->Rewrite(replacement));
396 : }
397 :
398 :
399 : } // namespace internal
400 : } // namespace v8
|
