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