Revert "Move ParseAssignmentExpression to ParserBase."

src/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 37 matching lines @@
 // Usually defined in math.h, but not in MSVC until VS2013+.
 // Abstracted to work
 int isfinite(double value);
 
 }  // namespace std
 #endif
 
 namespace v8 {
 namespace internal {
 
-
-void PreParserTraits::CheckStrictModeLValue(PreParserExpression expression,
-                                            bool* ok) {
-  if (expression.IsIdentifier() &&
-      expression.AsIdentifier().IsEvalOrArguments()) {
-    pre_parser_->ReportMessage("strict_eval_arguments",
-                               Vector<const char*>::empty());
-    *ok = false;
-  }
-}
-
-
 void PreParserTraits::ReportMessageAt(Scanner::Location location,
                                       const char* message,
                                       Vector<const char*> args) {
   ReportMessageAt(location.beg_pos,
                   location.end_pos,
                   message,
                   args.length() > 0 ? args[0] : NULL);
 }
 
 
@@ skipping 36 matching lines @@
 PreParserExpression PreParserTraits::ExpressionFromString(
     int pos, Scanner* scanner, PreParserFactory* factory) {
   pre_parser_->LogSymbol();
   if (scanner->UnescapedLiteralMatches("use strict", 10)) {
     return PreParserExpression::UseStrictStringLiteral();
   }
   return PreParserExpression::StringLiteral();
 }
 
 
+PreParserExpression PreParserTraits::ParseAssignmentExpression(bool accept_IN,
+                                                               bool* ok) {
+  return pre_parser_->ParseAssignmentExpression(accept_IN, ok);
+}
+
+
 PreParserExpression PreParserTraits::ParseV8Intrinsic(bool* ok) {
   return pre_parser_->ParseV8Intrinsic(ok);
 }
 
 
 PreParserExpression PreParserTraits::ParseFunctionLiteral(
     PreParserIdentifier name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
     bool is_generator,
     int function_token_position,
     FunctionLiteral::FunctionType type,
     bool* ok) {
   return pre_parser_->ParseFunctionLiteral(
       name, function_name_location, name_is_strict_reserved, is_generator,
       function_token_position, type, ok);
 }
 
 
-PreParserExpression PreParserTraits::ParseYieldExpression(bool* ok) {
-  return pre_parser_->ParseYieldExpression(ok);
-}
-
-
-PreParserExpression PreParserTraits::ParseConditionalExpression(bool accept_IN,
-                                                                bool* ok) {
-  return pre_parser_->ParseConditionalExpression(accept_IN, ok);
-}
-
-
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
     StrictMode strict_mode, bool is_generator, ParserRecorder* log) {
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   PreParserScope top_scope(scope_, GLOBAL_SCOPE);
   FunctionState top_state(&function_state_, &scope_, &top_scope);
   scope_->SetStrictMode(strict_mode);
   PreParserScope function_scope(scope_, FUNCTION_SCOPE);
   FunctionState function_state(&function_state_, &scope_, &function_scope);
   function_state.set_is_generator(is_generator);
@@ skipping 671 matching lines @@
 
 
 #undef CHECK_OK
 #define CHECK_OK  ok);                     \
   if (!*ok) return Expression::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
+// Precedence = 2
+PreParser::Expression PreParser::ParseAssignmentExpression(bool accept_IN,
+                                                           bool* ok) {
+  // AssignmentExpression ::
+  //   ConditionalExpression
+  //   YieldExpression
+  //   LeftHandSideExpression AssignmentOperator AssignmentExpression
+
+  if (function_state_->is_generator() && peek() == Token::YIELD) {
+    return ParseYieldExpression(ok);
+  }
+
+  Scanner::Location before = scanner()->peek_location();
+  Expression expression = ParseConditionalExpression(accept_IN, CHECK_OK);
+
+  if (!Token::IsAssignmentOp(peek())) {
+    // Parsed conditional expression only (no assignment).
+    return expression;
+  }
+
+  if (strict_mode() == STRICT &&
+      expression.IsIdentifier() &&
+      expression.AsIdentifier().IsEvalOrArguments()) {
+    Scanner::Location after = scanner()->location();
+    PreParserTraits::ReportMessageAt(before.beg_pos, after.end_pos,
+                                     "strict_eval_arguments", NULL);
+    *ok = false;
+    return Expression::Default();
+  }
+
+  Token::Value op = Next();  // Get assignment operator.
+  ParseAssignmentExpression(accept_IN, CHECK_OK);
+
+  if ((op == Token::ASSIGN) && expression.IsThisProperty()) {
+    function_state_->AddProperty();
+  }
+
+  return Expression::Default();
+}
+
+
 // Precedence = 3
 PreParser::Expression PreParser::ParseYieldExpression(bool* ok) {
   // YieldExpression ::
   //   'yield' '*'? AssignmentExpression
   Consume(Token::YIELD);
   Check(Token::MUL);
 
   ParseAssignmentExpression(false, CHECK_OK);
 
   return Expression::Default();
@@ skipping 51 matching lines @@
   //   '~' UnaryExpression
   //   '!' UnaryExpression
 
   Token::Value op = peek();
   if (Token::IsUnaryOp(op)) {
     op = Next();
     ParseUnaryExpression(ok);
     return Expression::Default();
   } else if (Token::IsCountOp(op)) {
     op = Next();
+    Scanner::Location before = scanner()->peek_location();
     Expression expression = ParseUnaryExpression(CHECK_OK);
-    if (strict_mode() == STRICT) {
-      CheckStrictModeLValue(expression, CHECK_OK);
+    if (strict_mode() == STRICT &&
+        expression.IsIdentifier() &&
+        expression.AsIdentifier().IsEvalOrArguments()) {
+      Scanner::Location after = scanner()->location();
+      PreParserTraits::ReportMessageAt(before.beg_pos, after.end_pos,
+                                       "strict_eval_arguments", NULL);
+      *ok = false;
     }
     return Expression::Default();
   } else {
     return ParsePostfixExpression(ok);
   }
 }
 
 
 PreParser::Expression PreParser::ParsePostfixExpression(bool* ok) {
   // PostfixExpression ::
   //   LeftHandSideExpression ('++' | '--')?
 
+  Scanner::Location before = scanner()->peek_location();
   Expression expression = ParseLeftHandSideExpression(CHECK_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
-    if (strict_mode() == STRICT) {
-      CheckStrictModeLValue(expression, CHECK_OK);
+    if (strict_mode() == STRICT &&
+        expression.IsIdentifier() &&
+        expression.AsIdentifier().IsEvalOrArguments()) {
+      Scanner::Location after = scanner()->location();
+      PreParserTraits::ReportMessageAt(before.beg_pos, after.end_pos,
+                                       "strict_eval_arguments", NULL);
+      *ok = false;
+      return Expression::Default();
     }
     Next();
     return Expression::Default();
   }
   return expression;
 }
 
 
 PreParser::Expression PreParser::ParseLeftHandSideExpression(bool* ok) {
   // LeftHandSideExpression ::
@@ skipping 282 matching lines @@
 
 
 void PreParser::LogSymbol() {
   if (log_->ShouldLogSymbols()) {
     scanner()->LogSymbol(log_, position());
   }
 }
 
 
 } }  // v8::internal