Introduce "expression classifier" to the parser.

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 556 matching lines @@
   // whether it is strict mode future reserved.
   IdentifierT ParseIdentifierOrStrictReservedWord(
       bool* is_strict_reserved,
       bool* ok);
   IdentifierT ParseIdentifierName(bool* ok);
   // Parses an identifier and determines whether or not it is 'get' or 'set'.
   IdentifierT ParseIdentifierNameOrGetOrSet(bool* is_get,
                                             bool* is_set,
                                             bool* ok);
 
-  ExpressionT ParseRegExpLiteral(bool seen_equal, bool* ok);
 
-  ExpressionT ParsePrimaryExpression(bool* ok);
+  class ExpressionClassifier {

[rossberg, 2015/04/22 09:30:47]

Don't we also want is_valid_arrow_parameter_list, to generalise the current
hacks around that?

[Dmitry Lomov (no reviews), 2015/04/22 09:36:55]

Sounds good, but I'd prefer to do that in a separate CL.

+   public:
+    ExpressionClassifier()
+        : expression_error_(Scanner::Location::invalid()),
+          binding_pattern_error_(Scanner::Location::invalid()),
+          assignment_pattern_error_(Scanner::Location::invalid()) {}
+
+    bool is_valid_expression() const {
+      return expression_error_ == Scanner::Location::invalid();
+    }
+
+    bool is_valid_binding_pattern() const {
+      return binding_pattern_error_ == Scanner::Location::invalid();
+    }
+
+    bool is_valid_assignmnent_pattern() const {
+      return assignment_pattern_error_ == Scanner::Location::invalid();
+    }
+
+    void RecordExpressionError(const Scanner::Location& loc) {
+      if (!is_valid_expression()) return;
+      expression_error_ = loc;
+    }
+
+    void RecordBindingPatternError(const Scanner::Location& loc) {
+      if (!is_valid_binding_pattern()) return;
+      binding_pattern_error_ = loc;
+    }
+
+    void RecordAssignmentPatternError(const Scanner::Location& loc) {
+      if (!is_valid_assignmnent_pattern()) return;
+      assignment_pattern_error_ = loc;
+    }
+
+   private:
+    Scanner::Location expression_error_;
+    Scanner::Location binding_pattern_error_;
+    Scanner::Location assignment_pattern_error_;
+  };
+
+  ExpressionT ParseRegExpLiteral(bool seen_equal,
+                                 ExpressionClassifier* classifier, bool* ok);
+
+  ExpressionT ParsePrimaryExpression(ExpressionClassifier* classifier,
+                                     bool* ok);
   ExpressionT ParseExpression(bool accept_IN, bool* ok);
