Set up rewriting triggers

src/parsing/parser.cc

 // 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.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-visitor.h"
 #include "src/ast/ast-literal-reindexer.h"
@@ skipping 4732 matching lines @@
         proxy, CONST, block_scope, pos, is_class_declaration,
         scope_->class_declaration_group_start());
     Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   }
 
   Expression* extends = NULL;
   if (Check(Token::EXTENDS)) {
     block_scope->set_start_position(scanner()->location().end_pos);
     ExpressionClassifier classifier;
     extends = ParseLeftHandSideExpression(&classifier, CHECK_OK);
-    ValidateExpression(&classifier, CHECK_OK);
-    extends = ParserTraits::RewriteExpression(extends);
+    extends = ParserTraits::RewriteExpression(extends, &classifier, CHECK_OK);
   } else {
     block_scope->set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
   ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4, zone());
   FunctionLiteral* constructor = NULL;
   bool has_seen_constructor = false;
 
   Expect(Token::LBRACE, CHECK_OK);
 
   const bool has_extends = extends != nullptr;
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
     const bool in_class = true;
     const bool is_static = false;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier classifier;
     const AstRawString* name = nullptr;
     ObjectLiteral::Property* property = ParsePropertyDefinition(
         &checker, in_class, has_extends, is_static, &is_computed_name,
         &has_seen_constructor, &classifier, &name, CHECK_OK);
-    ValidateExpression(&classifier, CHECK_OK);
-    property = ParserTraits::RewriteObjectLiteralProperty(property);
+    property = ParserTraits::RewriteObjectLiteralProperty(property, &classifier,
+                                                          CHECK_OK);
 
     if (has_seen_constructor && constructor == NULL) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
     } else {
       properties->Add(property, zone());
     }
 
     if (fni_ != NULL) fni_->Infer();
 
@@ skipping 594 matching lines @@
   SetLanguageMode(scope_,
                   static_cast<LanguageMode>(scope_->language_mode() | mode));
 }
 
 
 void ParserTraits::RewriteDestructuringAssignments() {
   parser_->RewriteDestructuringAssignments();
 }
 
 
-Expression* ParserTraits::RewriteExpression(Expression* expr) {
-  return parser_->RewriteExpression(expr);
+Expression* ParserTraits::RewriteExpression(
+    Expression* expr, const ExpressionClassifier* classifier, bool* ok) {
+  return parser_->RewriteExpression(expr, classifier, ok);
 }
 
 
 ObjectLiteralProperty* ParserTraits::RewriteObjectLiteralProperty(
-    ObjectLiteralProperty* property) {
-  return parser_->RewriteObjectLiteralProperty(property);
+    ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
+    bool* ok) {
+  return parser_->RewriteObjectLiteralProperty(property, classifier, ok);
 }
 
 
-Expression* Parser::RewriteExpression(Expression* expr) {
-  // TODO(nikolaos): For the time being, this does no rewriting at all.
+Expression* Parser::RewriteExpression(Expression* expr,
+                                      const ExpressionClassifier* classifier,
+                                      bool* ok) {
+  // For the time being, this does no rewriting at all.
+  ValidateExpression(classifier, ok);
   return expr;
 }
 
 
 ObjectLiteralProperty* Parser::RewriteObjectLiteralProperty(
-    ObjectLiteralProperty* property) {
+    ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
+    bool* ok) {
   if (property != nullptr) {
-    Expression* key = RewriteExpression(property->key());
+    Expression* key = RewriteExpression(property->key(), classifier, ok);
     property->set_key(key);
-    Expression* value = RewriteExpression(property->value());
+    Expression* value = RewriteExpression(property->value(), classifier, ok);
     property->set_value(value);
   }
   return property;
 }
 
 
 void Parser::RewriteDestructuringAssignments() {
   FunctionState* func = function_state_;
   if (!allow_harmony_destructuring_assignment()) return;
   const List<DestructuringAssignment>& assignments =
@@ skipping 53 matching lines @@
     auto class_literal = value->AsClassLiteral();
     if (class_literal->raw_name() == nullptr) {
       class_literal->set_raw_name(name);
     }
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8