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 0 : if (statements->at(i)->IsJump()) break;
35 : }
36 : }
37 :
38 :
39 2112 : void AstExpressionRewriter::VisitExpressions(
40 11764 : ZoneList<Expression*>* expressions) {
41 13876 : 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 4826 : if (expressions->at(i) != nullptr) {
47 11764 : 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 0 : for (CaseClause* clause : *node->cases()) {
120 0 : if (!clause->is_default()) {
121 0 : AST_REWRITE_PROPERTY(Expression, clause, label);
122 : }
123 0 : VisitStatements(clause->statements());
124 : }
125 : }
126 :
127 :
128 0 : void AstExpressionRewriter::VisitDoWhileStatement(DoWhileStatement* node) {
129 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
130 0 : AST_REWRITE_PROPERTY(Statement, node, body);
131 : }
132 :
133 :
134 0 : void AstExpressionRewriter::VisitWhileStatement(WhileStatement* node) {
135 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
136 0 : AST_REWRITE_PROPERTY(Statement, node, body);
137 : }
138 :
139 :
140 0 : void AstExpressionRewriter::VisitForStatement(ForStatement* node) {
141 0 : if (node->init() != nullptr) {
142 0 : AST_REWRITE_PROPERTY(Statement, node, init);
143 : }
144 0 : if (node->cond() != nullptr) {
145 0 : AST_REWRITE_PROPERTY(Expression, node, cond);
146 : }
147 0 : if (node->next() != nullptr) {
148 0 : AST_REWRITE_PROPERTY(Statement, node, next);
149 : }
150 0 : AST_REWRITE_PROPERTY(Statement, node, body);
151 : }
152 :
153 :
154 0 : void AstExpressionRewriter::VisitForInStatement(ForInStatement* node) {
155 0 : AST_REWRITE_PROPERTY(Expression, node, each);
156 0 : AST_REWRITE_PROPERTY(Expression, node, subject);
157 0 : AST_REWRITE_PROPERTY(Statement, node, body);
158 : }
159 :
160 :
161 0 : void AstExpressionRewriter::VisitForOfStatement(ForOfStatement* node) {
162 0 : AST_REWRITE_PROPERTY(Expression, node, assign_iterator);
163 0 : AST_REWRITE_PROPERTY(Expression, node, next_result);
164 0 : AST_REWRITE_PROPERTY(Expression, node, result_done);
165 0 : AST_REWRITE_PROPERTY(Expression, node, assign_each);
166 0 : AST_REWRITE_PROPERTY(Statement, node, body);
167 : }
168 :
169 :
170 0 : void AstExpressionRewriter::VisitTryCatchStatement(TryCatchStatement* node) {
171 0 : AST_REWRITE_PROPERTY(Block, node, try_block);
172 : // Not visiting the variable.
173 0 : AST_REWRITE_PROPERTY(Block, node, catch_block);
174 : }
175 :
176 :
177 0 : void AstExpressionRewriter::VisitTryFinallyStatement(
178 0 : TryFinallyStatement* node) {
179 0 : AST_REWRITE_PROPERTY(Block, node, try_block);
180 0 : AST_REWRITE_PROPERTY(Block, node, finally_block);
181 : }
182 :
183 :
184 0 : void AstExpressionRewriter::VisitDebuggerStatement(DebuggerStatement* node) {
185 : NOTHING();
186 0 : }
187 :
188 :
189 0 : void AstExpressionRewriter::VisitFunctionLiteral(FunctionLiteral* node) {
190 0 : REWRITE_THIS(node);
191 0 : VisitDeclarations(node->scope()->declarations());
192 : ZoneList<Statement*>* body = node->body();
193 0 : if (body != nullptr) VisitStatements(body);
194 : }
195 :
196 :
197 0 : void AstExpressionRewriter::VisitClassLiteral(ClassLiteral* node) {
198 0 : REWRITE_THIS(node);
199 : // Not visiting `class_variable_proxy_`.
200 0 : if (node->extends() != nullptr) {
201 0 : AST_REWRITE_PROPERTY(Expression, node, extends);
202 : }
203 0 : AST_REWRITE_PROPERTY(FunctionLiteral, node, constructor);
204 0 : ZoneList<typename ClassLiteral::Property*>* properties = node->properties();
205 0 : for (int i = 0; i < properties->length(); i++) {
206 0 : VisitLiteralProperty(properties->at(i));
207 : }
208 : }
209 :
210 0 : void AstExpressionRewriter::VisitNativeFunctionLiteral(
211 : NativeFunctionLiteral* node) {
212 0 : REWRITE_THIS(node);
213 : NOTHING();
214 : }
215 :
216 :
217 0 : void AstExpressionRewriter::VisitConditional(Conditional* node) {
218 0 : REWRITE_THIS(node);
219 0 : AST_REWRITE_PROPERTY(Expression, node, condition);
220 0 : AST_REWRITE_PROPERTY(Expression, node, then_expression);
221 0 : AST_REWRITE_PROPERTY(Expression, node, else_expression);
222 : }
223 :
224 :
225 840 : void AstExpressionRewriter::VisitVariableProxy(VariableProxy* node) {
226 840 : REWRITE_THIS(node);
227 : NOTHING();
228 : }
229 :
230 :
231 1170 : void AstExpressionRewriter::VisitLiteral(Literal* node) {
232 1170 : REWRITE_THIS(node);
233 : NOTHING();
234 : }
235 :
236 :
237 0 : void AstExpressionRewriter::VisitRegExpLiteral(RegExpLiteral* node) {
238 0 : REWRITE_THIS(node);
239 : NOTHING();
240 : }
241 :
242 :
243 0 : void AstExpressionRewriter::VisitObjectLiteral(ObjectLiteral* node) {
244 0 : REWRITE_THIS(node);
245 0 : ZoneList<typename ObjectLiteral::Property*>* properties = node->properties();
246 0 : for (int i = 0; i < properties->length(); i++) {
247 0 : VisitLiteralProperty(properties->at(i));
248 : }
249 : }
250 :
251 0 : void AstExpressionRewriter::VisitLiteralProperty(LiteralProperty* property) {
252 0 : if (property == nullptr) return;
253 0 : AST_REWRITE_PROPERTY(Expression, property, key);
254 0 : AST_REWRITE_PROPERTY(Expression, property, value);
255 : }
256 :
257 :
258 2112 : void AstExpressionRewriter::VisitArrayLiteral(ArrayLiteral* node) {
259 4224 : REWRITE_THIS(node);
260 0 : VisitExpressions(node->values());
261 : }
262 :
263 :
264 0 : void AstExpressionRewriter::VisitAssignment(Assignment* node) {
265 0 : REWRITE_THIS(node);
266 0 : AST_REWRITE_PROPERTY(Expression, node, target);
267 0 : AST_REWRITE_PROPERTY(Expression, node, value);
268 : }
269 :
270 0 : void AstExpressionRewriter::VisitCompoundAssignment(CompoundAssignment* node) {
271 0 : VisitAssignment(node);
272 0 : }
273 :
274 0 : void AstExpressionRewriter::VisitYield(Yield* node) {
275 0 : REWRITE_THIS(node);
276 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
277 : }
278 :
279 0 : void AstExpressionRewriter::VisitYieldStar(YieldStar* node) {
280 0 : REWRITE_THIS(node);
281 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
282 : }
283 :
284 0 : void AstExpressionRewriter::VisitAwait(Await* node) {
285 0 : REWRITE_THIS(node);
286 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
287 : }
288 :
289 0 : void AstExpressionRewriter::VisitThrow(Throw* node) {
290 0 : REWRITE_THIS(node);
291 0 : AST_REWRITE_PROPERTY(Expression, node, exception);
292 : }
293 :
294 :
295 0 : void AstExpressionRewriter::VisitProperty(Property* node) {
296 0 : REWRITE_THIS(node);
297 0 : if (node == nullptr) return;
298 0 : AST_REWRITE_PROPERTY(Expression, node, obj);
299 0 : AST_REWRITE_PROPERTY(Expression, node, key);
300 : }
301 :
302 :
303 15 : void AstExpressionRewriter::VisitCall(Call* node) {
304 15 : REWRITE_THIS(node);
305 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
306 0 : VisitExpressions(node->arguments());
307 : }
308 :
309 :
310 0 : void AstExpressionRewriter::VisitCallNew(CallNew* node) {
311 0 : REWRITE_THIS(node);
312 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
313 0 : VisitExpressions(node->arguments());
314 : }
315 :
316 :
317 0 : void AstExpressionRewriter::VisitCallRuntime(CallRuntime* node) {
318 0 : REWRITE_THIS(node);
319 0 : VisitExpressions(node->arguments());
320 : }
321 :
322 :
323 0 : void AstExpressionRewriter::VisitUnaryOperation(UnaryOperation* node) {
324 0 : REWRITE_THIS(node);
325 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
326 : }
327 :
328 :
329 0 : void AstExpressionRewriter::VisitCountOperation(CountOperation* node) {
330 0 : REWRITE_THIS(node);
331 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
332 : }
333 :
334 :
335 0 : void AstExpressionRewriter::VisitBinaryOperation(BinaryOperation* node) {
336 0 : REWRITE_THIS(node);
337 0 : AST_REWRITE_PROPERTY(Expression, node, left);
338 0 : AST_REWRITE_PROPERTY(Expression, node, right);
339 : }
340 :
341 :
342 0 : void AstExpressionRewriter::VisitCompareOperation(CompareOperation* node) {
343 0 : REWRITE_THIS(node);
344 0 : AST_REWRITE_PROPERTY(Expression, node, left);
345 0 : AST_REWRITE_PROPERTY(Expression, node, right);
346 : }
347 :
348 :
349 2794 : void AstExpressionRewriter::VisitSpread(Spread* node) {
350 2794 : REWRITE_THIS(node);
351 0 : AST_REWRITE_PROPERTY(Expression, node, expression);
352 : }
353 :
354 :
355 0 : void AstExpressionRewriter::VisitThisFunction(ThisFunction* node) {
356 0 : REWRITE_THIS(node);
357 : NOTHING();
358 : }
359 :
360 :
361 0 : void AstExpressionRewriter::VisitSuperPropertyReference(
362 0 : SuperPropertyReference* node) {
363 0 : REWRITE_THIS(node);
364 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
365 0 : AST_REWRITE_PROPERTY(Expression, node, home_object);
366 : }
367 :
368 :
369 0 : void AstExpressionRewriter::VisitSuperCallReference(SuperCallReference* node) {
370 0 : REWRITE_THIS(node);
371 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
372 0 : AST_REWRITE_PROPERTY(VariableProxy, node, new_target_var);
373 0 : AST_REWRITE_PROPERTY(VariableProxy, node, this_function_var);
374 : }
375 :
376 :
377 0 : void AstExpressionRewriter::VisitEmptyParentheses(EmptyParentheses* node) {
378 : NOTHING();
379 0 : }
380 :
381 0 : void AstExpressionRewriter::VisitGetIterator(GetIterator* node) {
382 0 : AST_REWRITE_PROPERTY(Expression, node, iterable);
383 : }
384 :
385 0 : void AstExpressionRewriter::VisitGetTemplateObject(GetTemplateObject* node) {
386 : NOTHING();
387 0 : }
388 :
389 0 : void AstExpressionRewriter::VisitImportCallExpression(
390 0 : ImportCallExpression* node) {
391 0 : REWRITE_THIS(node);
392 0 : AST_REWRITE_PROPERTY(Expression, node, argument);
393 : }
394 :
395 7 : void AstExpressionRewriter::VisitDoExpression(DoExpression* node) {
396 7 : REWRITE_THIS(node);
397 0 : AST_REWRITE_PROPERTY(Block, node, block);
398 0 : AST_REWRITE_PROPERTY(VariableProxy, node, result);
399 : }
400 :
401 :
402 2112 : void AstExpressionRewriter::VisitRewritableExpression(
403 4224 : RewritableExpression* node) {
404 2112 : REWRITE_THIS(node);
405 6336 : AST_REWRITE(Expression, node->expression(), node->Rewrite(replacement));
406 : }
407 :
408 :
409 : } // namespace internal
410 : } // namespace v8
|
