Lines Matching refs:node
14 void AstLiteralReindexer::VisitVariableDeclaration(VariableDeclaration* node) {
15 VisitVariableProxy(node->proxy());
19 void AstLiteralReindexer::VisitEmptyStatement(EmptyStatement* node) {}
23 SloppyBlockFunctionStatement* node) {
24 Visit(node->statement());
28 void AstLiteralReindexer::VisitContinueStatement(ContinueStatement* node) {}
31 void AstLiteralReindexer::VisitBreakStatement(BreakStatement* node) {}
34 void AstLiteralReindexer::VisitDebuggerStatement(DebuggerStatement* node) {}
38 NativeFunctionLiteral* node) {}
41 void AstLiteralReindexer::VisitDoExpression(DoExpression* node) {
42 Visit(node->block());
43 Visit(node->result());
47 void AstLiteralReindexer::VisitLiteral(Literal* node) {}
50 void AstLiteralReindexer::VisitRegExpLiteral(RegExpLiteral* node) {
51 UpdateIndex(node);
55 void AstLiteralReindexer::VisitVariableProxy(VariableProxy* node) {}
58 void AstLiteralReindexer::VisitThisFunction(ThisFunction* node) {}
62 SuperPropertyReference* node) {
63 Visit(node->this_var());
64 Visit(node->home_object());
68 void AstLiteralReindexer::VisitSuperCallReference(SuperCallReference* node) {
69 Visit(node->this_var());
70 Visit(node->new_target_var());
71 Visit(node->this_function_var());
76 RewritableExpression* node) {
77 Visit(node->expression());
81 void AstLiteralReindexer::VisitExpressionStatement(ExpressionStatement* node) {
82 Visit(node->expression());
86 void AstLiteralReindexer::VisitReturnStatement(ReturnStatement* node) {
87 Visit(node->expression());
91 void AstLiteralReindexer::VisitYield(Yield* node) {
92 Visit(node->generator_object());
93 Visit(node->expression());
97 void AstLiteralReindexer::VisitThrow(Throw* node) { Visit(node->exception()); }
100 void AstLiteralReindexer::VisitUnaryOperation(UnaryOperation* node) {
101 Visit(node->expression());
105 void AstLiteralReindexer::VisitCountOperation(CountOperation* node) {
106 Visit(node->expression());
110 void AstLiteralReindexer::VisitBlock(Block* node) {
111 VisitStatements(node->statements());
115 void AstLiteralReindexer::VisitFunctionDeclaration(FunctionDeclaration* node) {
116 VisitVariableProxy(node->proxy());
117 VisitFunctionLiteral(node->fun());
121 void AstLiteralReindexer::VisitCallRuntime(CallRuntime* node) {
122 VisitArguments(node->arguments());
126 void AstLiteralReindexer::VisitWithStatement(WithStatement* node) {
127 Visit(node->expression());
128 Visit(node->statement());
132 void AstLiteralReindexer::VisitDoWhileStatement(DoWhileStatement* node) {
133 Visit(node->body());
134 Visit(node->cond());
138 void AstLiteralReindexer::VisitWhileStatement(WhileStatement* node) {
139 Visit(node->cond());
140 Visit(node->body());
144 void AstLiteralReindexer::VisitTryCatchStatement(TryCatchStatement* node) {
145 Visit(node->try_block());
146 Visit(node->catch_block());
150 void AstLiteralReindexer::VisitTryFinallyStatement(TryFinallyStatement* node) {
151 Visit(node->try_block());
152 Visit(node->finally_block());
156 void AstLiteralReindexer::VisitProperty(Property* node) {
157 Visit(node->key());
158 Visit(node->obj());
162 void AstLiteralReindexer::VisitAssignment(Assignment* node) {
163 Visit(node->target());
164 Visit(node->value());
168 void AstLiteralReindexer::VisitBinaryOperation(BinaryOperation* node) {
169 Visit(node->left());
170 Visit(node->right());
174 void AstLiteralReindexer::VisitCompareOperation(CompareOperation* node) {
175 Visit(node->left());
176 Visit(node->right());
180 void AstLiteralReindexer::VisitSpread(Spread* node) {
183 Visit(node->expression());
187 void AstLiteralReindexer::VisitEmptyParentheses(EmptyParentheses* node) {}
190 void AstLiteralReindexer::VisitForInStatement(ForInStatement* node) {
191 Visit(node->each());
192 Visit(node->enumerable());
193 Visit(node->body());
197 void 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());
206 void AstLiteralReindexer::VisitConditional(Conditional* node) {
207 Visit(node->condition());
208 Visit(node->then_expression());
209 Visit(node->else_expression());
213 void AstLiteralReindexer::VisitIfStatement(IfStatement* node) {
214 Visit(node->condition());
215 Visit(node->then_statement());
216 if (node->HasElseStatement()) {
217 Visit(node->else_statement());
222 void AstLiteralReindexer::VisitSwitchStatement(SwitchStatement* node) {
223 Visit(node->tag());
224 ZoneList<CaseClause*>* cases = node->cases();
231 void AstLiteralReindexer::VisitCaseClause(CaseClause* node) {
232 if (!node->is_default()) Visit(node->label());
233 VisitStatements(node->statements());
237 void 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());
245 void 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());
251 for (int i = 0; i < node->properties()->length(); i++) {
252 VisitLiteralProperty(node->properties()->at(i));
256 void AstLiteralReindexer::VisitObjectLiteral(ObjectLiteral* node) {
257 UpdateIndex(node);
258 for (int i = 0; i < node->properties()->length(); i++) {
259 VisitLiteralProperty(node->properties()->at(i));
263 void AstLiteralReindexer::VisitLiteralProperty(LiteralProperty* node) {
264 Visit(node->key());
265 Visit(node->value());
269 void AstLiteralReindexer::VisitArrayLiteral(ArrayLiteral* node) {
270 UpdateIndex(node);
271 for (int i = 0; i < node->values()->length(); i++) {
272 Visit(node->values()->at(i));
277 void AstLiteralReindexer::VisitCall(Call* node) {
278 Visit(node->expression());
279 VisitArguments(node->arguments());
283 void AstLiteralReindexer::VisitCallNew(CallNew* node) {
284 Visit(node->expression());
285 VisitArguments(node->arguments());
312 void AstLiteralReindexer::VisitFunctionLiteral(FunctionLiteral* node) {