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 1019 matching lines @@
   ExpressionClassifier classifier;
   auto result = ParseAndClassifyIdentifier(&classifier, ok);
   if (!*ok) return Traits::EmptyIdentifier();
 
   if (allow_restricted_identifiers == kDontAllowRestrictedIdentifiers) {
     ValidateAssignmentPattern(&classifier, ok);
     if (!*ok) return Traits::EmptyIdentifier();
     ValidateBindingPattern(&classifier, ok);
     if (!*ok) return Traits::EmptyIdentifier();
   } else {
+#if 0  // TODO(nikolaos): is this needed?

[rossberg, 2016/01/12 13:47:52]

Yes, this is needed -- ParseAndClassifyIdentifier may set expression errors in
some cases (e.g. using `arguments` in strong mode).

[nickie, 2016/01/12 14:12:32]

Acknowledged.  I'm adding a test for this.

[nickie, 2016/01/12 15:16:09]

Cannot find a test for this.  This is the "else" case, when the use of
restricted identifiers is allowed.  Is there something to validate in this case?

[rossberg, 2016/01/14 13:28:40]

Yes, I don't understand why this is the else case either. Shouldn't it occur in
the then case?

[nickie, 2016/01/14 14:47:14]

In the "then" case there is some validation.  But this thing is just an
identifier and not yet found to be a non-pattern, so no rewriting must take
place there (and I believe that calling ValidateExpression would be wrong).  On
top of everything, we're talking about rewriting an identifier which will
probably never be non-trivial...

     ValidateExpression(&classifier, ok);
     if (!*ok) return Traits::EmptyIdentifier();
+#endif
   }
 
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::IdentifierT
 ParserBase<Traits>::ParseAndClassifyIdentifier(ExpressionClassifier* classifier,
                                                bool* ok) {
@@ skipping 295 matching lines @@
         Expect(Token::RPAREN, CHECK_OK);
         return factory()->NewSpread(expr, ellipsis_pos);
       }
       // Heuristically try to detect immediately called functions before
       // seeing the call parentheses.
       parenthesized_function_ = (peek() == Token::FUNCTION);
       ExpressionT expr = this->ParseExpression(true, kIsPossibleArrowFormals,
                                                classifier, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       if (peek() != Token::ARROW) {
+#if 0  // TODO(nikolaos): is this needed?

[rossberg, 2016/01/12 13:47:52]

Isn't this needed to catch syntax errors like "(());"? Why is Rewrite not needed
here?

[caitp (gmail), 2016/01/12 13:50:39]

This is needed to catch things like CoverInitializedNames in things that didn't
turn out to be Arrow formal parameters

[nickie, 2016/01/12 14:12:32]

Acknowledged.  I'm adding a test for this.

[nickie, 2016/01/12 15:16:09]

Cannot find a test for this either.  It seems to me that errors like "(())" will
be caught when this whole thing is rewritten and validated.  This may be at the
place where somebody called ParsePrimaryExpression, or indeed at the place where
somebody called a chain that is a suffix of:

    ParseExpression
    ParseAssignmentExpression
    ParseConditionalExpression
    ParseBinaryExpression
    ParseUnaryExpression
    ParsePostfixExpression
    ParseLeftHandSideExpression
    ParseMemberExpressionWithNewPrefixesExpression
    ParseMemberExpression
    ParsePrimaryExpression

[nickie, 2016/01/13 10:26:06]

After Caitlin's patch for parenthesized patterns, I believe this is not needed
anymore.  It doesn't hurt much to have a validate-and-rewrite here, but notice
that this expression will certainly be (validated and) rewritten again, so we're
sort of violating our invariant that this non-pattern rewriting phase should be
kept as "shallow" as possible.

[rossberg, 2016/01/14 13:28:40]

Hm, I wonder if it isn't a broader shortcoming that parenthesised get rewritten
again (also in other cases). Shouldn't RewriteNonPattern stop when it hits an
expression with the is_parenthesised flag?

[nickie, 2016/01/14 14:47:14]

There's two approaches, as I understand it.  Either we remove the validation
from here and change nothing else, or we add the validation here and we have
RewriteNonPattern stop when it hits expressions with the is_parenthesised flag
set.  I have taken the first approach, see here:

https://codereview.chromium.org/1567603005/diff/100001/src/parsing/parser-bas...

but if you prefer the second, I can change it.

[caitp (gmail), 2016/01/14 15:06:25]

Just a note about why the ValidateExpression was originally added, it was
because the ParseExpression method was changed from one that did its own
ValidateExpression(), to one that doesn't (because arrow formals needed to be
validated differently).

For whatever reason, it seems that the correct validation is happening
elsewhere. So, so long as you can't write `({ x = 10 });` or `({ x: { y = 10 }
});` without a SyntaxError, it should be fine to just remove the validation.

This is unrelated to the parenthesized flag, it's all making sure
ExpressionErrors are only emitted in an Expression context, and at this point
it's ambiguous whether it's an Expression context or not, until the `=>` is seen
or not seen

         ValidateExpression(classifier, CHECK_OK);
+#endif
         expr->set_is_parenthesized();
       }
       return expr;
     }
 
     case Token::CLASS: {
       BindingPatternUnexpectedToken(classifier);
       Consume(Token::CLASS);
       if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
         ReportMessage(MessageTemplate::kSloppyLexical);
@@ skipping 44 matching lines @@
   *ok = false;
   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);
+  result = Traits::RewriteExpression(result, &classifier, CHECK_OK);
   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);
+      expression = Traits::RewriteExpression(
+          expression, &computed_name_classifier, CHECK_OK);
       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);
+        rhs = Traits::RewriteExpression(
+            rhs, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         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 47 matching lines @@
                                                is_static, *is_computed_name);
   }
 
   if (in_class && name_is_static && !is_static) {
     // ClassElement (static)
     //    'static' MethodDefinition
     *name = this->EmptyIdentifier();
     ObjectLiteralPropertyT property = ParsePropertyDefinition(
         checker, true, has_extends, true, is_computed_name, nullptr, classifier,
         name, ok);
-    property = Traits::RewriteObjectLiteralProperty(property);
+    property = Traits::RewriteObjectLiteralProperty(property, classifier, ok);
     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 119 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);
+    argument = Traits::RewriteExpression(argument, classifier,
+                                         CHECK_OK_CUSTOM(NullExpressionList));
     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 118 matching lines @@
   bool maybe_pattern =
       (expression->IsObjectLiteral() || expression->IsArrayLiteral()) &&
       !expression->is_parenthesized();
 
   if (!Token::IsAssignmentOp(peek())) {
     // Parsed conditional expression only (no assignment).
     if (is_pattern_element) {
       CheckDestructuringElement(expression, classifier, lhs_beg_pos,
                                 scanner()->location().end_pos);
     } else if (is_rhs && maybe_pattern) {
+#if 0  // TODO(nikolaos): is this needed?

[rossberg, 2016/01/12 13:47:52]

Hm, why is it not needed? Don't you even have to do RewriteExpression here?
Can't this arise as "x = ()", for example?

[nickie, 2016/01/12 14:12:32]

I have a RewriteExpression at the place where the RHS of the assignment is
parsed, so now it will be validated there.  Probably the rhs flag is not needed
any more, @caitp?

[caitp (gmail), 2016/01/12 14:25:55]

It looks like you can remove this block, and the flag, but it's possible that
I've missed something

[nickie, 2016/01/12 15:16:09]

Acknowledged.

       ValidateExpression(classifier, CHECK_OK);
+#endif
     }
-
     return expression;
   }
 
   if (!(allow_harmony_destructuring_bind() ||
         allow_harmony_default_parameters())) {
     BindingPatternUnexpectedToken(classifier);
   }
 
   if (allow_harmony_destructuring_assignment() && maybe_pattern &&
       peek() == Token::ASSIGN) {
@@ skipping 24 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);
+  right = Traits::RewriteExpression(right, &rhs_classifier, CHECK_OK);
   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);
+        expression =
+            Traits::RewriteExpression(expression, classifier, CHECK_OK);
         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);
+  expression = Traits::RewriteExpression(expression, classifier, CHECK_OK);
   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);
+  left = Traits::RewriteExpression(left, classifier, CHECK_OK);
   Expect(Token::COLON, CHECK_OK);
   ExpressionT right =
       ParseAssignmentExpression(accept_IN, classifier, CHECK_OK);
-  right = Traits::RewriteExpression(right);
+  right = Traits::RewriteExpression(right, classifier, CHECK_OK);
   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);
+      x = Traits::RewriteExpression(x, classifier, CHECK_OK);
       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);
+      y = Traits::RewriteExpression(y, classifier, CHECK_OK);
 
       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);
+    expression = Traits::RewriteExpression(expression, classifier, CHECK_OK);
 
     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);
+    expression = Traits::RewriteExpression(expression, classifier, CHECK_OK);
 
     return factory()->NewCountOperation(op,
                                         true /* prefix */,
                                         expression,
                                         position());
 
   } else {
     return this->ParsePostfixExpression(classifier, ok);
   }
 }
@@ skipping 11 matching lines @@
       this->ParseLeftHandSideExpression(classifier, CHECK_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
 
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInPostfixOp, CHECK_OK);
     expression = this->MarkExpressionAsAssigned(expression);
+    expression = Traits::RewriteExpression(expression, classifier, CHECK_OK);
 
     Token::Value next = Next();
     expression =
         factory()->NewCountOperation(next,
                                      false /* postfix */,
                                      expression,
                                      position());
   }
   return expression;
 }
@@ skipping 10 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);
+        index = Traits::RewriteExpression(index, classifier, CHECK_OK);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
-        result = Traits::RewriteExpression(result);
+        result = Traits::RewriteExpression(result, classifier, CHECK_OK);
         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);
+    result = Traits::RewriteExpression(result, classifier, CHECK_OK);
     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);
+      index = Traits::RewriteExpression(index, classifier, CHECK_OK);
       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);
+  right = Traits::RewriteExpression(right, classifier, CHECK_OK);
   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);
+        index = Traits::RewriteExpression(index, classifier, CHECK_OK);
         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 60 matching lines @@
     ValidateFormalParameterInitializer(classifier, ok);
     if (!*ok) return;
     classifier->RecordNonSimpleParameter();
   }
 
   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);
+    initializer = Traits::RewriteExpression(initializer, &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 151 matching lines @@
             function_state.materialized_literal_count();
         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);
+      expression = Traits::RewriteExpression(expression, &classifier, CHECK_OK);
       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 85 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);
+    expression = Traits::RewriteExpression(expression, classifier, CHECK_OK);
     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