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