Set up rewriting triggers

src/parsing/parser-base.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 1411 matching lines @@
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
     bool accept_IN, bool* ok) {
   ExpressionClassifier classifier;
   ExpressionT result = ParseExpression(accept_IN, &classifier, CHECK_OK);
   ValidateExpression(&classifier, CHECK_OK);
+  result = Traits::RewriteExpression(result);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
     bool accept_IN, ExpressionClassifier* classifier, bool* ok) {
   return ParseExpression(accept_IN, kIsLeftHandSide, classifier, ok);
 }
 
@@ skipping 145 matching lines @@
       Consume(Token::NUMBER);
       *name = this->GetNumberAsSymbol(scanner());
       break;
 
     case Token::LBRACK: {
       *is_computed_name = true;
       Consume(Token::LBRACK);
       ExpressionClassifier computed_name_classifier;
       ExpressionT expression =
           ParseAssignmentExpression(true, &computed_name_classifier, CHECK_OK);
+      expression = Traits::RewriteExpression(expression);

[rossberg, 2016/01/08 12:22:27]

Do we actually need to do this here? My thinking was that we should only have to
rewrite in places where we resolve an ambiguous parse (i.e., all places that do
ValidateExpression). In the case here (and most others below), there was no
ambiguity, so we can assume that the expression is already in the right shape.
If we invoke this everywhere, wouldn't we end up traversing expressions
exponentially in the worst case?

(Maybe you don't even need a separate RewriteExpression trait function, but can
simply trigger the rewrite in ValidateExpression?)

[nickie, 2016/01/08 13:46:58]

You can look at this as a "non-pattern rewriter".  For spread rewriting, it only
traverses pattern-looking things that are not patterns.

The idea is that such rewriters should only do local work and not go arbitrarily
deep in the tree.  The general invariant is that a rewriter for an expression
tree should avoid visiting subtrees that have already been rewritten as
expressions (unless of course it is required to rewrite them anew).  I thought
that this should be the rewriters' responsibility.  If this invariant is not
obeyed, even if you restrict this to the places where ValidateExpression is
called, you'll still have too many unnecessary traversals.

If we really want to combine this with ValidateExpression, then the spread
rewriter would need to go deeper in the tree.  I'm not sure if in this way it
would be possible to avoid traversing some subtrees twice (which now is indeed
avoided), without keeping track of what has been rewritten and what not.
Yes, depending on the verdict of the previous question.

An alternative way to combine this with ValidateExpression would be to do it the
other way round.  Would it make sense to call ValidateExpression in all places
where RewriteExpression is called?

       classifier->Accumulate(computed_name_classifier,
                              ExpressionClassifier::ExpressionProductions);
       Expect(Token::RBRACK, CHECK_OK);
       return expression;
     }
 
     case Token::ESCAPED_KEYWORD:
       *is_escaped_keyword = true;
       *name = ParseIdentifierNameOrGetOrSet(is_get, is_set, CHECK_OK);
       break;
