| // Copyright 2014 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/ast-this-access-visitor.h" |
| #include "src/parser.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| typedef class AstThisAccessVisitor ATAV; // for code shortitude. |
| |
| ATAV::AstThisAccessVisitor(Zone* zone) : uses_this_(false) { |
| InitializeAstVisitor(zone); |
| } |
| |
| |
| void ATAV::VisitVariableProxy(VariableProxy* proxy) { |
| if (proxy->is_this()) { |
| uses_this_ = true; |
| } |
| } |
| |
| |
| void ATAV::VisitSuperReference(SuperReference* leaf) { |
| // disallow super.method() and super(...). |
| uses_this_ = true; |
| } |
| |
| |
| void ATAV::VisitCallNew(CallNew* e) { |
| // new super(..) does not use 'this'. |
| if (!e->expression()->IsSuperReference()) { |
| Visit(e->expression()); |
| } |
| VisitExpressions(e->arguments()); |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // -- Leaf nodes ------------------------------------------------------------- |
| // --------------------------------------------------------------------------- |
| |
| void ATAV::VisitVariableDeclaration(VariableDeclaration* leaf) {} |
| void ATAV::VisitFunctionDeclaration(FunctionDeclaration* leaf) {} |
| void ATAV::VisitModuleDeclaration(ModuleDeclaration* leaf) {} |
| void ATAV::VisitImportDeclaration(ImportDeclaration* leaf) {} |
| void ATAV::VisitExportDeclaration(ExportDeclaration* leaf) {} |
| void ATAV::VisitModuleVariable(ModuleVariable* leaf) {} |
| void ATAV::VisitModulePath(ModulePath* leaf) {} |
| void ATAV::VisitModuleUrl(ModuleUrl* leaf) {} |
| void ATAV::VisitEmptyStatement(EmptyStatement* leaf) {} |
| void ATAV::VisitContinueStatement(ContinueStatement* leaf) {} |
| void ATAV::VisitBreakStatement(BreakStatement* leaf) {} |
| void ATAV::VisitDebuggerStatement(DebuggerStatement* leaf) {} |
| void ATAV::VisitFunctionLiteral(FunctionLiteral* leaf) {} |
| void ATAV::VisitNativeFunctionLiteral(NativeFunctionLiteral* leaf) {} |
| void ATAV::VisitLiteral(Literal* leaf) {} |
| void ATAV::VisitRegExpLiteral(RegExpLiteral* leaf) {} |
| void ATAV::VisitThisFunction(ThisFunction* leaf) {} |
| |
| // --------------------------------------------------------------------------- |
| // -- Pass-through nodes------------------------------------------------------ |
| // --------------------------------------------------------------------------- |
| void ATAV::VisitModuleLiteral(ModuleLiteral* e) { Visit(e->body()); } |
| |
| |
| void ATAV::VisitBlock(Block* stmt) { VisitStatements(stmt->statements()); } |
| |
| |
| void ATAV::VisitExpressionStatement(ExpressionStatement* stmt) { |
| Visit(stmt->expression()); |
| } |
| |
| |
| void ATAV::VisitIfStatement(IfStatement* stmt) { |
| Visit(stmt->condition()); |
| Visit(stmt->then_statement()); |
| Visit(stmt->else_statement()); |
| } |
| |
| |
| void ATAV::VisitReturnStatement(ReturnStatement* stmt) { |
| Visit(stmt->expression()); |
| } |
| |
| |
| void ATAV::VisitWithStatement(WithStatement* stmt) { |
| Visit(stmt->expression()); |
| Visit(stmt->statement()); |
| } |
| |
| |
| void ATAV::VisitSwitchStatement(SwitchStatement* stmt) { |
| Visit(stmt->tag()); |
| ZoneList<CaseClause*>* clauses = stmt->cases(); |
| for (int i = 0; i < clauses->length(); i++) { |
| Visit(clauses->at(i)); |
| } |
| } |
| |
| |
| void ATAV::VisitTryFinallyStatement(TryFinallyStatement* stmt) { |
| Visit(stmt->try_block()); |
| Visit(stmt->finally_block()); |
| } |
| |
| |
| void ATAV::VisitClassLiteral(ClassLiteral* e) { |
| VisitIfNotNull(e->extends()); |
| Visit(e->constructor()); |
| ZoneList<ObjectLiteralProperty*>* properties = e->properties(); |
| for (int i = 0; i < properties->length(); i++) { |
| Visit(properties->at(i)->value()); |
| } |
| } |
| |
| |
| void ATAV::VisitConditional(Conditional* e) { |
| Visit(e->condition()); |
| Visit(e->then_expression()); |
| Visit(e->else_expression()); |
| } |
| |
| |
| void ATAV::VisitObjectLiteral(ObjectLiteral* e) { |
| ZoneList<ObjectLiteralProperty*>* properties = e->properties(); |
| for (int i = 0; i < properties->length(); i++) { |
| Visit(properties->at(i)->value()); |
| } |
| } |
| |
| |
| void ATAV::VisitArrayLiteral(ArrayLiteral* e) { VisitExpressions(e->values()); } |
| |
| |
| void ATAV::VisitYield(Yield* stmt) { |
| Visit(stmt->generator_object()); |
| Visit(stmt->expression()); |
| } |
| |
| |
| void ATAV::VisitThrow(Throw* stmt) { Visit(stmt->exception()); } |
| |
| |
| void ATAV::VisitProperty(Property* e) { |
| Visit(e->obj()); |
| Visit(e->key()); |
| } |
| |
| |
| void ATAV::VisitCall(Call* e) { |
| Visit(e->expression()); |
| VisitExpressions(e->arguments()); |
| } |
| |
| |
| void ATAV::VisitCallRuntime(CallRuntime* e) { |
| VisitExpressions(e->arguments()); |
| } |
| |
| |
| void ATAV::VisitUnaryOperation(UnaryOperation* e) { Visit(e->expression()); } |
| |
| |
| void ATAV::VisitBinaryOperation(BinaryOperation* e) { |
| Visit(e->left()); |
| Visit(e->right()); |
| } |
| |
| |
| void ATAV::VisitCompareOperation(CompareOperation* e) { |
| Visit(e->left()); |
| Visit(e->right()); |
| } |
| |
| |
| void ATAV::VisitCaseClause(CaseClause* cc) { |
| if (!cc->is_default()) Visit(cc->label()); |
| VisitStatements(cc->statements()); |
| } |
| |
| |
| void ATAV::VisitModuleStatement(ModuleStatement* stmt) { Visit(stmt->body()); } |
| |
| |
| void ATAV::VisitTryCatchStatement(TryCatchStatement* stmt) { |
| Visit(stmt->try_block()); |
| Visit(stmt->catch_block()); |
| } |
| |
| |
| void ATAV::VisitDoWhileStatement(DoWhileStatement* loop) { |
| Visit(loop->body()); |
| Visit(loop->cond()); |
| } |
| |
| |
| void ATAV::VisitWhileStatement(WhileStatement* loop) { |
| Visit(loop->cond()); |
| Visit(loop->body()); |
| } |
| |
| |
| void ATAV::VisitForStatement(ForStatement* loop) { |
| VisitIfNotNull(loop->init()); |
| VisitIfNotNull(loop->cond()); |
| Visit(loop->body()); |
| VisitIfNotNull(loop->next()); |
| } |
| |
| |
| void ATAV::VisitForInStatement(ForInStatement* loop) { |
| Visit(loop->each()); |
| Visit(loop->subject()); |
| Visit(loop->body()); |
| } |
| |
| |
| void ATAV::VisitForOfStatement(ForOfStatement* loop) { |
| Visit(loop->each()); |
| Visit(loop->subject()); |
| Visit(loop->body()); |
| } |
| |
| |
| void ATAV::VisitAssignment(Assignment* stmt) { |
| Expression* l = stmt->target(); |
| Visit(l); |
| Visit(stmt->value()); |
| } |
| |
| |
| void ATAV::VisitCountOperation(CountOperation* e) { |
| Expression* l = e->expression(); |
| Visit(l); |
| } |
| } |
| } // namespace v8::internal |