[parser] Clean up type definitions

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"
 
 namespace v8 {
 namespace internal {
 
 #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(ObjectLiteralProduction, 8)              \
   T(TailCallExpressionProduction, 9)         \
   T(AsyncArrowFormalParametersProduction, 10)
 
-template <typename Traits>
+template <typename Types>
 class ExpressionClassifier {
  public:
   enum ErrorKind : unsigned {
 #define DEFINE_ERROR_KIND(NAME, CODE) k##NAME = CODE,
     ERROR_CODES(DEFINE_ERROR_KIND)
 #undef DEFINE_ERROR_KIND
     kUnusedError = 15  // Larger than error codes; should fit in 4 bits
   };
 
   struct Error {
@@ skipping 31 matching lines @@
     AllProductions =
         (ExpressionProductions | PatternProductions |
          FormalParametersProductions | ArrowFormalParametersProduction |
          ObjectLiteralProduction | AsyncArrowFormalParametersProduction)
   };
 
   enum FunctionProperties : unsigned {
     NonSimpleParameter = 1 << 0
   };
 
-  explicit ExpressionClassifier(const typename Traits::Type::Base* base,
+  explicit ExpressionClassifier(const typename Types::Base* base,
                                 DuplicateFinder* duplicate_finder = nullptr)
       : zone_(base->impl()->zone()),
         non_patterns_to_rewrite_(base->impl()->GetNonPatternList()),
         reported_errors_(base->impl()->GetReportedErrorList()),
         duplicate_finder_(duplicate_finder),
         invalid_productions_(0),
         function_properties_(0) {
     reported_errors_begin_ = reported_errors_end_ = reported_errors_->length();
     non_pattern_begin_ = non_patterns_to_rewrite_->length();
   }
@@ skipping 327 matching lines @@
   // in an inner classifier) or it could be an existing error (in case a
   // copy is needed).
   V8_INLINE void Copy(int i) {
     DCHECK_LT(i, reported_errors_->length());
     if (reported_errors_end_ != i)
       reported_errors_->at(reported_errors_end_) = reported_errors_->at(i);
     reported_errors_end_++;
   }
 
   Zone* zone_;
-  ZoneList<typename Traits::Type::Expression>* non_patterns_to_rewrite_;
+  ZoneList<typename Types::Expression>* non_patterns_to_rewrite_;
   ZoneList<Error>* reported_errors_;
   DuplicateFinder* duplicate_finder_;
   // The uint16_t for non_pattern_begin_ will not be enough in the case,
   // e.g., of an array literal containing more than 64K inner array
   // literals with spreads, as in:
   // var N=65536; eval("var x=[];" + "[" + "[...x],".repeat(N) + "].length");
   // An implementation limit error in ParserBase::AddNonPatternForRewriting
   // will be triggered in this case.
   uint16_t non_pattern_begin_;
   unsigned invalid_productions_ : 14;
@@ skipping 10 matching lines @@
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H