@@ skipping 93 matching lines @@
 
       ExpressionT lhs = this->ExpressionFromIdentifier(
           *name, next_beg_pos, next_end_pos, scope_, factory());
       CheckDestructuringElement(lhs, classifier, next_beg_pos, next_end_pos);
 
       if (peek() == Token::ASSIGN) {
         Consume(Token::ASSIGN);
         ExpressionClassifier rhs_classifier;
         ExpressionT rhs = this->ParseAssignmentExpression(
             true, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+        rhs = Traits::RewriteExpression(rhs);
         classifier->Accumulate(rhs_classifier,
                                ExpressionClassifier::ExpressionProductions);
         value = factory()->NewAssignment(Token::ASSIGN, lhs, rhs,
                                          RelocInfo::kNoPosition);
         classifier->RecordCoverInitializedNameError(
             Scanner::Location(next_beg_pos, scanner()->location().end_pos),
             MessageTemplate::kInvalidCoverInitializedName);
       } else {
         value = lhs;
       }
@@ skipping 44 matching lines @@
 
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
   }
 
   if (in_class && name_is_static && !is_static) {
     // ClassElement (static)
     //    'static' MethodDefinition
     *name = this->EmptyIdentifier();
-    return ParsePropertyDefinition(checker, true, has_extends, true,
-                                   is_computed_name, nullptr, classifier, name,
-                                   ok);
+    ObjectLiteralPropertyT property = ParsePropertyDefinition(
+        checker, true, has_extends, true, is_computed_name, nullptr, classifier,
+        name, ok);
+    property = Traits::RewriteObjectLiteralProperty(property);
+    return property;
   }
 
   if (is_get || is_set) {
     // MethodDefinition (Accessors)
     //    get PropertyName '(' ')' '{' FunctionBody '}'
     //    set PropertyName '(' PropertySetParameterList ')' '{' FunctionBody '}'
     *name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
@@ skipping 118 matching lines @@
   Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   bool done = (peek() == Token::RPAREN);
   bool was_unspread = false;
   int unspread_sequences_count = 0;
   while (!done) {
     int start_pos = peek_position();
     bool is_spread = Check(Token::ELLIPSIS);
 
     ExpressionT argument = this->ParseAssignmentExpression(
         true, classifier, CHECK_OK_CUSTOM(NullExpressionList));
+    argument = Traits::RewriteExpression(argument);
     if (is_spread) {
       if (!spread_arg.IsValid()) {
         spread_arg.beg_pos = start_pos;
         spread_arg.end_pos = peek_position();
       }
       argument = factory()->NewSpread(argument, start_pos);
     }
     result->Add(argument, zone_);
 
     // unspread_sequences_count is the number of sequences of parameters which
@@ skipping 164 matching lines @@
   }
   int pos = position();
 
   ExpressionClassifier rhs_classifier;
 
   int rhs_flags = flags;
   rhs_flags &= ~(kIsPatternElement | kIsPossibleArrowFormals);
   rhs_flags |= kIsRightHandSide;
   ExpressionT right = this->ParseAssignmentExpression(
       accept_IN, rhs_flags, &rhs_classifier, CHECK_OK);
+  right = Traits::RewriteExpression(right);
   classifier->Accumulate(
       rhs_classifier, ExpressionClassifier::ExpressionProductions |
                           ExpressionClassifier::CoverInitializedNameProduction);
 
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
   // assignment to a property of 'this'. We should probably only add
   // properties if we haven't seen them before. Otherwise we'll
   // probably overestimate the number of properties.
   if (op == Token::ASSIGN && this->IsThisProperty(expression)) {
@@ skipping 51 matching lines @@
         // The above set of tokens is the complete set of tokens that can appear
         // after an AssignmentExpression, and none of them can start an
         // AssignmentExpression.  This allows us to avoid looking for an RHS for
         // a Yield::kSuspend operation, given only one look-ahead token.
         if (kind == Yield::kSuspend)
           break;
         DCHECK_EQ(Yield::kDelegating, kind);
         // Delegating yields require an RHS; fall through.
       default:
         expression = ParseAssignmentExpression(false, classifier, CHECK_OK);
+        expression = Traits::RewriteExpression(expression);
         break;
     }
   }
   if (kind == Yield::kDelegating) {
     // var iterator = subject[Symbol.iterator]();
     // Hackily disambiguate o from o.next and o [Symbol.iterator]().
     // TODO(verwaest): Come up with a better solution.
     expression = this->GetIterator(expression, factory(), pos + 1);
   }
   // Hackily disambiguate o from o.next and o [Symbol.iterator]().
