LCOV - code coverage report
Current view: top level - src/ast - ast-expression-rewriter.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 21 188 11.2 %
Date: 2017-04-26 Functions: 8 54 14.8 %

          Line data    Source code
       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-expression-rewriter.h"
       6             : #include "src/ast/ast.h"
       7             : #include "src/objects-inl.h"
       8             : 
       9             : namespace v8 {
      10             : namespace internal {
      11             : 
      12             : // ----------------------------------------------------------------------------
      13             : // Implementation of AstExpressionRewriter
      14             : // The AST is traversed but no actual rewriting takes place, unless the
      15             : // Visit methods are overriden in subclasses.
      16             : 
      17             : #define REWRITE_THIS(node)                \
      18             :   do {                                    \
      19             :     if (!RewriteExpression(node)) return; \
      20             :   } while (false)
      21             : #define NOTHING() DCHECK_NULL(replacement_)
      22             : 
      23           0 : void AstExpressionRewriter::VisitDeclarations(Declaration::List* declarations) {
      24           0 :   for (Declaration::List::Iterator it = declarations->begin();
      25             :        it != declarations->end(); ++it) {
      26           0 :     AST_REWRITE(Declaration, *it, it = replacement);
      27             :   }
      28             : }
      29             : 
      30             : 
      31           0 : void AstExpressionRewriter::VisitStatements(ZoneList<Statement*>* statements) {
      32           0 :   for (int i = 0; i < statements->length(); i++) {
      33           0 :     AST_REWRITE_LIST_ELEMENT(Statement, statements, i);
      34             :     // Not stopping when a jump statement is found.
      35             :   }
      36             : }
      37             : 
      38             : 
      39        3324 : void AstExpressionRewriter::VisitExpressions(
      40        8749 :     ZoneList<Expression*>* expressions) {
      41       24146 :   for (int i = 0; i < expressions->length(); i++) {
      42             :     // The variable statement visiting code may pass NULL expressions
      43             :     // to this code. Maybe this should be handled by introducing an
      44             :     // undefined expression or literal?  Revisit this code if this
      45             :     // changes
      46       20822 :     if (expressions->at(i) != nullptr) {
      47       20822 :       AST_REWRITE_LIST_ELEMENT(Expression, expressions, i);
      48             :     }
      49             :   }
      50             : }
      51             : 
      52             : 
      53           0 : void AstExpressionRewriter::VisitVariableDeclaration(
      54             :     VariableDeclaration* node) {
      55             :   // Not visiting `proxy_`.
      56             :   NOTHING();
      57           0 : }
      58             : 
      59             : 
      60           0 : void AstExpressionRewriter::VisitFunctionDeclaration(
      61           0 :     FunctionDeclaration* node) {
      62             :   // Not visiting `proxy_`.
      63           0 :   AST_REWRITE_PROPERTY(FunctionLiteral, node, fun);
      64             : }
      65             : 
      66             : 
      67           0 : void AstExpressionRewriter::VisitBlock(Block* node) {
      68           0 :   VisitStatements(node->statements());
      69           0 : }
      70             : 
      71             : 
      72           0 : void AstExpressionRewriter::VisitExpressionStatement(
      73           0 :     ExpressionStatement* node) {
      74           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
      75             : }
      76             : 
      77             : 
      78           0 : void AstExpressionRewriter::VisitEmptyStatement(EmptyStatement* node) {
      79             :   NOTHING();
      80           0 : }
      81             : 
      82             : 
      83           0 : void AstExpressionRewriter::VisitSloppyBlockFunctionStatement(
      84           0 :     SloppyBlockFunctionStatement* node) {
      85           0 :   AST_REWRITE_PROPERTY(Statement, node, statement);
      86             : }
      87             : 
      88             : 
      89           0 : void AstExpressionRewriter::VisitIfStatement(IfStatement* node) {
      90           0 :   AST_REWRITE_PROPERTY(Expression, node, condition);
      91           0 :   AST_REWRITE_PROPERTY(Statement, node, then_statement);
      92           0 :   AST_REWRITE_PROPERTY(Statement, node, else_statement);
      93             : }
      94             : 
      95             : 
      96           0 : void AstExpressionRewriter::VisitContinueStatement(ContinueStatement* node) {
      97             :   NOTHING();
      98           0 : }
      99             : 
     100             : 
     101           0 : void AstExpressionRewriter::VisitBreakStatement(BreakStatement* node) {
     102             :   NOTHING();
     103           0 : }
     104             : 
     105             : 
     106           0 : void AstExpressionRewriter::VisitReturnStatement(ReturnStatement* node) {
     107           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     108             : }
     109             : 
     110             : 
     111           0 : void AstExpressionRewriter::VisitWithStatement(WithStatement* node) {
     112           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     113           0 :   AST_REWRITE_PROPERTY(Statement, node, statement);
     114             : }
     115             : 
     116             : 
     117           0 : void AstExpressionRewriter::VisitSwitchStatement(SwitchStatement* node) {
     118           0 :   AST_REWRITE_PROPERTY(Expression, node, tag);
     119             :   ZoneList<CaseClause*>* clauses = node->cases();
     120           0 :   for (int i = 0; i < clauses->length(); i++) {
     121           0 :     AST_REWRITE_LIST_ELEMENT(CaseClause, clauses, i);
     122             :   }
     123             : }
     124             : 
     125             : 
     126           0 : void AstExpressionRewriter::VisitDoWhileStatement(DoWhileStatement* node) {
     127           0 :   AST_REWRITE_PROPERTY(Expression, node, cond);
     128           0 :   AST_REWRITE_PROPERTY(Statement, node, body);
     129             : }
     130             : 
     131             : 
     132           0 : void AstExpressionRewriter::VisitWhileStatement(WhileStatement* node) {
     133           0 :   AST_REWRITE_PROPERTY(Expression, node, cond);
     134           0 :   AST_REWRITE_PROPERTY(Statement, node, body);
     135             : }
     136             : 
     137             : 
     138           0 : void AstExpressionRewriter::VisitForStatement(ForStatement* node) {
     139           0 :   if (node->init() != nullptr) {
     140           0 :     AST_REWRITE_PROPERTY(Statement, node, init);
     141             :   }
     142           0 :   if (node->cond() != nullptr) {
     143           0 :     AST_REWRITE_PROPERTY(Expression, node, cond);
     144             :   }
     145           0 :   if (node->next() != nullptr) {
     146           0 :     AST_REWRITE_PROPERTY(Statement, node, next);
     147             :   }
     148           0 :   AST_REWRITE_PROPERTY(Statement, node, body);
     149             : }
     150             : 
     151             : 
     152           0 : void AstExpressionRewriter::VisitForInStatement(ForInStatement* node) {
     153           0 :   AST_REWRITE_PROPERTY(Expression, node, each);
     154           0 :   AST_REWRITE_PROPERTY(Expression, node, subject);
     155           0 :   AST_REWRITE_PROPERTY(Statement, node, body);
     156             : }
     157             : 
     158             : 
     159           0 : void AstExpressionRewriter::VisitForOfStatement(ForOfStatement* node) {
     160           0 :   AST_REWRITE_PROPERTY(Expression, node, assign_iterator);
     161           0 :   AST_REWRITE_PROPERTY(Expression, node, next_result);
     162           0 :   AST_REWRITE_PROPERTY(Expression, node, result_done);
     163           0 :   AST_REWRITE_PROPERTY(Expression, node, assign_each);
     164           0 :   AST_REWRITE_PROPERTY(Statement, node, body);
     165             : }
     166             : 
     167             : 
     168           0 : void AstExpressionRewriter::VisitTryCatchStatement(TryCatchStatement* node) {
     169           0 :   AST_REWRITE_PROPERTY(Block, node, try_block);
     170             :   // Not visiting the variable.
     171           0 :   AST_REWRITE_PROPERTY(Block, node, catch_block);
     172             : }
     173             : 
     174             : 
     175           0 : void AstExpressionRewriter::VisitTryFinallyStatement(
     176           0 :     TryFinallyStatement* node) {
     177           0 :   AST_REWRITE_PROPERTY(Block, node, try_block);
     178           0 :   AST_REWRITE_PROPERTY(Block, node, finally_block);
     179             : }
     180             : 
     181             : 
     182           0 : void AstExpressionRewriter::VisitDebuggerStatement(DebuggerStatement* node) {
     183             :   NOTHING();
     184           0 : }
     185             : 
     186             : 
     187           0 : void AstExpressionRewriter::VisitFunctionLiteral(FunctionLiteral* node) {
     188           0 :   REWRITE_THIS(node);
     189           0 :   VisitDeclarations(node->scope()->declarations());
     190             :   ZoneList<Statement*>* body = node->body();
     191           0 :   if (body != nullptr) VisitStatements(body);
     192             : }
     193             : 
     194             : 
     195           0 : void AstExpressionRewriter::VisitClassLiteral(ClassLiteral* node) {
     196           0 :   REWRITE_THIS(node);
     197             :   // Not visiting `class_variable_proxy_`.
     198           0 :   if (node->extends() != nullptr) {
     199           0 :     AST_REWRITE_PROPERTY(Expression, node, extends);
     200             :   }
     201           0 :   AST_REWRITE_PROPERTY(FunctionLiteral, node, constructor);
     202             :   ZoneList<typename ClassLiteral::Property*>* properties = node->properties();
     203           0 :   for (int i = 0; i < properties->length(); i++) {
     204           0 :     VisitLiteralProperty(properties->at(i));
     205             :   }
     206             : }
     207             : 
     208           0 : void AstExpressionRewriter::VisitNativeFunctionLiteral(
     209             :     NativeFunctionLiteral* node) {
     210           0 :   REWRITE_THIS(node);
     211             :   NOTHING();
     212             : }
     213             : 
     214             : 
     215           0 : void AstExpressionRewriter::VisitConditional(Conditional* node) {
     216           0 :   REWRITE_THIS(node);
     217           0 :   AST_REWRITE_PROPERTY(Expression, node, condition);
     218           0 :   AST_REWRITE_PROPERTY(Expression, node, then_expression);
     219           0 :   AST_REWRITE_PROPERTY(Expression, node, else_expression);
     220             : }
     221             : 
     222             : 
     223         978 : void AstExpressionRewriter::VisitVariableProxy(VariableProxy* node) {
     224         978 :   REWRITE_THIS(node);
     225             :   NOTHING();
     226             : }
     227             : 
     228             : 
     229        2343 : void AstExpressionRewriter::VisitLiteral(Literal* node) {
     230        2343 :   REWRITE_THIS(node);
     231             :   NOTHING();
     232             : }
     233             : 
     234             : 
     235           0 : void AstExpressionRewriter::VisitRegExpLiteral(RegExpLiteral* node) {
     236           0 :   REWRITE_THIS(node);
     237             :   NOTHING();
     238             : }
     239             : 
     240             : 
     241           0 : void AstExpressionRewriter::VisitObjectLiteral(ObjectLiteral* node) {
     242           0 :   REWRITE_THIS(node);
     243             :   ZoneList<typename ObjectLiteral::Property*>* properties = node->properties();
     244           0 :   for (int i = 0; i < properties->length(); i++) {
     245           0 :     VisitLiteralProperty(properties->at(i));
     246             :   }
     247             : }
     248             : 
     249           0 : void AstExpressionRewriter::VisitLiteralProperty(LiteralProperty* property) {
     250           0 :   if (property == nullptr) return;
     251           0 :   AST_REWRITE_PROPERTY(Expression, property, key);
     252           0 :   AST_REWRITE_PROPERTY(Expression, property, value);
     253             : }
     254             : 
     255             : 
     256        3324 : void AstExpressionRewriter::VisitArrayLiteral(ArrayLiteral* node) {
     257        6648 :   REWRITE_THIS(node);
     258           0 :   VisitExpressions(node->values());
     259             : }
     260             : 
     261             : 
     262           0 : void AstExpressionRewriter::VisitAssignment(Assignment* node) {
     263           0 :   REWRITE_THIS(node);
     264           0 :   AST_REWRITE_PROPERTY(Expression, node, target);
     265           0 :   AST_REWRITE_PROPERTY(Expression, node, value);
     266             : }
     267             : 
     268           0 : void AstExpressionRewriter::VisitSuspend(Suspend* node) {
     269           0 :   REWRITE_THIS(node);
     270           0 :   AST_REWRITE_PROPERTY(Expression, node, generator_object);
     271           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     272             : }
     273             : 
     274             : 
     275           0 : void AstExpressionRewriter::VisitThrow(Throw* node) {
     276           0 :   REWRITE_THIS(node);
     277           0 :   AST_REWRITE_PROPERTY(Expression, node, exception);
     278             : }
     279             : 
     280             : 
     281           0 : void AstExpressionRewriter::VisitProperty(Property* node) {
     282           0 :   REWRITE_THIS(node);
     283           0 :   if (node == nullptr) return;
     284           0 :   AST_REWRITE_PROPERTY(Expression, node, obj);
     285           0 :   AST_REWRITE_PROPERTY(Expression, node, key);
     286             : }
     287             : 
     288             : 
     289          21 : void AstExpressionRewriter::VisitCall(Call* node) {
     290          21 :   REWRITE_THIS(node);
     291           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     292           0 :   VisitExpressions(node->arguments());
     293             : }
     294             : 
     295             : 
     296           0 : void AstExpressionRewriter::VisitCallNew(CallNew* node) {
     297           0 :   REWRITE_THIS(node);
     298           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     299           0 :   VisitExpressions(node->arguments());
     300             : }
     301             : 
     302             : 
     303           0 : void AstExpressionRewriter::VisitCallRuntime(CallRuntime* node) {
     304           0 :   REWRITE_THIS(node);
     305           0 :   VisitExpressions(node->arguments());
     306             : }
     307             : 
     308             : 
     309           0 : void AstExpressionRewriter::VisitUnaryOperation(UnaryOperation* node) {
     310           0 :   REWRITE_THIS(node);
     311           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     312             : }
     313             : 
     314             : 
     315           0 : void AstExpressionRewriter::VisitCountOperation(CountOperation* node) {
     316           0 :   REWRITE_THIS(node);
     317           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     318             : }
     319             : 
     320             : 
     321           0 : void AstExpressionRewriter::VisitBinaryOperation(BinaryOperation* node) {
     322           0 :   REWRITE_THIS(node);
     323           0 :   AST_REWRITE_PROPERTY(Expression, node, left);
     324           0 :   AST_REWRITE_PROPERTY(Expression, node, right);
     325             : }
     326             : 
     327             : 
     328           0 : void AstExpressionRewriter::VisitCompareOperation(CompareOperation* node) {
     329           0 :   REWRITE_THIS(node);
     330           0 :   AST_REWRITE_PROPERTY(Expression, node, left);
     331           0 :   AST_REWRITE_PROPERTY(Expression, node, right);
     332             : }
     333             : 
     334             : 
     335        5397 : void AstExpressionRewriter::VisitSpread(Spread* node) {
     336        5397 :   REWRITE_THIS(node);
     337           0 :   AST_REWRITE_PROPERTY(Expression, node, expression);
     338             : }
     339             : 
     340             : 
     341           0 : void AstExpressionRewriter::VisitThisFunction(ThisFunction* node) {
     342           0 :   REWRITE_THIS(node);
     343             :   NOTHING();
     344             : }
     345             : 
     346             : 
     347           0 : void AstExpressionRewriter::VisitSuperPropertyReference(
     348           0 :     SuperPropertyReference* node) {
     349           0 :   REWRITE_THIS(node);
     350           0 :   AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
     351           0 :   AST_REWRITE_PROPERTY(Expression, node, home_object);
     352             : }
     353             : 
     354             : 
     355           0 : void AstExpressionRewriter::VisitSuperCallReference(SuperCallReference* node) {
     356           0 :   REWRITE_THIS(node);
     357           0 :   AST_REWRITE_PROPERTY(VariableProxy, node, this_var);
     358           0 :   AST_REWRITE_PROPERTY(VariableProxy, node, new_target_var);
     359           0 :   AST_REWRITE_PROPERTY(VariableProxy, node, this_function_var);
     360             : }
     361             : 
     362             : 
     363           0 : void AstExpressionRewriter::VisitCaseClause(CaseClause* node) {
     364           0 :   if (!node->is_default()) {
     365           0 :     AST_REWRITE_PROPERTY(Expression, node, label);
     366             :   }
     367           0 :   VisitStatements(node->statements());
     368             : }
     369             : 
     370             : 
     371           0 : void AstExpressionRewriter::VisitEmptyParentheses(EmptyParentheses* node) {
     372             :   NOTHING();
     373           0 : }
     374             : 
     375           0 : void AstExpressionRewriter::VisitGetIterator(GetIterator* node) {
     376           0 :   AST_REWRITE_PROPERTY(Expression, node, iterable);
     377             : }
     378             : 
     379           0 : void AstExpressionRewriter::VisitImportCallExpression(
     380           0 :     ImportCallExpression* node) {
     381           0 :   REWRITE_THIS(node);
     382           0 :   AST_REWRITE_PROPERTY(Expression, node, argument);
     383             : }
     384             : 
     385          10 : void AstExpressionRewriter::VisitDoExpression(DoExpression* node) {
     386          10 :   REWRITE_THIS(node);
     387           0 :   AST_REWRITE_PROPERTY(Block, node, block);
     388           0 :   AST_REWRITE_PROPERTY(VariableProxy, node, result);
     389             : }
     390             : 
     391             : 
     392        3324 : void AstExpressionRewriter::VisitRewritableExpression(
     393        6648 :     RewritableExpression* node) {
     394        3324 :   REWRITE_THIS(node);
     395        9972 :   AST_REWRITE(Expression, node->expression(), node->Rewrite(replacement));
     396             : }
     397             : 
     398             : 
     399             : }  // namespace internal
     400             : }  // namespace v8

Generated by: LCOV version 1.10