-  ExpressionT ParseArrayLiteral(bool* ok);
+  ExpressionT ParseExpression(bool accept_IN, ExpressionClassifier* classifier,
+                              bool* ok);
+  ExpressionT ParseArrayLiteral(ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParsePropertyName(IdentifierT* name, bool* is_get, bool* is_set,
                                 bool* is_static, bool* is_computed_name,
-                                bool* ok);
-  ExpressionT ParseObjectLiteral(bool* ok);
+                                ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParseObjectLiteral(ExpressionClassifier* classifier, bool* ok);
   ObjectLiteralPropertyT ParsePropertyDefinition(
       ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
       bool is_static, bool* is_computed_name, bool* has_seen_constructor,
+      ExpressionClassifier* classifier, bool* ok);
+  typename Traits::Type::ExpressionList ParseArguments(
+      Scanner::Location* first_spread_pos, ExpressionClassifier* classifier,
       bool* ok);
-  typename Traits::Type::ExpressionList ParseArguments(
-      Scanner::Location* first_spread_pos, bool* ok);
-  ExpressionT ParseAssignmentExpression(bool accept_IN, bool* ok);
-  ExpressionT ParseYieldExpression(bool* ok);
-  ExpressionT ParseConditionalExpression(bool accept_IN, bool* ok);
-  ExpressionT ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
-  ExpressionT ParseUnaryExpression(bool* ok);
-  ExpressionT ParsePostfixExpression(bool* ok);
-  ExpressionT ParseLeftHandSideExpression(bool* ok);
-  ExpressionT ParseMemberWithNewPrefixesExpression(bool* ok);
-  ExpressionT ParseMemberExpression(bool* ok);
-  ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
-                                                bool* ok);
+  ExpressionT ParseAssignmentExpression(bool accept_IN,
+                                        ExpressionClassifier* classifier,
+                                        bool* ok);
+  ExpressionT ParseYieldExpression(ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParseConditionalExpression(bool accept_IN,
+                                         ExpressionClassifier* classifier,
+                                         bool* ok);
+  ExpressionT ParseBinaryExpression(int prec, bool accept_IN,
+                                    ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParseUnaryExpression(ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParsePostfixExpression(ExpressionClassifier* classifier,
+                                     bool* ok);
+  ExpressionT ParseLeftHandSideExpression(ExpressionClassifier* classifier,
+                                          bool* ok);
+  ExpressionT ParseMemberWithNewPrefixesExpression(
+      ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParseMemberExpression(ExpressionClassifier* classifier, bool* ok);
+  ExpressionT ParseMemberExpressionContinuation(
+      ExpressionT expression, ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseArrowFunctionLiteral(int start_pos, ExpressionT params_ast,
+                                        ExpressionClassifier* classifier,
                                         bool* ok);
-  ExpressionT ParseTemplateLiteral(ExpressionT tag, int start, bool* ok);
+  ExpressionT ParseTemplateLiteral(ExpressionT tag, int start,
+                                   ExpressionClassifier* classifier, bool* ok);
   void AddTemplateExpression(ExpressionT);
-  ExpressionT ParseSuperExpression(bool is_new, bool* ok);
+  ExpressionT ParseSuperExpression(bool is_new,
+                                   ExpressionClassifier* classifier, bool* ok);
 
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
       Scanner::Location location, const char* message, bool* ok);
 
   // Used to validate property names in object literals and class literals
   enum PropertyKind {
@@ skipping 1305 matching lines @@
                                                   bool* ok) {
   IdentifierT result = ParseIdentifierName(ok);
   if (!*ok) return Traits::EmptyIdentifier();
   scanner()->IsGetOrSet(is_get, is_set);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseRegExpLiteral(
-    bool seen_equal, bool* ok) {
+    bool seen_equal, ExpressionClassifier* classifier, bool* ok) {
   int pos = peek_position();
   if (!scanner()->ScanRegExpPattern(seen_equal)) {
     Next();
     ReportMessage("unterminated_regexp");
     *ok = false;
     return Traits::EmptyExpression();
   }
 
   int literal_index = function_state_->NextMaterializedLiteralIndex();
 
@@ skipping 16 matching lines @@
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // Used in functions where the return type is not ExpressionT.
 #define CHECK_OK_CUSTOM(x) ok); \
   if (!*ok) return this->x(); \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
+
+#define CHECK_CLASSIFIER_OK  classifier, ok); \

[rossberg, 2015/04/22 09:30:47]

Don't think this macro is worth it. It saves a single character, which doesn't
justify the added obscurity and irregularity...

Unless you plan to merge the ok into the classifier. Not sure if that's
desirable?

[Dmitry Lomov (no reviews), 2015/04/22 09:36:55]

Yes, I think we should merge ok into a classifier - does not make sense to have
both. But I'd perfer to do that in a separate CL as well.

+  if (!*ok) return this->EmptyExpression();   \
+  ((void)0
+#define DUMMY )  // to make indentation work
+#undef DUMMY
+
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParsePrimaryExpression(bool* ok) {
+ParserBase<Traits>::ParsePrimaryExpression(ExpressionClassifier* classifier,
+                                           bool* ok) {
   // PrimaryExpression ::
   //   'this'
   //   'null'
   //   'true'
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
@@ skipping 36 matching lines @@
       break;
     }
 
     case Token::STRING: {
       Consume(Token::STRING);
       result = this->ExpressionFromString(beg_pos, scanner(), factory());
       break;
     }
 
     case Token::ASSIGN_DIV:
-      result = this->ParseRegExpLiteral(true, CHECK_OK);
+      result = this->ParseRegExpLiteral(true, CHECK_CLASSIFIER_OK);
       break;
 
     case Token::DIV:
-      result = this->ParseRegExpLiteral(false, CHECK_OK);
+      result = this->ParseRegExpLiteral(false, CHECK_CLASSIFIER_OK);
       break;
 
     case Token::LBRACK:
-      result = this->ParseArrayLiteral(CHECK_OK);
+      result = this->ParseArrayLiteral(CHECK_CLASSIFIER_OK);
       break;
 
     case Token::LBRACE:
-      result = this->ParseObjectLiteral(CHECK_OK);
+      result = this->ParseObjectLiteral(CHECK_CLASSIFIER_OK);
       break;
 
     case Token::LPAREN:
       Consume(Token::LPAREN);
       if (allow_harmony_arrow_functions() && peek() == Token::RPAREN) {
         // Arrow functions are the only expression type constructions
         // for which an empty parameter list "()" is valid input.
         Consume(Token::RPAREN);
         result = this->ParseArrowFunctionLiteral(
-            beg_pos, this->EmptyArrowParamList(), CHECK_OK);
+            beg_pos, this->EmptyArrowParamList(), CHECK_CLASSIFIER_OK);
       } else {
         // Heuristically try to detect immediately called functions before
         // seeing the call parentheses.
         parenthesized_function_ = (peek() == Token::FUNCTION);
-        result = this->ParseExpression(true, CHECK_OK);
+        result = this->ParseExpression(true, CHECK_CLASSIFIER_OK);
         result->increase_parenthesization_level();
         Expect(Token::RPAREN, CHECK_OK);
       }
       break;
 
     case Token::CLASS: {
       Consume(Token::CLASS);
       if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
         ReportMessage("sloppy_lexical", NULL);
         *ok = false;
@@ skipping 10 matching lines @@
       }
       result = this->ParseClassLiteral(name, class_name_location,
                                        is_strict_reserved_name,
                                        class_token_position, CHECK_OK);
       break;
     }
 
     case Token::TEMPLATE_SPAN:
     case Token::TEMPLATE_TAIL:
       result = this->ParseTemplateLiteral(Traits::NoTemplateTag(), beg_pos,
-                                          CHECK_OK);
+                                          CHECK_CLASSIFIER_OK);
       break;
 
     case Token::MOD:
       if (allow_natives() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
     default: {
       Next();
       ReportUnexpectedToken(token);
       *ok = false;
     }
   }
 
   return result;
 }
 
+
+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);
+  // TODO(dslomov): report error if not a valid expression.
+  return result;
+}
+
+
 // Precedence = 1
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
-    bool accept_IN, bool* ok) {
+    bool accept_IN, ExpressionClassifier* classifier, bool* ok) {
   // Expression ::
   //   AssignmentExpression
   //   Expression ',' AssignmentExpression
 
-  ExpressionT result = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
+  ExpressionT result =
+      this->ParseAssignmentExpression(accept_IN, CHECK_CLASSIFIER_OK);
   while (peek() == Token::COMMA) {
     Expect(Token::COMMA, CHECK_OK);
     int pos = position();
-    ExpressionT right = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
+    ExpressionT right =
+        this->ParseAssignmentExpression(accept_IN, CHECK_CLASSIFIER_OK);
     result = factory()->NewBinaryOperation(Token::COMMA, result, right, pos);
   }
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseArrayLiteral(
-    bool* ok) {
+    ExpressionClassifier* classifier, bool* ok) {
   // ArrayLiteral ::
   //   '[' Expression? (',' Expression?)* ']'
 
   int pos = peek_position();
   typename Traits::Type::ExpressionList values =
       this->NewExpressionList(4, zone_);
   Expect(Token::LBRACK, CHECK_OK);
   while (peek() != Token::RBRACK) {
     ExpressionT elem = this->EmptyExpression();
     if (peek() == Token::COMMA) {
       if (is_strong(language_mode())) {
         ReportMessageAt(scanner()->peek_location(), "strong_ellision");
         *ok = false;
         return this->EmptyExpression();
       }
       elem = this->GetLiteralTheHole(peek_position(), factory());
     } else {
-      elem = this->ParseAssignmentExpression(true, CHECK_OK);
+      elem = this->ParseAssignmentExpression(true, CHECK_CLASSIFIER_OK);
     }
     values->Add(elem, zone_);
     if (peek() != Token::RBRACK) {
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RBRACK, CHECK_OK);
 
   // Update the scope information before the pre-parsing bailout.
   int literal_index = function_state_->NextMaterializedLiteralIndex();
 
   return factory()->NewArrayLiteral(values, literal_index, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParsePropertyName(
     IdentifierT* name, bool* is_get, bool* is_set, bool* is_static,
-    bool* is_computed_name, bool* ok) {
+    bool* is_computed_name, ExpressionClassifier* classifier, bool* ok) {
   Token::Value token = peek();
   int pos = peek_position();
 
   // For non computed property names we normalize the name a bit:
   //
   //   "12" -> 12
   //   12.3 -> "12.3"
   //   12.30 -> "12.3"
   //   identifier -> "identifier"
   //
@@ skipping 12 matching lines @@
 
     case Token::NUMBER:
       Consume(Token::NUMBER);
       *name = this->GetNumberAsSymbol(scanner());
       break;
 
     case Token::LBRACK:
       if (allow_harmony_computed_property_names_) {
         *is_computed_name = true;
         Consume(Token::LBRACK);
-        ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
+        ExpressionT expression =
+            ParseAssignmentExpression(true, CHECK_CLASSIFIER_OK);
         Expect(Token::RBRACK, CHECK_OK);
         return expression;
       }
 
     // Fall through.
     case Token::STATIC:
       *is_static = true;
 
     // Fall through.
     default:
       *name = ParseIdentifierNameOrGetOrSet(is_get, is_set, CHECK_OK);
       break;
   }
 
   uint32_t index;
   return this->IsArrayIndex(*name, &index)
              ? factory()->NewNumberLiteral(index, pos)
              : factory()->NewStringLiteral(*name, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT
-ParserBase<Traits>::ParsePropertyDefinition(ObjectLiteralCheckerBase* checker,
-                                            bool in_class, bool has_extends,
-                                            bool is_static,
-                                            bool* is_computed_name,
-                                            bool* has_seen_constructor,
-                                            bool* ok) {
+ParserBase<Traits>::ParsePropertyDefinition(
+    ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
+    bool is_static, bool* is_computed_name, bool* has_seen_constructor,
+    ExpressionClassifier* classifier, bool* ok) {
   DCHECK(!in_class || is_static || has_seen_constructor != nullptr);
   ExpressionT value = this->EmptyExpression();
   IdentifierT name = this->EmptyIdentifier();
   bool is_get = false;
   bool is_set = false;
   bool name_is_static = false;
   bool is_generator = allow_harmony_object_literals_ && Check(Token::MUL);
 
   Token::Value name_token = peek();
   int next_beg_pos = scanner()->peek_location().beg_pos;
   int next_end_pos = scanner()->peek_location().end_pos;
   ExpressionT name_expression = ParsePropertyName(
-      &name, &is_get, &is_set, &name_is_static, is_computed_name,
+      &name, &is_get, &is_set, &name_is_static, is_computed_name, classifier,
       CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   if (fni_ != nullptr && !*is_computed_name) {
     this->PushLiteralName(fni_, name);
   }
 
   if (!in_class && !is_generator && peek() == Token::COLON) {
     // PropertyDefinition : PropertyName ':' AssignmentExpression
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kValueProperty, is_static,
                              is_generator,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
     Consume(Token::COLON);
     value = this->ParseAssignmentExpression(
-        true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+        true, classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   } else if (is_generator ||
              (allow_harmony_object_literals_ && peek() == Token::LPAREN)) {
     // Concise Method
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kMethodProperty, is_static,
                              is_generator,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
@@ skipping 15 matching lines @@
         FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
 
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
     return ParsePropertyDefinition(checker, true, has_extends, true,
-                                   is_computed_name, nullptr, ok);
+                                   is_computed_name, nullptr, classifier, ok);
   } else if (is_get || is_set) {
     // Accessor
     name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
     name_expression = ParsePropertyName(
-        &name, &dont_care, &dont_care, &dont_care, is_computed_name,
+        &name, &dont_care, &dont_care, &dont_care, is_computed_name, classifier,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kAccessorProperty, is_static,
                              is_generator,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
     FunctionKind kind = FunctionKind::kAccessorFunction;
     if (!in_class) kind = WithObjectLiteralBit(kind);
@@ skipping 34 matching lines @@
     return this->EmptyObjectLiteralProperty();
   }
 
   return factory()->NewObjectLiteralProperty(name_expression, value, is_static,
                                              *is_computed_name);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
-    bool* ok) {
+    ExpressionClassifier* classifier, bool* ok) {
   // ObjectLiteral ::
   // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
 
   int pos = peek_position();
   typename Traits::Type::PropertyList properties =
       this->NewPropertyList(4, zone_);
   int number_of_boilerplate_properties = 0;
   bool has_function = false;
   bool has_computed_names = false;
   ObjectLiteralChecker checker(this);
 
   Expect(Token::LBRACE, CHECK_OK);
 
   while (peek() != Token::RBRACE) {
     if (fni_ != nullptr) fni_->Enter();
 
     const bool in_class = false;
     const bool is_static = false;
     const bool has_extends = false;
     bool is_computed_name = false;
     ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
         &checker, in_class, has_extends, is_static, &is_computed_name, NULL,
-        CHECK_OK);
+        CHECK_CLASSIFIER_OK);
 
     if (is_computed_name) {
       has_computed_names = true;
     }
 
     // Mark top-level object literals that contain function literals and
     // pretenure the literal so it can be added as a constant function
     // property. (Parser only.)
     this->CheckFunctionLiteralInsideTopLevelObjectLiteral(scope_, property,
                                                           &has_function);
@@ skipping 22 matching lines @@
   return factory()->NewObjectLiteral(properties,
                                      literal_index,
                                      number_of_boilerplate_properties,
                                      has_function,
                                      pos);
 }
 
 
 template <class Traits>
 typename Traits::Type::ExpressionList ParserBase<Traits>::ParseArguments(
-    Scanner::Location* first_spread_arg_loc, bool* ok) {
+    Scanner::Location* first_spread_arg_loc, ExpressionClassifier* classifier,
+    bool* ok) {
   // Arguments ::
   //   '(' (AssignmentExpression)*[','] ')'
 
   Scanner::Location spread_arg = Scanner::Location::invalid();
   typename Traits::Type::ExpressionList result =
       this->NewExpressionList(4, zone_);
   Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   bool done = (peek() == Token::RPAREN);
   bool was_unspread = false;
   int unspread_sequences_count = 0;
   while (!done) {
     bool is_spread = allow_harmony_spreadcalls() && (peek() == Token::ELLIPSIS);
     int start_pos = peek_position();
     if (is_spread) Consume(Token::ELLIPSIS);
 
     ExpressionT argument = this->ParseAssignmentExpression(
-        true, CHECK_OK_CUSTOM(NullExpressionList));
+        true, 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 29 matching lines @@
     // the parser and preparser
     Traits::MaterializeUnspreadArgumentsLiterals(unspread_sequences_count);
   }
 
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, bool* ok) {
+ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
+                                              ExpressionClassifier* classifier,
+                                              bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
   Scanner::Location lhs_location = scanner()->peek_location();
 
   if (peek() == Token::YIELD && is_generator()) {
-    return this->ParseYieldExpression(ok);
+    return this->ParseYieldExpression(classifier, ok);
   }
 
   if (fni_ != NULL) fni_->Enter();
   ParserBase<Traits>::Checkpoint checkpoint(this);
   ExpressionT expression =
-      this->ParseConditionalExpression(accept_IN, CHECK_OK);
+      this->ParseConditionalExpression(accept_IN, CHECK_CLASSIFIER_OK);
 
   if (allow_harmony_arrow_functions() && peek() == Token::ARROW) {
     checkpoint.Restore();
-    expression = this->ParseArrowFunctionLiteral(lhs_location.beg_pos,
-                                                 expression, CHECK_OK);
+    expression = this->ParseArrowFunctionLiteral(
+        lhs_location.beg_pos, expression, CHECK_CLASSIFIER_OK);
     return expression;
   }
 
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
   expression = this->CheckAndRewriteReferenceExpression(
       expression, lhs_location, "invalid_lhs_in_assignment", CHECK_OK);
   expression = this->MarkExpressionAsAssigned(expression);
 
   Token::Value op = Next();  // Get assignment operator.
   int pos = position();
-  ExpressionT right = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
+  ExpressionT right =
+      this->ParseAssignmentExpression(accept_IN, CHECK_CLASSIFIER_OK);
 
   // 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)) {
     function_state_->AddProperty();
   }
 
@@ skipping 12 matching lines @@
       fni_->RemoveLastFunction();
     }
     fni_->Leave();
   }
 
   return factory()->NewAssignment(op, expression, right, pos);
 }
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseYieldExpression(bool* ok) {
+ParserBase<Traits>::ParseYieldExpression(ExpressionClassifier* classifier,
+                                         bool* ok) {
   // YieldExpression ::
   //   'yield' ([no line terminator] '*'? AssignmentExpression)?
   int pos = peek_position();
   Expect(Token::YIELD, CHECK_OK);
   ExpressionT generator_object =
       factory()->NewVariableProxy(function_state_->generator_object_variable());
   ExpressionT expression = Traits::EmptyExpression();
   Yield::Kind kind = Yield::kSuspend;
   if (!scanner()->HasAnyLineTerminatorBeforeNext()) {
     if (Check(Token::MUL)) kind = Yield::kDelegating;
     switch (peek()) {
       case Token::EOS:
       case Token::SEMICOLON:
       case Token::RBRACE:
       case Token::RBRACK:
       case Token::RPAREN:
       case Token::COLON:
       case Token::COMMA:
         // 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, CHECK_OK);
+        expression = ParseAssignmentExpression(false, CHECK_CLASSIFIER_OK);
         break;
     }
   }
   if (kind == Yield::kDelegating) {
     // var iterator = subject[Symbol.iterator]();
     expression = this->GetIterator(expression, factory());
   }
   typename Traits::Type::YieldExpression yield =
       factory()->NewYield(generator_object, expression, kind, pos);
   if (kind == Yield::kDelegating) {
     yield->set_index(function_state_->NextHandlerIndex());
   }
   return yield;
 }
 
 
 // Precedence = 3
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseConditionalExpression(bool accept_IN, bool* ok) {
+ParserBase<Traits>::ParseConditionalExpression(bool accept_IN,
+                                               ExpressionClassifier* classifier,
+                                               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, CHECK_OK);
+  ExpressionT expression =
+      this->ParseBinaryExpression(4, accept_IN, CHECK_CLASSIFIER_OK);
   if (peek() != Token::CONDITIONAL) return expression;
   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, CHECK_OK);
+  ExpressionT left = ParseAssignmentExpression(true, CHECK_CLASSIFIER_OK);
   Expect(Token::COLON, CHECK_OK);
-  ExpressionT right = ParseAssignmentExpression(accept_IN, CHECK_OK);
+  ExpressionT right = ParseAssignmentExpression(accept_IN, CHECK_CLASSIFIER_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, bool* ok) {
+ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN,
+                                          ExpressionClassifier* classifier,
+                                          bool* ok) {
   DCHECK(prec >= 4);
-  ExpressionT x = this->ParseUnaryExpression(CHECK_OK);
+  ExpressionT x = this->ParseUnaryExpression(CHECK_CLASSIFIER_OK);
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
       Token::Value op = Next();
       Scanner::Location op_location = scanner()->location();
       int pos = position();
-      ExpressionT y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);
+      ExpressionT y =
+          ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_CLASSIFIER_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 20 matching lines @@
         x = factory()->NewBinaryOperation(op, x, y, pos);
       }
     }
   }
   return x;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseUnaryExpression(bool* ok) {
+ParserBase<Traits>::ParseUnaryExpression(ExpressionClassifier* classifier,
+                                         bool* ok) {
   // UnaryExpression ::
   //   PostfixExpression
   //   'delete' UnaryExpression
   //   'void' UnaryExpression
   //   'typeof' UnaryExpression
   //   '++' UnaryExpression
   //   '--' UnaryExpression
   //   '+' UnaryExpression
   //   '-' UnaryExpression
   //   '~' UnaryExpression
   //   '!' UnaryExpression
 
   Token::Value op = peek();
   if (Token::IsUnaryOp(op)) {
     op = Next();
     int pos = position();
-    ExpressionT expression = ParseUnaryExpression(CHECK_OK);
+    ExpressionT expression = ParseUnaryExpression(CHECK_CLASSIFIER_OK);
 
     if (op == Token::DELETE && is_strict(language_mode())) {
       if (is_strong(language_mode())) {
         ReportMessage("strong_delete");
         *ok = false;
         return this->EmptyExpression();
       } else if (this->IsIdentifier(expression)) {
         // "delete identifier" is a syntax error in strict mode.
         ReportMessage("strict_delete");
         *ok = false;
         return this->EmptyExpression();
       }
     }
 
     // Allow Traits do rewrite the expression.
     return this->BuildUnaryExpression(expression, op, pos, factory());
   } else if (Token::IsCountOp(op)) {
     op = Next();
     Scanner::Location lhs_location = scanner()->peek_location();
-    ExpressionT expression = this->ParseUnaryExpression(CHECK_OK);
+    ExpressionT expression = this->ParseUnaryExpression(CHECK_CLASSIFIER_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, "invalid_lhs_in_prefix_op", CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
 
     return factory()->NewCountOperation(op,
                                         true /* prefix */,
                                         expression,
                                         position());
 
   } else {
-    return this->ParsePostfixExpression(ok);
+    return this->ParsePostfixExpression(classifier, ok);
   }
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParsePostfixExpression(bool* ok) {
+ParserBase<Traits>::ParsePostfixExpression(ExpressionClassifier* classifier,
+                                           bool* ok) {
   // PostfixExpression ::
   //   LeftHandSideExpression ('++' | '--')?
 
   Scanner::Location lhs_location = scanner()->peek_location();
-  ExpressionT expression = this->ParseLeftHandSideExpression(CHECK_OK);
+  ExpressionT expression =
+      this->ParseLeftHandSideExpression(CHECK_CLASSIFIER_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, "invalid_lhs_in_postfix_op", CHECK_OK);
     expression = this->MarkExpressionAsAssigned(expression);
 
     Token::Value next = Next();
     expression =
         factory()->NewCountOperation(next,
                                      false /* postfix */,
                                      expression,
                                      position());
   }
   return expression;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseLeftHandSideExpression(bool* ok) {
+ParserBase<Traits>::ParseLeftHandSideExpression(
+    ExpressionClassifier* classifier, bool* ok) {
   // LeftHandSideExpression ::
   //   (NewExpression | MemberExpression) ...
 
-  ExpressionT result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
+  ExpressionT result =
+      this->ParseMemberWithNewPrefixesExpression(CHECK_CLASSIFIER_OK);
 
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         int pos = position();
-        ExpressionT index = ParseExpression(true, CHECK_OK);
+        ExpressionT index = ParseExpression(true, CHECK_CLASSIFIER_OK);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
         if (is_strong(language_mode()) && this->IsIdentifier(result) &&
             this->IsEval(this->AsIdentifier(result))) {
           ReportMessage("strong_direct_eval");
           *ok = false;
@@ skipping 13 matching lines @@
           pos = peek_position();
           // Also the trailing parenthesis are a hint that the function will
           // be called immediately. If we happen to have parsed a preceding
           // function literal eagerly, we can also compile it eagerly.
           if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             result->AsFunctionLiteral()->set_parenthesized();
           }
         }
         Scanner::Location spread_pos;
         typename Traits::Type::ExpressionList args =
-            ParseArguments(&spread_pos, CHECK_OK);
+            ParseArguments(&spread_pos, CHECK_CLASSIFIER_OK);
 
         // Keep track of eval() calls since they disable all local variable
         // optimizations.
         // The calls that need special treatment are the
         // direct eval calls. These calls are all of the form eval(...), with
         // no explicit receiver.
         // These calls are marked as potentially direct eval calls. Whether
         // they are actually direct calls to eval is determined at run time.
         this->CheckPossibleEvalCall(result, scope_);
 
@@ skipping 19 matching lines @@
 
       default:
         return result;
     }
   }
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseMemberWithNewPrefixesExpression(bool* ok) {
+ParserBase<Traits>::ParseMemberWithNewPrefixesExpression(
+    ExpressionClassifier* classifier, bool* ok) {
   // NewExpression ::
   //   ('new')+ MemberExpression
 
   // The grammar for new expressions is pretty warped. We can have several 'new'
   // keywords following each other, and then a MemberExpression. When we see '('
   // after the MemberExpression, it's associated with the rightmost unassociated
   // 'new' to create a NewExpression with arguments. However, a NewExpression
   // can also occur without arguments.
 
   // Examples of new expression:
   // new foo.bar().baz means (new (foo.bar)()).baz
   // new foo()() means (new foo())()
   // new new foo()() means (new (new foo())())
   // new new foo means new (new foo)
   // new new foo() means new (new foo())
   // new new foo().bar().baz means (new (new foo()).bar()).baz
 
   if (peek() == Token::NEW) {
     Consume(Token::NEW);
     int new_pos = position();
     ExpressionT result = this->EmptyExpression();
     if (peek() == Token::SUPER) {
       const bool is_new = true;
-      result = ParseSuperExpression(is_new, CHECK_OK);
+      result = ParseSuperExpression(is_new, CHECK_CLASSIFIER_OK);
     } else {
-      result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
+      result = this->ParseMemberWithNewPrefixesExpression(CHECK_CLASSIFIER_OK);
     }
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       Scanner::Location spread_pos;
       typename Traits::Type::ExpressionList args =
-          this->ParseArguments(&spread_pos, CHECK_OK);
+          this->ParseArguments(&spread_pos, CHECK_CLASSIFIER_OK);
 
       if (spread_pos.IsValid()) {
         args = Traits::PrepareSpreadArguments(args);
         result = Traits::SpreadCallNew(result, args, new_pos);
       } else {
         result = factory()->NewCallNew(result, args, new_pos);
       }
       // The expression can still continue with . or [ after the arguments.
-      result = this->ParseMemberExpressionContinuation(result, CHECK_OK);
+      result =
+          this->ParseMemberExpressionContinuation(result, CHECK_CLASSIFIER_OK);
       return result;
     }
     // NewExpression without arguments.
     return factory()->NewCallNew(result, this->NewExpressionList(0, zone_),
                                  new_pos);
   }
   // No 'new' or 'super' keyword.
-  return this->ParseMemberExpression(ok);
+  return this->ParseMemberExpression(classifier, ok);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseMemberExpression(bool* ok) {
+ParserBase<Traits>::ParseMemberExpression(ExpressionClassifier* classifier,
+                                          bool* ok) {
   // MemberExpression ::
   //   (PrimaryExpression | FunctionLiteral | ClassLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)*
 
   // The '[' Expression ']' and '.' Identifier parts are parsed by
   // ParseMemberExpressionContinuation, and the Arguments part is parsed by the
   // caller.
 
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
@@ skipping 13 matching lines @@
       function_type = FunctionLiteral::NAMED_EXPRESSION;
     }
     result = this->ParseFunctionLiteral(
         name, function_name_location, is_strict_reserved_name,
         is_generator ? FunctionKind::kGeneratorFunction
                      : FunctionKind::kNormalFunction,
         function_token_position, function_type, FunctionLiteral::NORMAL_ARITY,
         CHECK_OK);
   } else if (peek() == Token::SUPER) {
     const bool is_new = false;
-    result = ParseSuperExpression(is_new, CHECK_OK);
+    result = ParseSuperExpression(is_new, CHECK_CLASSIFIER_OK);
   } else {
-    result = ParsePrimaryExpression(CHECK_OK);
+    result = ParsePrimaryExpression(CHECK_CLASSIFIER_OK);
   }
 
-  result = ParseMemberExpressionContinuation(result, CHECK_OK);
+  result = ParseMemberExpressionContinuation(result, CHECK_CLASSIFIER_OK);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseSuperExpression(bool is_new, bool* ok) {
+ParserBase<Traits>::ParseSuperExpression(bool is_new,
+                                         ExpressionClassifier* classifier,
+                                         bool* ok) {
   Expect(Token::SUPER, CHECK_OK);
 
   FunctionState* function_state = function_state_;
   while (IsArrowFunction(function_state->kind())) {
     function_state = function_state->outer();
   }
   // TODO(arv): Handle eval scopes similarly.
 
   FunctionKind kind = function_state->kind();
   if (IsConciseMethod(kind) || IsAccessorFunction(kind) ||
@@ skipping 23 matching lines @@
   }
 
   ReportMessageAt(scanner()->location(), "unexpected_super");
   *ok = false;
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseMemberExpressionContinuation(ExpressionT expression,
-                                                      bool* ok) {
+ParserBase<Traits>::ParseMemberExpressionContinuation(
+    ExpressionT expression, ExpressionClassifier* classifier, bool* ok) {
   // Parses this part of MemberExpression:
   // ('[' Expression ']' | '.' Identifier | TemplateLiteral)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         int pos = position();
-        ExpressionT index = this->ParseExpression(true, CHECK_OK);
+        ExpressionT index = this->ParseExpression(true, CHECK_CLASSIFIER_OK);
         expression = factory()->NewProperty(expression, 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 11 matching lines @@
         if (scanner()->current_token() == Token::IDENTIFIER) {
           pos = position();
         } else {
           pos = peek_position();
           if (expression->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             // If the tag function looks like an IIFE, set_parenthesized() to
             // force eager compilation.
             expression->AsFunctionLiteral()->set_parenthesized();
           }
         }
-        expression = ParseTemplateLiteral(expression, pos, CHECK_OK);
+        expression = ParseTemplateLiteral(expression, pos, CHECK_CLASSIFIER_OK);
         break;
       }
       default:
         return expression;
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseArrowFunctionLiteral(int start_pos,
                                               ExpressionT params_ast,
+                                              ExpressionClassifier* classifier,
                                               bool* ok) {
   if (peek() == Token::ARROW && scanner_->HasAnyLineTerminatorBeforeNext()) {
     // ASI inserts `;` after arrow parameters if a line terminator is found.
     // `=> ...` is never a valid expression, so report as syntax error.
     // If next token is not `=>`, it's a syntax error anyways.
     ReportUnexpectedTokenAt(scanner_->peek_location(), Token::ARROW);
     *ok = false;
     return this->EmptyExpression();
   }
 
@@ skipping 51 matching lines @@
             Token::INIT_VAR, kArrowFunction, CHECK_OK);
         materialized_literal_count =
             function_state.materialized_literal_count();
         expected_property_count = function_state.expected_property_count();
         handler_count = function_state.handler_count();
       }
     } else {
       // Single-expression body
       int pos = position();
       parenthesized_function_ = false;
-      ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
+      ExpressionT expression =
+          ParseAssignmentExpression(true, CHECK_CLASSIFIER_OK);
       body = this->NewStatementList(1, zone());
       body->Add(factory()->NewReturnStatement(expression, pos), zone());
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
     }
     super_loc = function_state.super_call_location();
 
     scope->set_start_position(start_pos);
     scope->set_end_position(scanner()->location().end_pos);
@@ skipping 28 matching lines @@
   if (super_loc.IsValid()) function_state_->set_super_call_location(super_loc);
 
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
 
   return function_literal;
 }
 
 
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseTemplateLiteral(ExpressionT tag, int start, bool* ok) {
+ParserBase<Traits>::ParseTemplateLiteral(ExpressionT tag, int start,
+                                         ExpressionClassifier* classifier,
+                                         bool* ok) {
   // A TemplateLiteral is made up of 0 or more TEMPLATE_SPAN tokens (literal
   // text followed by a substitution expression), finalized by a single
   // TEMPLATE_TAIL.
   //
   // In terms of draft language, TEMPLATE_SPAN may be either the TemplateHead or
   // TemplateMiddle productions, while TEMPLATE_TAIL is either TemplateTail, or
   // NoSubstitutionTemplate.
   //
   // When parsing a TemplateLiteral, we must have scanned either an initial
   // TEMPLATE_SPAN, or a TEMPLATE_TAIL.
@@ skipping 31 matching lines @@
       return Traits::EmptyExpression();
     } else if (next == Token::ILLEGAL) {
       Traits::ReportMessageAt(
           Scanner::Location(position() + 1, peek_position()),
           "unexpected_token", "ILLEGAL", kSyntaxError);
       *ok = false;
       return Traits::EmptyExpression();
     }
 
     int expr_pos = peek_position();
-    ExpressionT expression = this->ParseExpression(true, CHECK_OK);
+    ExpressionT expression = this->ParseExpression(true, CHECK_CLASSIFIER_OK);
     Traits::AddTemplateExpression(&ts, expression);
 
     if (peek() != Token::RBRACE) {
       ReportMessageAt(Scanner::Location(expr_pos, peek_position()),
                       "unterminated_template_expr");
       *ok = false;
       return Traits::EmptyExpression();
     }
 
     // If we didn't die parsing that expression, our next token should be a
@@ skipping 111 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H