[parser] Clean up type definitions

src/parsing/parser.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_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
@@ skipping 120 matching lines @@
 
   explicit ParserFormalParameters(DeclarationScope* scope)
       : FormalParametersBase(scope), params(4, scope->zone()) {}
   ZoneList<Parameter> params;
 
   int Arity() const { return params.length(); }
   const Parameter& at(int i) const { return params[i]; }
 };
 
 template <>
-class ParserBaseTraits<Parser> {
- public:
-  struct Type {
-    typedef ParserBase<Parser> Base;
-    typedef Parser Impl;
+struct ParserTypes<Parser> {
+  typedef ParserBase<Parser> Base;
+  typedef Parser Impl;
 
-    typedef Variable GeneratorVariable;
+  typedef Variable GeneratorVariable;
 
-    typedef v8::internal::AstProperties AstProperties;
+  typedef v8::internal::AstProperties AstProperties;
 
-    typedef v8::internal::ExpressionClassifier<ParserBaseTraits<Parser>>
-        ExpressionClassifier;
+  typedef v8::internal::ExpressionClassifier<ParserTypes<Parser>>
+      ExpressionClassifier;
 
-    // Return types for traversing functions.
-    typedef const AstRawString* Identifier;
-    typedef v8::internal::Expression* Expression;
-    typedef Yield* YieldExpression;
-    typedef v8::internal::FunctionLiteral* FunctionLiteral;
-    typedef v8::internal::ClassLiteral* ClassLiteral;
-    typedef v8::internal::Literal* Literal;
-    typedef ObjectLiteral::Property* ObjectLiteralProperty;
-    typedef ZoneList<v8::internal::Expression*>* ExpressionList;
-    typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
-    typedef ParserFormalParameters::Parameter FormalParameter;
-    typedef ParserFormalParameters FormalParameters;
-    typedef ZoneList<v8::internal::Statement*>* StatementList;
+  // Return types for traversing functions.
+  typedef const AstRawString* Identifier;
+  typedef v8::internal::Expression* Expression;
+  typedef Yield* YieldExpression;
+  typedef v8::internal::FunctionLiteral* FunctionLiteral;
+  typedef v8::internal::ClassLiteral* ClassLiteral;
+  typedef v8::internal::Literal* Literal;
+  typedef ObjectLiteral::Property* ObjectLiteralProperty;
+  typedef ZoneList<v8::internal::Expression*>* ExpressionList;
+  typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
+  typedef ParserFormalParameters::Parameter FormalParameter;
+  typedef ParserFormalParameters FormalParameters;
+  typedef ZoneList<v8::internal::Statement*>* StatementList;
 
-    // For constructing objects returned by the traversing functions.
-    typedef AstNodeFactory Factory;
-  };
+  // For constructing objects returned by the traversing functions.
+  typedef AstNodeFactory Factory;
 };
 
 class Parser : public ParserBase<Parser> {
  public:
   explicit Parser(ParseInfo* info);
   ~Parser() {
     delete reusable_preparser_;
     reusable_preparser_ = NULL;
     delete cached_parse_data_;
     cached_parse_data_ = NULL;
   }
 
   // Parses the source code represented by the compilation info and sets its
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool ParseStatic(ParseInfo* info);
   bool Parse(ParseInfo* info);
   void ParseOnBackground(ParseInfo* info);
 
   void DeserializeScopeChain(ParseInfo* info, Handle<Context> context,
                              Scope::DeserializationMode deserialization_mode);
 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize(Isolate* isolate, Handle<Script> script, bool error);
   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
 
  private:
   friend class ParserBase<Parser>;
-  friend class v8::internal::ExpressionClassifier<ParserBaseTraits<Parser>>;
+  friend class v8::internal::ExpressionClassifier<ParserTypes<Parser>>;
 
   // Runtime encoding of different completion modes.
   enum CompletionKind {
     kNormalCompletion,
     kThrowCompletion,
     kAbruptCompletion
   };
 
   enum class FunctionBodyType { kNormal, kSingleExpression };
 
@@ skipping 262 matching lines @@
                                       Expression* iterable, Statement* body,
                                       bool finalize,
                                       int next_result_pos = kNoSourcePosition);
   Statement* DesugarLexicalBindingsInForStatement(
       Scope* inner_scope, VariableMode mode,
       ZoneList<const AstRawString*>* names, ForStatement* loop, Statement* init,
       Expression* cond, Statement* next, Statement* body, bool* ok);
 
   void DesugarAsyncFunctionBody(const AstRawString* function_name, Scope* scope,
                                 ZoneList<Statement*>* body,
-                                Type::ExpressionClassifier* classifier,
+                                ExpressionClassifier* classifier,
                                 FunctionKind kind, FunctionBodyType type,
                                 bool accept_IN, int pos, bool* ok);
 
   void RewriteDoExpression(Expression* expr, bool* ok);
 
   FunctionLiteral* ParseFunctionLiteral(
       const AstRawString* name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
       LanguageMode language_mode, bool* ok);
@@ skipping 122 matching lines @@
   void ParseAsyncArrowSingleExpressionBody(ZoneList<Statement*>* body,
                                            bool accept_IN,
                                            ExpressionClassifier* classifier,
                                            int pos, bool* ok) {
     DesugarAsyncFunctionBody(ast_value_factory()->empty_string(), scope(), body,
                              classifier, kAsyncArrowFunction,
                              FunctionBodyType::kSingleExpression, accept_IN,
                              pos, ok);
   }
 
-  ZoneList<v8::internal::Expression*>* PrepareSpreadArguments(
-      ZoneList<v8::internal::Expression*>* list);
-  Expression* SpreadCall(Expression* function,
-                         ZoneList<v8::internal::Expression*>* args, int pos);
-  Expression* SpreadCallNew(Expression* function,
-                            ZoneList<v8::internal::Expression*>* args, int pos);
+  ZoneList<Expression*>* PrepareSpreadArguments(ZoneList<Expression*>* list);
+  Expression* SpreadCall(Expression* function, ZoneList<Expression*>* args,
+                         int pos);
+  Expression* SpreadCallNew(Expression* function, ZoneList<Expression*>* args,
+                            int pos);
 
   void SetLanguageMode(Scope* scope, LanguageMode mode);
   void RaiseLanguageMode(LanguageMode mode);
 
   V8_INLINE void MarkCollectedTailCallExpressions();
   V8_INLINE void MarkTailPosition(Expression* expression);
 
   // Rewrite all DestructuringAssignments in the current FunctionState.
   V8_INLINE void RewriteDestructuringAssignments();
 
@@ skipping 294 matching lines @@
     }
     return NewUnresolved(name, start_position, end_position);
   }
 
   V8_INLINE Expression* ExpressionFromString(int pos) {
     const AstRawString* symbol = GetSymbol();
     if (fni_ != NULL) fni_->PushLiteralName(symbol);
     return factory()->NewStringLiteral(symbol, pos);
   }
 
