blob: 91d4afb18e6379b29dcb1beee8ca78daa86bb1e2 [file] [log] [blame]
Ben Murdoch4a90d5f2016-03-22 12:00:34 +00001// 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/v8.h"
6
7#include "src/ast/ast-expression-visitor.h"
8
9#include "src/ast/ast.h"
10#include "src/ast/scopes.h"
11#include "src/codegen.h"
12
13namespace v8 {
14namespace internal {
15
16
17#define RECURSE(call) \
18 do { \
19 DCHECK(!HasStackOverflow()); \
20 call; \
21 if (HasStackOverflow()) return; \
22 } while (false)
23
24
25#define RECURSE_EXPRESSION(call) \
26 do { \
27 DCHECK(!HasStackOverflow()); \
28 ++depth_; \
29 call; \
30 --depth_; \
31 if (HasStackOverflow()) return; \
32 } while (false)
33
34
35AstExpressionVisitor::AstExpressionVisitor(Isolate* isolate, Expression* root)
36 : root_(root), depth_(0) {
37 InitializeAstVisitor(isolate);
38}
39
40
41AstExpressionVisitor::AstExpressionVisitor(uintptr_t stack_limit,
42 Expression* root)
43 : root_(root), depth_(0) {
44 InitializeAstVisitor(stack_limit);
45}
46
47
48void AstExpressionVisitor::Run() { RECURSE(Visit(root_)); }
49
50
51void AstExpressionVisitor::VisitVariableDeclaration(VariableDeclaration* decl) {
52}
53
54
55void AstExpressionVisitor::VisitFunctionDeclaration(FunctionDeclaration* decl) {
56 RECURSE(Visit(decl->fun()));
57}
58
59
60void AstExpressionVisitor::VisitImportDeclaration(ImportDeclaration* decl) {}
61
62
63void AstExpressionVisitor::VisitExportDeclaration(ExportDeclaration* decl) {}
64
65
66void AstExpressionVisitor::VisitStatements(ZoneList<Statement*>* stmts) {
67 for (int i = 0; i < stmts->length(); ++i) {
68 Statement* stmt = stmts->at(i);
69 RECURSE(Visit(stmt));
70 if (stmt->IsJump()) break;
71 }
72}
73
74
75void AstExpressionVisitor::VisitBlock(Block* stmt) {
76 RECURSE(VisitStatements(stmt->statements()));
77}
78
79
80void AstExpressionVisitor::VisitExpressionStatement(ExpressionStatement* stmt) {
81 RECURSE(Visit(stmt->expression()));
82}
83
84
85void AstExpressionVisitor::VisitEmptyStatement(EmptyStatement* stmt) {}
86
87
88void AstExpressionVisitor::VisitSloppyBlockFunctionStatement(
89 SloppyBlockFunctionStatement* stmt) {
90 RECURSE(Visit(stmt->statement()));
91}
92
93
94void AstExpressionVisitor::VisitIfStatement(IfStatement* stmt) {
95 RECURSE(Visit(stmt->condition()));
96 RECURSE(Visit(stmt->then_statement()));
97 RECURSE(Visit(stmt->else_statement()));
98}
99
100
101void AstExpressionVisitor::VisitContinueStatement(ContinueStatement* stmt) {}
102
103
104void AstExpressionVisitor::VisitBreakStatement(BreakStatement* stmt) {}
105
106
107void AstExpressionVisitor::VisitReturnStatement(ReturnStatement* stmt) {
108 RECURSE(Visit(stmt->expression()));
109}
110
111
112void AstExpressionVisitor::VisitWithStatement(WithStatement* stmt) {
113 RECURSE(stmt->expression());
114 RECURSE(stmt->statement());
115}
116
117
118void AstExpressionVisitor::VisitSwitchStatement(SwitchStatement* stmt) {
119 RECURSE(Visit(stmt->tag()));
120
121 ZoneList<CaseClause*>* clauses = stmt->cases();
122
123 for (int i = 0; i < clauses->length(); ++i) {
124 CaseClause* clause = clauses->at(i);
125 if (!clause->is_default()) {
126 Expression* label = clause->label();
127 RECURSE(Visit(label));
128 }
129 ZoneList<Statement*>* stmts = clause->statements();
130 RECURSE(VisitStatements(stmts));
131 }
132}
133
134
135void AstExpressionVisitor::VisitCaseClause(CaseClause* clause) {
136 UNREACHABLE();
137}
138
139
140void AstExpressionVisitor::VisitDoWhileStatement(DoWhileStatement* stmt) {
141 RECURSE(Visit(stmt->body()));
142 RECURSE(Visit(stmt->cond()));
143}
144
145
146void AstExpressionVisitor::VisitWhileStatement(WhileStatement* stmt) {
147 RECURSE(Visit(stmt->cond()));
148 RECURSE(Visit(stmt->body()));
149}
150
151
152void AstExpressionVisitor::VisitForStatement(ForStatement* stmt) {
153 if (stmt->init() != NULL) {
154 RECURSE(Visit(stmt->init()));
155 }
156 if (stmt->cond() != NULL) {
157 RECURSE(Visit(stmt->cond()));
158 }
159 if (stmt->next() != NULL) {
160 RECURSE(Visit(stmt->next()));
161 }
162 RECURSE(Visit(stmt->body()));
163}
164
165
166void AstExpressionVisitor::VisitForInStatement(ForInStatement* stmt) {
167 RECURSE(Visit(stmt->enumerable()));
168 RECURSE(Visit(stmt->body()));
169}
170
171
172void AstExpressionVisitor::VisitForOfStatement(ForOfStatement* stmt) {
Ben Murdoch4a90d5f2016-03-22 12:00:34 +0000173 RECURSE(Visit(stmt->assign_iterator()));
174 RECURSE(Visit(stmt->next_result()));
175 RECURSE(Visit(stmt->result_done()));
176 RECURSE(Visit(stmt->assign_each()));
177 RECURSE(Visit(stmt->body()));
178}
179
180
181void AstExpressionVisitor::VisitTryCatchStatement(TryCatchStatement* stmt) {
182 RECURSE(Visit(stmt->try_block()));
183 RECURSE(Visit(stmt->catch_block()));
184}
185
186
187void AstExpressionVisitor::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
188 RECURSE(Visit(stmt->try_block()));
189 RECURSE(Visit(stmt->finally_block()));
190}
191
192
193void AstExpressionVisitor::VisitDebuggerStatement(DebuggerStatement* stmt) {}
194
195
196void AstExpressionVisitor::VisitFunctionLiteral(FunctionLiteral* expr) {
197 Scope* scope = expr->scope();
198 VisitExpression(expr);
199 RECURSE_EXPRESSION(VisitDeclarations(scope->declarations()));
200 RECURSE_EXPRESSION(VisitStatements(expr->body()));
201}
202
203
204void AstExpressionVisitor::VisitNativeFunctionLiteral(
205 NativeFunctionLiteral* expr) {}
206
207
208void AstExpressionVisitor::VisitDoExpression(DoExpression* expr) {
Ben Murdoch097c5b22016-05-18 11:27:45 +0100209 VisitExpression(expr);
Ben Murdoch4a90d5f2016-03-22 12:00:34 +0000210 RECURSE(VisitBlock(expr->block()));
211 RECURSE(VisitVariableProxy(expr->result()));
212}
213
214
215void AstExpressionVisitor::VisitConditional(Conditional* expr) {
216 VisitExpression(expr);
217 RECURSE_EXPRESSION(Visit(expr->condition()));
218 RECURSE_EXPRESSION(Visit(expr->then_expression()));
219 RECURSE_EXPRESSION(Visit(expr->else_expression()));
220}
221
222
223void AstExpressionVisitor::VisitVariableProxy(VariableProxy* expr) {
224 VisitExpression(expr);
225}
226
227
228void AstExpressionVisitor::VisitLiteral(Literal* expr) {
229 VisitExpression(expr);
230}
231
232
233void AstExpressionVisitor::VisitRegExpLiteral(RegExpLiteral* expr) {
234 VisitExpression(expr);
235}
236
237
238void AstExpressionVisitor::VisitObjectLiteral(ObjectLiteral* expr) {
239 VisitExpression(expr);
240 ZoneList<ObjectLiteralProperty*>* props = expr->properties();
241 for (int i = 0; i < props->length(); ++i) {
242 ObjectLiteralProperty* prop = props->at(i);
243 if (!prop->key()->IsLiteral()) {
244 RECURSE_EXPRESSION(Visit(prop->key()));
245 }
246 RECURSE_EXPRESSION(Visit(prop->value()));
247 }
248}
249
250
251void AstExpressionVisitor::VisitArrayLiteral(ArrayLiteral* expr) {
252 VisitExpression(expr);
253 ZoneList<Expression*>* values = expr->values();
254 for (int i = 0; i < values->length(); ++i) {
255 Expression* value = values->at(i);
256 RECURSE_EXPRESSION(Visit(value));
257 }
258}
259
260
261void AstExpressionVisitor::VisitAssignment(Assignment* expr) {
262 VisitExpression(expr);
263 RECURSE_EXPRESSION(Visit(expr->target()));
264 RECURSE_EXPRESSION(Visit(expr->value()));
265}
266
267
268void AstExpressionVisitor::VisitYield(Yield* expr) {
269 VisitExpression(expr);
270 RECURSE_EXPRESSION(Visit(expr->generator_object()));
271 RECURSE_EXPRESSION(Visit(expr->expression()));
272}
273
274
275void AstExpressionVisitor::VisitThrow(Throw* expr) {
276 VisitExpression(expr);
277 RECURSE_EXPRESSION(Visit(expr->exception()));
278}
279
280
281void AstExpressionVisitor::VisitProperty(Property* expr) {
282 VisitExpression(expr);
283 RECURSE_EXPRESSION(Visit(expr->obj()));
284 RECURSE_EXPRESSION(Visit(expr->key()));
285}
286
287
288void AstExpressionVisitor::VisitCall(Call* expr) {
289 VisitExpression(expr);
290 RECURSE_EXPRESSION(Visit(expr->expression()));
291 ZoneList<Expression*>* args = expr->arguments();
292 for (int i = 0; i < args->length(); ++i) {
293 Expression* arg = args->at(i);
294 RECURSE_EXPRESSION(Visit(arg));
295 }
296}
297
298
299void AstExpressionVisitor::VisitCallNew(CallNew* expr) {
300 VisitExpression(expr);
301 RECURSE_EXPRESSION(Visit(expr->expression()));
302 ZoneList<Expression*>* args = expr->arguments();
303 for (int i = 0; i < args->length(); ++i) {
304 Expression* arg = args->at(i);
305 RECURSE_EXPRESSION(Visit(arg));
306 }
307}
308
309
310void AstExpressionVisitor::VisitCallRuntime(CallRuntime* expr) {
311 VisitExpression(expr);
312 ZoneList<Expression*>* args = expr->arguments();
313 for (int i = 0; i < args->length(); ++i) {
314 Expression* arg = args->at(i);
315 RECURSE_EXPRESSION(Visit(arg));
316 }
317}
318
319
320void AstExpressionVisitor::VisitUnaryOperation(UnaryOperation* expr) {
321 VisitExpression(expr);
322 RECURSE_EXPRESSION(Visit(expr->expression()));
323}
324
325
326void AstExpressionVisitor::VisitCountOperation(CountOperation* expr) {
327 VisitExpression(expr);
328 RECURSE_EXPRESSION(Visit(expr->expression()));
329}
330
331
332void AstExpressionVisitor::VisitBinaryOperation(BinaryOperation* expr) {
333 VisitExpression(expr);
334 RECURSE_EXPRESSION(Visit(expr->left()));
335 RECURSE_EXPRESSION(Visit(expr->right()));
336}
337
338
339void AstExpressionVisitor::VisitCompareOperation(CompareOperation* expr) {
340 VisitExpression(expr);
341 RECURSE_EXPRESSION(Visit(expr->left()));
342 RECURSE_EXPRESSION(Visit(expr->right()));
343}
344
345
346void AstExpressionVisitor::VisitThisFunction(ThisFunction* expr) {
347 VisitExpression(expr);
348}
349
350
351void AstExpressionVisitor::VisitDeclarations(ZoneList<Declaration*>* decls) {
352 for (int i = 0; i < decls->length(); ++i) {
353 Declaration* decl = decls->at(i);
354 RECURSE(Visit(decl));
355 }
356}
357
358
359void AstExpressionVisitor::VisitClassLiteral(ClassLiteral* expr) {
360 VisitExpression(expr);
361 if (expr->extends() != nullptr) {
362 RECURSE_EXPRESSION(Visit(expr->extends()));
363 }
364 RECURSE_EXPRESSION(Visit(expr->constructor()));
365 ZoneList<ObjectLiteralProperty*>* props = expr->properties();
366 for (int i = 0; i < props->length(); ++i) {
367 ObjectLiteralProperty* prop = props->at(i);
368 if (!prop->key()->IsLiteral()) {
369 RECURSE_EXPRESSION(Visit(prop->key()));
370 }
371 RECURSE_EXPRESSION(Visit(prop->value()));
372 }
373}
374
375
376void AstExpressionVisitor::VisitSpread(Spread* expr) {
377 VisitExpression(expr);
378 RECURSE_EXPRESSION(Visit(expr->expression()));
379}
380
381
382void AstExpressionVisitor::VisitEmptyParentheses(EmptyParentheses* expr) {}
383
384
385void AstExpressionVisitor::VisitSuperPropertyReference(
386 SuperPropertyReference* expr) {
387 VisitExpression(expr);
388 RECURSE_EXPRESSION(VisitVariableProxy(expr->this_var()));
389 RECURSE_EXPRESSION(Visit(expr->home_object()));
390}
391
392
393void AstExpressionVisitor::VisitSuperCallReference(SuperCallReference* expr) {
394 VisitExpression(expr);
395 RECURSE_EXPRESSION(VisitVariableProxy(expr->this_var()));
396 RECURSE_EXPRESSION(VisitVariableProxy(expr->new_target_var()));
397 RECURSE_EXPRESSION(VisitVariableProxy(expr->this_function_var()));
398}
399
400
Ben Murdoch097c5b22016-05-18 11:27:45 +0100401void AstExpressionVisitor::VisitRewritableExpression(
402 RewritableExpression* expr) {
Ben Murdoch4a90d5f2016-03-22 12:00:34 +0000403 VisitExpression(expr);
404 RECURSE(Visit(expr->expression()));
405}
406
407
408} // namespace internal
409} // namespace v8