[cleanup] Eliminate Forgive* methods on ExpressionClassifier

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/base/hashmap.h"
@@ skipping 2263 matching lines @@
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
                                               ExpressionClassifier* classifier,
                                               bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
-  bool is_destructuring_assignment = false;
   int lhs_beg_pos = peek_position();
 
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(accept_IN, classifier, ok);
   }
 
   FuncNameInferrer::State fni_state(fni_);
   ParserBase<Traits>::Checkpoint checkpoint(this);
   ExpressionClassifier arrow_formals_classifier(this,
                                                 classifier->duplicate_finder());
@@ skipping 74 matching lines @@
     arrow_formals_classifier.Discard();
     classifier->RecordPatternError(arrow_loc,
                                    MessageTemplate::kUnexpectedToken,
                                    Token::String(Token::ARROW));
 
     if (fni_ != nullptr) fni_->Infer();
 
     return expression;
   }
 
-  if (this->IsValidReferenceExpression(expression)) {
-    arrow_formals_classifier.ForgiveAssignmentPatternError();
+  // "expression" was not itself an arrow function parameter list, but it might
+  // form part of one.  Propagate speculative formal parameter error locations
+  // (including those for binding patterns, since formal parameters can
+  // themselves contain binding patterns).
+  // Do not merge pending non-pattern expressions yet!
+  unsigned productions =
+      ExpressionClassifier::BindingPatternProduction |
+      ExpressionClassifier::LetPatternProduction |

[nickie, 2016/08/23 08:24:27]

I'd rather change this to:
(ExpressionClassifier::PatternProductions &
~ExpressionClassifier::AssignmentPatternProduction)
for clarity.

[adamk, 2016/08/23 18:02:31]

I've moved all the pattern logic down into the IsValidReferenceExpression if
statement, thanks for the suggestion.

+      ExpressionClassifier::FormalParametersProductions |
+      ExpressionClassifier::AsyncArrowFormalParametersProduction |
+      ExpressionClassifier::FormalParameterInitializerProduction;
+
+  // Parenthesized identifiers and property references are allowed as part
+  // of a larger binding pattern, even though parenthesized patterns
+  // themselves are not allowed, e.g., "[(x)] = []". Only accumulate
+  // assignment pattern errors if the parsed expression is more complex.
+  if (!this->IsValidReferenceExpression(expression)) {
+    productions |= ExpressionClassifier::AssignmentPatternProduction;
   }
 
-  // "expression" was not itself an arrow function parameter list, but it might
-  // form part of one.  Propagate speculative formal parameter error locations.
-  // Do not merge pending non-pattern expressions yet!
-  classifier->Accumulate(
-      &arrow_formals_classifier,
-      ExpressionClassifier::ExpressionProductions |
-          ExpressionClassifier::PatternProductions |
-          ExpressionClassifier::FormalParametersProductions |
-          ExpressionClassifier::ObjectLiteralProduction |
-          ExpressionClassifier::AsyncArrowFormalParametersProduction,
-      false);
+  const bool is_destructuring_assignment =
+      IsValidPattern(expression) && peek() == Token::ASSIGN;
+  if (!is_destructuring_assignment) {
+    // This may be an expression or a pattern, so we must continue to
+    // accumulate expression-related errors.
+    productions |= ExpressionClassifier::ExpressionProduction |
+                   ExpressionClassifier::TailCallExpressionProduction |
+                   ExpressionClassifier::ObjectLiteralProduction;
+  }
+
+  classifier->Accumulate(&arrow_formals_classifier, productions, false);
 
   if (!Token::IsAssignmentOp(peek())) {
     // Parsed conditional expression only (no assignment).
     // Now pending non-pattern expressions must be merged.
     classifier->MergeNonPatterns(&arrow_formals_classifier);
     return expression;
   }
 
   // Now pending non-pattern expressions must be discarded.
   arrow_formals_classifier.Discard();
 
   CheckNoTailCallExpressions(classifier, CHECK_OK);
 
-  if (IsValidPattern(expression) && peek() == Token::ASSIGN) {
-    classifier->ForgiveObjectLiteralError();
+  if (is_destructuring_assignment) {
     ValidateAssignmentPattern(classifier, CHECK_OK);
-    is_destructuring_assignment = true;
   } else {
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInAssignment, CHECK_OK);
   }
 
   expression = this->MarkExpressionAsAssigned(expression);
 
   Token::Value op = Next();  // Get assignment operator.
   if (op != Token::ASSIGN) {
@@ skipping 1280 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H