@@ skipping 12 matching lines @@
                                                bool* ok) {
   // ConditionalExpression ::
   //   LogicalOrExpression
   //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression
 
   int pos = peek_position();
   // We start using the binary expression parser for prec >= 4 only!
   ExpressionT expression =
       this->ParseBinaryExpression(4, accept_IN, classifier, CHECK_OK);
   if (peek() != Token::CONDITIONAL) return expression;
+  expression = Traits::RewriteExpression(expression);
   ArrowFormalParametersUnexpectedToken(classifier);
   BindingPatternUnexpectedToken(classifier);
   Consume(Token::CONDITIONAL);
   // In parsing the first assignment expression in conditional
   // expressions we always accept the 'in' keyword; see ECMA-262,
   // section 11.12, page 58.
   ExpressionT left = ParseAssignmentExpression(true, classifier, CHECK_OK);
+  left = Traits::RewriteExpression(left);
   Expect(Token::COLON, CHECK_OK);
   ExpressionT right =
       ParseAssignmentExpression(accept_IN, classifier, CHECK_OK);
+  right = Traits::RewriteExpression(right);
   return factory()->NewConditional(expression, left, right, pos);
 }
 
 
 // Precedence >= 4
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN,
                                           ExpressionClassifier* classifier,
                                           bool* ok) {
   DCHECK(prec >= 4);
   ExpressionT x = this->ParseUnaryExpression(classifier, CHECK_OK);
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
+      x = Traits::RewriteExpression(x);
       BindingPatternUnexpectedToken(classifier);
       ArrowFormalParametersUnexpectedToken(classifier);
       Token::Value op = Next();
       Scanner::Location op_location = scanner()->location();
       int pos = position();
       ExpressionT y =
           ParseBinaryExpression(prec1 + 1, accept_IN, classifier, CHECK_OK);
+      y = Traits::RewriteExpression(y);
 
       if (this->ShortcutNumericLiteralBinaryExpression(&x, y, op, pos,
                                                        factory())) {
         continue;
       }
 
       // For now we distinguish between comparisons and other binary
       // operations.  (We could combine the two and get rid of this
       // code and AST node eventually.)
       if (Token::IsCompareOp(op)) {
@@ skipping 42 matching lines @@
   //   '!' UnaryExpression
 
   Token::Value op = peek();
   if (Token::IsUnaryOp(op)) {
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
 
     op = Next();
     int pos = position();
     ExpressionT expression = ParseUnaryExpression(classifier, CHECK_OK);
+    expression = Traits::RewriteExpression(expression);
 
     if (op == Token::DELETE && is_strict(language_mode())) {
       if (is_strong(language_mode())) {
         ReportMessage(MessageTemplate::kStrongDelete);
         *ok = false;
         return this->EmptyExpression();
       } else if (this->IsIdentifier(expression)) {
         // "delete identifier" is a syntax error in strict mode.
         ReportMessage(MessageTemplate::kStrictDelete);
         *ok = false;
         return this->EmptyExpression();
       }
     }
 
     // Allow Traits do rewrite the expression.
     return this->BuildUnaryExpression(expression, op, pos, factory());
   } else if (Token::IsCountOp(op)) {
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
     op = Next();
     int beg_pos = peek_position();
     ExpressionT expression = this->ParseUnaryExpression(classifier, CHECK_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInPrefixOp, CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
+    expression = Traits::RewriteExpression(expression);
 
     return factory()->NewCountOperation(op,
                                         true /* prefix */,
                                         expression,
                                         position());
 
   } else {
     return this->ParsePostfixExpression(classifier, ok);
   }
 }
@@ skipping 41 matching lines @@
       this->ParseMemberWithNewPrefixesExpression(classifier, CHECK_OK);
 
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         BindingPatternUnexpectedToken(classifier);
         ArrowFormalParametersUnexpectedToken(classifier);
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = ParseExpression(true, classifier, CHECK_OK);
+        index = Traits::RewriteExpression(index);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
+        result = Traits::RewriteExpression(result);
         BindingPatternUnexpectedToken(classifier);
         ArrowFormalParametersUnexpectedToken(classifier);
 
         if (is_strong(language_mode()) && this->IsIdentifier(result) &&
             this->IsEval(this->AsIdentifier(result))) {
           ReportMessage(MessageTemplate::kStrongDirectEval);
           *ok = false;
           return this->EmptyExpression();
         }
         int pos;
@@ skipping 107 matching lines @@
     int new_pos = position();
     ExpressionT result = this->EmptyExpression();
     if (peek() == Token::SUPER) {
       const bool is_new = true;
       result = ParseSuperExpression(is_new, classifier, CHECK_OK);
     } else if (peek() == Token::PERIOD) {
       return ParseNewTargetExpression(CHECK_OK);
     } else {
       result = this->ParseMemberWithNewPrefixesExpression(classifier, CHECK_OK);
     }
+    result = Traits::RewriteExpression(result);
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       Scanner::Location spread_pos;
       typename Traits::Type::ExpressionList args =
           this->ParseArguments(&spread_pos, classifier, CHECK_OK);
 
       if (spread_pos.IsValid()) {
         args = Traits::PrepareSpreadArguments(args);
         result = Traits::SpreadCallNew(result, args, new_pos);
       } else {
@@ skipping 79 matching lines @@
   int pos = position();
   function_state_->set_this_location(scanner()->location());
   ExpressionT this_expr = this->ThisExpression(scope_, factory(), pos);
 
   ExpressionT left = this->EmptyExpression();
   switch (peek()) {
     case Token::LBRACK: {
       Consume(Token::LBRACK);
       int pos = position();
       ExpressionT index = this->ParseExpression(true, classifier, CHECK_OK);
+      index = Traits::RewriteExpression(index);
       left = factory()->NewProperty(this_expr, index, pos);
       if (fni_ != NULL) {
         this->PushPropertyName(fni_, index);
       }
       Expect(Token::RBRACK, CHECK_OK);
       break;
     }
     case Token::PERIOD: {
       Consume(Token::PERIOD);
       int pos = position();
@@ skipping 15 matching lines @@
     ReportMessageAt(function_state_->this_location(),
                     MessageTemplate::kStrongConstructorThis);
     *ok = false;
     return this->EmptyExpression();
   }
   Consume(Token::ASSIGN);
   left = this->MarkExpressionAsAssigned(left);
 
   ExpressionT right =
       this->ParseAssignmentExpression(true, classifier, CHECK_OK);
+  right = Traits::RewriteExpression(right);
   this->CheckAssigningFunctionLiteralToProperty(left, right);
   function_state_->AddProperty();
   if (fni_ != NULL) {
     // Check if the right hand side is a call to avoid inferring a
     // name if we're dealing with "this.a = function(){...}();"-like
     // expression.
     if (!right->IsCall() && !right->IsCallNew()) {
       fni_->Infer();
     } else {
       fni_->RemoveLastFunction();
@@ skipping 136 matching lines @@
   // ('[' Expression ']' | '.' Identifier | TemplateLiteral)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         BindingPatternUnexpectedToken(classifier);
         ArrowFormalParametersUnexpectedToken(classifier);
 
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = this->ParseExpression(true, classifier, CHECK_OK);
+        index = Traits::RewriteExpression(index);
         expression = factory()->NewProperty(expression, index, pos);
         if (fni_ != NULL) {
           this->PushPropertyName(fni_, index);
         }
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
       case Token::PERIOD: {
         BindingPatternUnexpectedToken(classifier);
         ArrowFormalParametersUnexpectedToken(classifier);
@@ skipping 63 matching lines @@
   }
 
   ExpressionT initializer = Traits::EmptyExpression();
   if (!is_rest && allow_harmony_default_parameters() && Check(Token::ASSIGN)) {
     ExpressionClassifier init_classifier;
     initializer = ParseAssignmentExpression(true, &init_classifier, ok);
     if (!*ok) return;
     ValidateExpression(&init_classifier, ok);
     ValidateFormalParameterInitializer(&init_classifier, ok);
     if (!*ok) return;
+    initializer = Traits::RewriteExpression(initializer);
     parameters->is_simple = false;
     classifier->RecordNonSimpleParameter();
   }
 
   Traits::AddFormalParameter(parameters, pattern, initializer,
                              scanner()->location().end_pos, is_rest);
 }
 
 
 template <class Traits>
@@ skipping 152 matching lines @@
         expected_property_count = function_state.expected_property_count();
       }
     } else {
       // Single-expression body
       int pos = position();
       parenthesized_function_ = false;
       ExpressionClassifier classifier;
       ExpressionT expression =
           ParseAssignmentExpression(accept_IN, &classifier, CHECK_OK);
       ValidateExpression(&classifier, CHECK_OK);
+      expression = Traits::RewriteExpression(expression);
       body = this->NewStatementList(1, zone());
       this->AddParameterInitializationBlock(formal_parameters, body, CHECK_OK);
       body->Add(factory()->NewReturnStatement(expression, pos), zone());
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
     }
     super_loc = function_state.super_location();
 
     formal_parameters.scope->set_end_position(scanner()->location().end_pos);
 
@@ skipping 86 matching lines @@
     } else if (next == Token::ILLEGAL) {
       Traits::ReportMessageAt(
           Scanner::Location(position() + 1, peek_position()),
           MessageTemplate::kUnexpectedToken, "ILLEGAL", kSyntaxError);
       *ok = false;
       return Traits::EmptyExpression();
     }
 
     int expr_pos = peek_position();
     ExpressionT expression = this->ParseExpression(true, classifier, CHECK_OK);
+    expression = Traits::RewriteExpression(expression);
     Traits::AddTemplateExpression(&ts, expression);
 
     if (peek() != Token::RBRACE) {
       ReportMessageAt(Scanner::Location(expr_pos, peek_position()),
                       MessageTemplate::kUnterminatedTemplateExpr);
       *ok = false;
       return Traits::EmptyExpression();
     }
 
     // If we didn't die parsing that expression, our next token should be a
@@ skipping 162 matching lines @@
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H