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-literal-reindexer.h"
6
7#include "src/ast/ast.h"
8#include "src/ast/scopes.h"
9
10namespace v8 {
11namespace internal {
12
13
14void AstLiteralReindexer::VisitVariableDeclaration(VariableDeclaration* node) {
15  VisitVariableProxy(node->proxy());
16}
17
18
19void AstLiteralReindexer::VisitEmptyStatement(EmptyStatement* node) {}
20
21
22void AstLiteralReindexer::VisitSloppyBlockFunctionStatement(
23    SloppyBlockFunctionStatement* node) {
24  Visit(node->statement());
25}
26
27
28void AstLiteralReindexer::VisitContinueStatement(ContinueStatement* node) {}
29
30
31void AstLiteralReindexer::VisitBreakStatement(BreakStatement* node) {}
32
33
34void AstLiteralReindexer::VisitDebuggerStatement(DebuggerStatement* node) {}
35
36
37void AstLiteralReindexer::VisitNativeFunctionLiteral(
38    NativeFunctionLiteral* node) {}
39
40
41void AstLiteralReindexer::VisitDoExpression(DoExpression* node) {
42  Visit(node->block());
43  Visit(node->result());
44}
45
46
47void AstLiteralReindexer::VisitLiteral(Literal* node) {}
48
49
50void AstLiteralReindexer::VisitRegExpLiteral(RegExpLiteral* node) {
51  UpdateIndex(node);
52}
53
54
55void AstLiteralReindexer::VisitVariableProxy(VariableProxy* node) {}
56
57
58void AstLiteralReindexer::VisitThisFunction(ThisFunction* node) {}
59
60
61void AstLiteralReindexer::VisitSuperPropertyReference(
62    SuperPropertyReference* node) {
63  Visit(node->this_var());
64  Visit(node->home_object());
65}
66
67
68void AstLiteralReindexer::VisitSuperCallReference(SuperCallReference* node) {
69  Visit(node->this_var());
70  Visit(node->new_target_var());
71  Visit(node->this_function_var());
72}
73
74
75void AstLiteralReindexer::VisitRewritableExpression(
76    RewritableExpression* node) {
77  Visit(node->expression());
78}
79
80
81void AstLiteralReindexer::VisitExpressionStatement(ExpressionStatement* node) {
82  Visit(node->expression());
83}
84
85
86void AstLiteralReindexer::VisitReturnStatement(ReturnStatement* node) {
87  Visit(node->expression());
88}
89
90
91void AstLiteralReindexer::VisitYield(Yield* node) {
92  Visit(node->generator_object());
93  Visit(node->expression());
94}
95
96
97void AstLiteralReindexer::VisitThrow(Throw* node) { Visit(node->exception()); }
98
99
100void AstLiteralReindexer::VisitUnaryOperation(UnaryOperation* node) {
101  Visit(node->expression());
102}
103
104
105void AstLiteralReindexer::VisitCountOperation(CountOperation* node) {
106  Visit(node->expression());
107}
108
109
110void AstLiteralReindexer::VisitBlock(Block* node) {
111  VisitStatements(node->statements());
112}
113
114
115void AstLiteralReindexer::VisitFunctionDeclaration(FunctionDeclaration* node) {
116  VisitVariableProxy(node->proxy());
117  VisitFunctionLiteral(node->fun());
118}
119
120
121void AstLiteralReindexer::VisitCallRuntime(CallRuntime* node) {
122  VisitArguments(node->arguments());
123}
124
125
126void AstLiteralReindexer::VisitWithStatement(WithStatement* node) {
127  Visit(node->expression());
128  Visit(node->statement());
129}
130
131
132void AstLiteralReindexer::VisitDoWhileStatement(DoWhileStatement* node) {
133  Visit(node->body());
134  Visit(node->cond());
135}
136
137
138void AstLiteralReindexer::VisitWhileStatement(WhileStatement* node) {
139  Visit(node->cond());
140  Visit(node->body());
141}
142
143
144void AstLiteralReindexer::VisitTryCatchStatement(TryCatchStatement* node) {
145  Visit(node->try_block());
146  Visit(node->catch_block());
147}
148
149
150void AstLiteralReindexer::VisitTryFinallyStatement(TryFinallyStatement* node) {
151  Visit(node->try_block());
152  Visit(node->finally_block());
153}
154
155
156void AstLiteralReindexer::VisitProperty(Property* node) {
157  Visit(node->key());
158  Visit(node->obj());
159}
160
161
162void AstLiteralReindexer::VisitAssignment(Assignment* node) {
163  Visit(node->target());
164  Visit(node->value());
165}
166
167
168void AstLiteralReindexer::VisitBinaryOperation(BinaryOperation* node) {
169  Visit(node->left());
170  Visit(node->right());
171}
172
173
174void AstLiteralReindexer::VisitCompareOperation(CompareOperation* node) {
175  Visit(node->left());
176  Visit(node->right());
177}
178
179
180void AstLiteralReindexer::VisitSpread(Spread* node) {
181  // This is reachable because ParserBase::ParseArrowFunctionLiteral calls
182  // ReindexLiterals before calling RewriteDestructuringAssignments.
183  Visit(node->expression());
184}
185
186
187void AstLiteralReindexer::VisitEmptyParentheses(EmptyParentheses* node) {}
188
189
190void AstLiteralReindexer::VisitForInStatement(ForInStatement* node) {
191  Visit(node->each());
192  Visit(node->enumerable());
193  Visit(node->body());
194}
195
196
197void AstLiteralReindexer::VisitForOfStatement(ForOfStatement* node) {
198  Visit(node->assign_iterator());
199  Visit(node->next_result());
200  Visit(node->result_done());
201  Visit(node->assign_each());
202  Visit(node->body());
203}
204
205
206void AstLiteralReindexer::VisitConditional(Conditional* node) {
207  Visit(node->condition());
208  Visit(node->then_expression());
209  Visit(node->else_expression());
210}
211
212
213void AstLiteralReindexer::VisitIfStatement(IfStatement* node) {
214  Visit(node->condition());
215  Visit(node->then_statement());
216  if (node->HasElseStatement()) {
217    Visit(node->else_statement());
218  }
219}
220
221
222void AstLiteralReindexer::VisitSwitchStatement(SwitchStatement* node) {
223  Visit(node->tag());
224  ZoneList<CaseClause*>* cases = node->cases();
225  for (int i = 0; i < cases->length(); i++) {
226    VisitCaseClause(cases->at(i));
227  }
228}
229
230
231void AstLiteralReindexer::VisitCaseClause(CaseClause* node) {
232  if (!node->is_default()) Visit(node->label());
233  VisitStatements(node->statements());
234}
235
236
237void AstLiteralReindexer::VisitForStatement(ForStatement* node) {
238  if (node->init() != NULL) Visit(node->init());
239  if (node->cond() != NULL) Visit(node->cond());
240  if (node->next() != NULL) Visit(node->next());
241  Visit(node->body());
242}
243
244
245void AstLiteralReindexer::VisitClassLiteral(ClassLiteral* node) {
246  if (node->extends()) Visit(node->extends());
247  if (node->constructor()) Visit(node->constructor());
248  if (node->class_variable_proxy()) {
249    VisitVariableProxy(node->class_variable_proxy());
250  }
251  for (int i = 0; i < node->properties()->length(); i++) {
252    VisitLiteralProperty(node->properties()->at(i));
253  }
254}
255
256void AstLiteralReindexer::VisitObjectLiteral(ObjectLiteral* node) {
257  UpdateIndex(node);
258  for (int i = 0; i < node->properties()->length(); i++) {
259    VisitLiteralProperty(node->properties()->at(i));
260  }
261}
262
263void AstLiteralReindexer::VisitLiteralProperty(LiteralProperty* node) {
264  Visit(node->key());
265  Visit(node->value());
266}
267
268
269void AstLiteralReindexer::VisitArrayLiteral(ArrayLiteral* node) {
270  UpdateIndex(node);
271  for (int i = 0; i < node->values()->length(); i++) {
272    Visit(node->values()->at(i));
273  }
274}
275
276
277void AstLiteralReindexer::VisitCall(Call* node) {
278  Visit(node->expression());
279  VisitArguments(node->arguments());
280}
281
282
283void AstLiteralReindexer::VisitCallNew(CallNew* node) {
284  Visit(node->expression());
285  VisitArguments(node->arguments());
286}
287
288
289void AstLiteralReindexer::VisitStatements(ZoneList<Statement*>* statements) {
290  if (statements == NULL) return;
291  for (int i = 0; i < statements->length(); i++) {
292    Visit(statements->at(i));
293  }
294}
295
296
297void AstLiteralReindexer::VisitDeclarations(
298    ZoneList<Declaration*>* declarations) {
299  for (int i = 0; i < declarations->length(); i++) {
300    Visit(declarations->at(i));
301  }
302}
303
304
305void AstLiteralReindexer::VisitArguments(ZoneList<Expression*>* arguments) {
306  for (int i = 0; i < arguments->length(); i++) {
307    Visit(arguments->at(i));
308  }
309}
310
311
312void AstLiteralReindexer::VisitFunctionLiteral(FunctionLiteral* node) {
313  // We don't recurse into the declarations or body of the function literal:
314}
315
316void AstLiteralReindexer::Reindex(Expression* pattern) { Visit(pattern); }
317}  // namespace internal
318}  // namespace v8
319