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.
7 #include "src/ast-expression-visitor.h"
10 #include "src/codegen.h"
11 #include "src/scopes.h"
17 #define RECURSE(call) \
19 DCHECK(!HasStackOverflow()); \
21 if (HasStackOverflow()) return; \
25 #define RECURSE_EXPRESSION(call) \
27 DCHECK(!HasStackOverflow()); \
31 if (HasStackOverflow()) return; \
35 AstExpressionVisitor::AstExpressionVisitor(Isolate* isolate, Zone* zone,
36 FunctionLiteral* root)
37 : root_(root), depth_(0) {
38 InitializeAstVisitor(isolate, zone);
42 void AstExpressionVisitor::Run() { RECURSE(VisitFunctionLiteral(root_)); }
45 void AstExpressionVisitor::VisitVariableDeclaration(VariableDeclaration* decl) {
49 void AstExpressionVisitor::VisitFunctionDeclaration(FunctionDeclaration* decl) {
50 RECURSE(Visit(decl->fun()));
54 void AstExpressionVisitor::VisitImportDeclaration(ImportDeclaration* decl) {}
57 void AstExpressionVisitor::VisitExportDeclaration(ExportDeclaration* decl) {}
60 void AstExpressionVisitor::VisitStatements(ZoneList<Statement*>* stmts) {
61 for (int i = 0; i < stmts->length(); ++i) {
62 Statement* stmt = stmts->at(i);
64 if (stmt->IsJump()) break;
69 void AstExpressionVisitor::VisitBlock(Block* stmt) {
70 RECURSE(VisitStatements(stmt->statements()));
74 void AstExpressionVisitor::VisitExpressionStatement(ExpressionStatement* stmt) {
75 RECURSE(Visit(stmt->expression()));
79 void AstExpressionVisitor::VisitEmptyStatement(EmptyStatement* stmt) {}
82 void AstExpressionVisitor::VisitSloppyBlockFunctionStatement(
83 SloppyBlockFunctionStatement* stmt) {
84 RECURSE(Visit(stmt->statement()));
88 void AstExpressionVisitor::VisitIfStatement(IfStatement* stmt) {
89 RECURSE(Visit(stmt->condition()));
90 RECURSE(Visit(stmt->then_statement()));
91 RECURSE(Visit(stmt->else_statement()));
95 void AstExpressionVisitor::VisitContinueStatement(ContinueStatement* stmt) {}
98 void AstExpressionVisitor::VisitBreakStatement(BreakStatement* stmt) {}
101 void AstExpressionVisitor::VisitReturnStatement(ReturnStatement* stmt) {
102 RECURSE(Visit(stmt->expression()));
106 void AstExpressionVisitor::VisitWithStatement(WithStatement* stmt) {
107 RECURSE(stmt->expression());
108 RECURSE(stmt->statement());
112 void AstExpressionVisitor::VisitSwitchStatement(SwitchStatement* stmt) {
113 RECURSE(Visit(stmt->tag()));
115 ZoneList<CaseClause*>* clauses = stmt->cases();
117 for (int i = 0; i < clauses->length(); ++i) {
118 CaseClause* clause = clauses->at(i);
119 if (!clause->is_default()) {
120 Expression* label = clause->label();
121 RECURSE(Visit(label));
123 ZoneList<Statement*>* stmts = clause->statements();
124 RECURSE(VisitStatements(stmts));
129 void AstExpressionVisitor::VisitCaseClause(CaseClause* clause) {
134 void AstExpressionVisitor::VisitDoWhileStatement(DoWhileStatement* stmt) {
135 RECURSE(Visit(stmt->body()));
136 RECURSE(Visit(stmt->cond()));
140 void AstExpressionVisitor::VisitWhileStatement(WhileStatement* stmt) {
141 RECURSE(Visit(stmt->cond()));
142 RECURSE(Visit(stmt->body()));
146 void AstExpressionVisitor::VisitForStatement(ForStatement* stmt) {
147 if (stmt->init() != NULL) {
148 RECURSE(Visit(stmt->init()));
150 if (stmt->cond() != NULL) {
151 RECURSE(Visit(stmt->cond()));
153 if (stmt->next() != NULL) {
154 RECURSE(Visit(stmt->next()));
156 RECURSE(Visit(stmt->body()));
160 void AstExpressionVisitor::VisitForInStatement(ForInStatement* stmt) {
161 RECURSE(Visit(stmt->enumerable()));
162 RECURSE(Visit(stmt->body()));
166 void AstExpressionVisitor::VisitForOfStatement(ForOfStatement* stmt) {
167 RECURSE(Visit(stmt->iterable()));
168 RECURSE(Visit(stmt->body()));
172 void AstExpressionVisitor::VisitTryCatchStatement(TryCatchStatement* stmt) {
173 RECURSE(Visit(stmt->try_block()));
174 RECURSE(Visit(stmt->catch_block()));
178 void AstExpressionVisitor::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
179 RECURSE(Visit(stmt->try_block()));
180 RECURSE(Visit(stmt->finally_block()));
184 void AstExpressionVisitor::VisitDebuggerStatement(DebuggerStatement* stmt) {}
187 void AstExpressionVisitor::VisitFunctionLiteral(FunctionLiteral* expr) {
188 Scope* scope = expr->scope();
189 VisitExpression(expr);
190 RECURSE_EXPRESSION(VisitDeclarations(scope->declarations()));
191 RECURSE_EXPRESSION(VisitStatements(expr->body()));
195 void AstExpressionVisitor::VisitNativeFunctionLiteral(
196 NativeFunctionLiteral* expr) {}
199 void AstExpressionVisitor::VisitConditional(Conditional* expr) {
200 RECURSE(Visit(expr->condition()));
201 RECURSE(Visit(expr->then_expression()));
202 RECURSE(Visit(expr->else_expression()));
206 void AstExpressionVisitor::VisitVariableProxy(VariableProxy* expr) {
207 VisitExpression(expr);
211 void AstExpressionVisitor::VisitLiteral(Literal* expr) {
212 VisitExpression(expr);
216 void AstExpressionVisitor::VisitRegExpLiteral(RegExpLiteral* expr) {
217 VisitExpression(expr);
221 void AstExpressionVisitor::VisitObjectLiteral(ObjectLiteral* expr) {
222 VisitExpression(expr);
223 ZoneList<ObjectLiteralProperty*>* props = expr->properties();
224 for (int i = 0; i < props->length(); ++i) {
225 ObjectLiteralProperty* prop = props->at(i);
226 RECURSE_EXPRESSION(Visit(prop->value()));
231 void AstExpressionVisitor::VisitArrayLiteral(ArrayLiteral* expr) {
232 VisitExpression(expr);
233 ZoneList<Expression*>* values = expr->values();
234 for (int i = 0; i < values->length(); ++i) {
235 Expression* value = values->at(i);
236 RECURSE_EXPRESSION(Visit(value));
241 void AstExpressionVisitor::VisitAssignment(Assignment* expr) {
242 VisitExpression(expr);
243 RECURSE_EXPRESSION(Visit(expr->target()));
244 RECURSE_EXPRESSION(Visit(expr->value()));
248 void AstExpressionVisitor::VisitYield(Yield* expr) {
249 VisitExpression(expr);
250 RECURSE_EXPRESSION(Visit(expr->generator_object()));
251 RECURSE_EXPRESSION(Visit(expr->expression()));
255 void AstExpressionVisitor::VisitThrow(Throw* expr) {
256 VisitExpression(expr);
257 RECURSE_EXPRESSION(Visit(expr->exception()));
261 void AstExpressionVisitor::VisitProperty(Property* expr) {
262 VisitExpression(expr);
263 RECURSE_EXPRESSION(Visit(expr->obj()));
264 RECURSE_EXPRESSION(Visit(expr->key()));
268 void AstExpressionVisitor::VisitCall(Call* expr) {
269 VisitExpression(expr);
270 RECURSE_EXPRESSION(Visit(expr->expression()));
271 ZoneList<Expression*>* args = expr->arguments();
272 for (int i = 0; i < args->length(); ++i) {
273 Expression* arg = args->at(i);
274 RECURSE_EXPRESSION(Visit(arg));
279 void AstExpressionVisitor::VisitCallNew(CallNew* expr) {
280 VisitExpression(expr);
281 RECURSE_EXPRESSION(Visit(expr->expression()));
282 ZoneList<Expression*>* args = expr->arguments();
283 for (int i = 0; i < args->length(); ++i) {
284 Expression* arg = args->at(i);
285 RECURSE_EXPRESSION(Visit(arg));
290 void AstExpressionVisitor::VisitCallRuntime(CallRuntime* expr) {
291 VisitExpression(expr);
292 ZoneList<Expression*>* args = expr->arguments();
293 for (int i = 0; i < args->length(); ++i) {
294 Expression* arg = args->at(i);
295 RECURSE_EXPRESSION(Visit(arg));
300 void AstExpressionVisitor::VisitUnaryOperation(UnaryOperation* expr) {
301 VisitExpression(expr);
302 RECURSE_EXPRESSION(Visit(expr->expression()));
306 void AstExpressionVisitor::VisitCountOperation(CountOperation* expr) {
307 VisitExpression(expr);
308 RECURSE_EXPRESSION(Visit(expr->expression()));
312 void AstExpressionVisitor::VisitBinaryOperation(BinaryOperation* expr) {
313 VisitExpression(expr);
314 RECURSE_EXPRESSION(Visit(expr->left()));
315 RECURSE_EXPRESSION(Visit(expr->right()));
319 void AstExpressionVisitor::VisitCompareOperation(CompareOperation* expr) {
320 VisitExpression(expr);
321 RECURSE_EXPRESSION(Visit(expr->left()));
322 RECURSE_EXPRESSION(Visit(expr->right()));
326 void AstExpressionVisitor::VisitThisFunction(ThisFunction* expr) {
327 VisitExpression(expr);
331 void AstExpressionVisitor::VisitDeclarations(ZoneList<Declaration*>* decls) {
332 for (int i = 0; i < decls->length(); ++i) {
333 Declaration* decl = decls->at(i);
334 RECURSE(Visit(decl));
339 void AstExpressionVisitor::VisitClassLiteral(ClassLiteral* expr) {}
342 void AstExpressionVisitor::VisitSpread(Spread* expr) {}
345 void AstExpressionVisitor::VisitEmptyParentheses(EmptyParentheses* expr) {}
348 void AstExpressionVisitor::VisitSuperPropertyReference(
349 SuperPropertyReference* expr) {}
352 void AstExpressionVisitor::VisitSuperCallReference(SuperCallReference* expr) {}
356 } // namespace v8::internal