Remove now-unused TailCallExpressionProduction from 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"
 
 namespace v8 {
 namespace internal {
 
 class DuplicateFinder;
 
 #define ERROR_CODES(T)                       \
   T(ExpressionProduction, 0)                 \
   T(FormalParameterInitializerProduction, 1) \
   T(BindingPatternProduction, 2)             \
   T(AssignmentPatternProduction, 3)          \
   T(DistinctFormalParametersProduction, 4)   \
   T(StrictModeFormalParametersProduction, 5) \
   T(ArrowFormalParametersProduction, 6)      \
   T(LetPatternProduction, 7)                 \
-  T(TailCallExpressionProduction, 8)         \
-  T(AsyncArrowFormalParametersProduction, 9)
+  T(AsyncArrowFormalParametersProduction, 8)
 
 // Expression classifiers serve two purposes:
 //
 // 1) They keep track of error messages that are pending (and other
 //    related information), waiting for the parser to decide whether
 //    the parsed expression is a pattern or not.
 // 2) They keep track of expressions that may need to be rewritten, if
 //    the parser decides that they are not patterns.  (A different
 //    mechanism implements the rewriting of patterns.)
 //
@@ skipping 147 matching lines @@
   }
 
   V8_INLINE const Error& strict_mode_formal_parameter_error() const {
     return reported_error(kStrictModeFormalParametersProduction);
   }
 
   V8_INLINE const Error& let_pattern_error() const {
     return reported_error(kLetPatternProduction);
   }
 
-  V8_INLINE bool has_tail_call_expression() const {
-    return !is_valid(TailCallExpressionProduction);
-  }
-  V8_INLINE const Error& tail_call_expression_error() const {
-    return reported_error(kTailCallExpressionProduction);
-  }
-
   V8_INLINE const Error& async_arrow_formal_parameters_error() const {
     return reported_error(kAsyncArrowFormalParametersProduction);
   }
 
   V8_INLINE bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
   }
 
   V8_INLINE void RecordNonSimpleParameter() {
     function_properties_ |= NonSimpleParameter;
@@ skipping 81 matching lines @@
   }
 
   void RecordLetPatternError(const Scanner::Location& loc,
                              MessageTemplate::Template message,
                              const char* arg = nullptr) {
     if (!is_valid_let_pattern()) return;
     invalid_productions_ |= LetPatternProduction;
     Add(Error(loc, message, kLetPatternProduction, arg));
   }
 
-  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 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());
     DCHECK_EQ(inner->non_patterns_to_rewrite_, non_patterns_to_rewrite_);
     DCHECK_LE(non_pattern_begin_, inner->non_pattern_begin_);
     DCHECK_LE(inner->non_pattern_begin_, non_patterns_to_rewrite_->length());
     // Merge non-patterns from the inner classifier, or discard them.
     if (merge_non_patterns)
@@ skipping 146 matching lines @@
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H