-  V8_INLINE ZoneList<v8::internal::Expression*>* NewExpressionList(
-      int size) const {
-    return new (zone()) ZoneList<v8::internal::Expression*>(size, zone());
+  V8_INLINE ZoneList<Expression*>* NewExpressionList(int size) const {
+    return new (zone()) ZoneList<Expression*>(size, zone());
   }
   V8_INLINE ZoneList<ObjectLiteral::Property*>* NewPropertyList(
       int size) const {
     return new (zone()) ZoneList<ObjectLiteral::Property*>(size, zone());
   }
-  V8_INLINE ZoneList<v8::internal::Statement*>* NewStatementList(
-      int size) const {
-    return new (zone()) ZoneList<v8::internal::Statement*>(size, zone());
+  V8_INLINE ZoneList<Statement*>* NewStatementList(int size) const {
+    return new (zone()) ZoneList<Statement*>(size, zone());
   }
 
   V8_INLINE void AddParameterInitializationBlock(
-      const ParserFormalParameters& parameters,
-      ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok) {
+      const ParserFormalParameters& parameters, ZoneList<Statement*>* body,
+      bool is_async, bool* ok) {
     if (parameters.is_simple) return;
     auto* init_block = BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
     if (is_async) init_block = BuildRejectPromiseOnException(init_block);
     if (init_block != nullptr) body->Add(init_block, zone());
   }
 
   V8_INLINE void AddFormalParameter(ParserFormalParameters* parameters,
                                     Expression* pattern,
                                     Expression* initializer,
                                     int initializer_end_position,
                                     bool is_rest) {
     bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
     const AstRawString* name = is_simple
                                    ? pattern->AsVariableProxy()->raw_name()
                                    : ast_value_factory()->empty_string();
     parameters->params.Add(
         ParserFormalParameters::Parameter(name, pattern, initializer,
                                           initializer_end_position, is_rest),
         parameters->scope->zone());
   }
 
   V8_INLINE void DeclareFormalParameter(
       DeclarationScope* scope,
       const ParserFormalParameters::Parameter& parameter,
-      Type::ExpressionClassifier* classifier) {
+      ExpressionClassifier* classifier) {
     bool is_duplicate = false;
     bool is_simple = classifier->is_simple_parameter_list();
     auto name = is_simple || parameter.is_rest
                     ? parameter.name
                     : ast_value_factory()->empty_string();
     auto mode = is_simple || parameter.is_rest ? VAR : TEMPORARY;
     if (!is_simple) scope->SetHasNonSimpleParameters();
     bool is_optional = parameter.initializer != nullptr;
     Variable* var =
         scope->DeclareParameter(name, mode, is_optional, parameter.is_rest,
@@ skipping 24 matching lines @@
   V8_INLINE void MaterializeUnspreadArgumentsLiterals(int count) {}
 
   Expression* ExpressionListToExpression(ZoneList<Expression*>* args);
 
   void SetFunctionNameFromPropertyName(ObjectLiteralProperty* property,
                                        const AstRawString* name);
 
   void SetFunctionNameFromIdentifierRef(Expression* value,
                                         Expression* identifier);
 
-  V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
+  V8_INLINE ZoneList<typename ExpressionClassifier::Error>*
   GetReportedErrorList() const {
     return function_state_->GetReportedErrorList();
   }
 
   V8_INLINE ZoneList<Expression*>* GetNonPatternList() const {
     return function_state_->non_patterns_to_rewrite();
   }
 
   // Parser's private field members.
 
@@ skipping 45 matching lines @@
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_