[cleanup] Eliminate Forgive* methods on ExpressionClassifier

src/parsing/expression-classifier.h

 // Copyright 2015 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_EXPRESSION_CLASSIFIER_H
 #define V8_PARSING_EXPRESSION_CLASSIFIER_H
 
 #include "src/messages.h"
 #include "src/parsing/scanner.h"
 #include "src/parsing/token.h"
@@ skipping 293 matching lines @@
   }
 
   void RecordTailCallExpressionError(const Scanner::Location& loc,
                                      MessageTemplate::Template message,
                                      const char* arg = nullptr) {
     if (has_tail_call_expression()) return;
     invalid_productions_ |= TailCallExpressionProduction;
     Add(Error(loc, message, kTailCallExpressionProduction, arg));
   }
 
-  void ForgiveObjectLiteralError() {
-    if (!(invalid_productions_ & ObjectLiteralProduction)) return;
-    Error& e = reported_error(kObjectLiteralProduction);
-    e.kind = kUnusedError;
-    invalid_productions_ &= ~ObjectLiteralProduction;
-  }
-
-  void ForgiveAssignmentPatternError() {
-    if (!(invalid_productions_ & AssignmentPatternProduction)) return;
-    Error& e = reported_error(kAssignmentPatternProduction);
-    e.kind = kUnusedError;
-    invalid_productions_ &= ~AssignmentPatternProduction;
-  }
-
   void Accumulate(ExpressionClassifier* inner, unsigned productions,
                   bool merge_non_patterns = true) {
     DCHECK_EQ(inner->reported_errors_, reported_errors_);
     DCHECK_EQ(inner->reported_errors_begin_, reported_errors_end_);
     DCHECK_EQ(inner->reported_errors_end_, reported_errors_->length());
     if (merge_non_patterns) MergeNonPatterns(inner);
     // Propagate errors from inner, but don't overwrite already recorded
     // errors.
     unsigned non_arrow_inner_invalid_productions =
         inner->invalid_productions_ & ~ArrowFormalParametersProduction;
@@ skipping 68 matching lines @@
     DCHECK_LE(non_pattern_begin_, non_patterns_to_rewrite_->length());
     non_patterns_to_rewrite_->Rewind(non_pattern_begin_);
   }
 
   V8_INLINE void MergeNonPatterns(ExpressionClassifier* inner) {
     DCHECK_LE(non_pattern_begin_, inner->non_pattern_begin_);
     inner->non_pattern_begin_ = inner->non_patterns_to_rewrite_->length();
   }
 
  private:
-  V8_INLINE Error& reported_error(ErrorKind kind) const {
+  V8_INLINE const Error& reported_error(ErrorKind kind) const {
     if (invalid_productions_ & (1 << kind)) {
       for (int i = reported_errors_begin_; i < reported_errors_end_; i++) {
         if (reported_errors_->at(i).kind == kind)
           return reported_errors_->at(i);
       }
       UNREACHABLE();
     }
     // We should only be looking for an error when we know that one has
     // been reported.  But we're not...  So this is to make sure we have
     // the same behaviour.
@@ skipping 46 matching lines @@
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H