[parser] Clean up type definitions

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
 #include "src/messages.h"
 #include "src/parsing/expression-classifier.h"
 #include "src/parsing/func-name-inferrer.h"
 #include "src/parsing/parser-base.h"
 #include "src/parsing/scanner.h"
 #include "src/parsing/token.h"
 
 namespace v8 {
 namespace internal {
 
+// Whereas the Parser generates AST during the recursive descent,
+// the PreParser doesn't create a tree. Instead, it passes around minimal
+// data objects (PreParserExpression, PreParserIdentifier etc.) which contain
+// just enough data for the upper layer functions. PreParserFactory is
+// responsible for creating these dummy objects. It provides a similar kind of
+// interface as AstNodeFactory, so ParserBase doesn't need to care which one is
+// used.
+
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
   }
   static PreParserIdentifier Eval() {
     return PreParserIdentifier(kEvalIdentifier);
   }
   static PreParserIdentifier Arguments() {
@@ skipping 547 matching lines @@
   int arity = 0;
 
   int Arity() const { return arity; }
   PreParserIdentifier at(int i) { return PreParserIdentifier(); }  // Dummy
 };
 
 
 class PreParser;
 
 template <>
-class ParserBaseTraits<PreParser> {
- public:
-  struct Type {
-    typedef ParserBase<PreParser> Base;
-    typedef PreParser Impl;
+struct ParserTypes<PreParser> {
+  typedef ParserBase<PreParser> Base;
+  typedef PreParser Impl;
 
-    // PreParser doesn't need to store generator variables.
-    typedef void GeneratorVariable;
+  // PreParser doesn't need to store generator variables.
+  typedef void GeneratorVariable;
 
-    typedef int AstProperties;
+  typedef int AstProperties;
 
-    typedef v8::internal::ExpressionClassifier<ParserBaseTraits<PreParser>>
-        ExpressionClassifier;
+  typedef v8::internal::ExpressionClassifier<ParserTypes<PreParser>>
+      ExpressionClassifier;
 
-    // Return types for traversing functions.
-    typedef PreParserIdentifier Identifier;
-    typedef PreParserExpression Expression;
-    typedef PreParserExpression YieldExpression;
-    typedef PreParserExpression FunctionLiteral;
-    typedef PreParserExpression ClassLiteral;
-    typedef PreParserExpression Literal;
-    typedef PreParserExpression ObjectLiteralProperty;
-    typedef PreParserExpressionList ExpressionList;
-    typedef PreParserExpressionList PropertyList;
-    typedef PreParserIdentifier FormalParameter;
-    typedef PreParserFormalParameters FormalParameters;
-    typedef PreParserStatementList StatementList;
+  // Return types for traversing functions.
+  typedef PreParserIdentifier Identifier;
+  typedef PreParserExpression Expression;
+  typedef PreParserExpression YieldExpression;
+  typedef PreParserExpression FunctionLiteral;
+  typedef PreParserExpression ClassLiteral;
+  typedef PreParserExpression Literal;
+  typedef PreParserExpression ObjectLiteralProperty;
+  typedef PreParserExpressionList ExpressionList;
+  typedef PreParserExpressionList PropertyList;
+  typedef PreParserIdentifier FormalParameter;
+  typedef PreParserFormalParameters FormalParameters;
+  typedef PreParserStatementList StatementList;
 
-    // For constructing objects returned by the traversing functions.
-    typedef PreParserFactory Factory;
-  };
+  // For constructing objects returned by the traversing functions.
+  typedef PreParserFactory Factory;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
 // The PreParser checks that the syntax follows the grammar for JavaScript,
 // and collects some information about the program along the way.
 // The grammar check is only performed in order to understand the program
 // sufficiently to deduce some information about it, that can be used
 // to speed up later parsing. Finding errors is not the goal of pre-parsing,
 // rather it is to speed up properly written and correct programs.
 // That means that contextual checks (like a label being declared where
 // it is used) are generally omitted.
 class PreParser : public ParserBase<PreParser> {
   friend class ParserBase<PreParser>;
-  friend class v8::internal::ExpressionClassifier<ParserBaseTraits<PreParser>>;
+  friend class v8::internal::ExpressionClassifier<ParserTypes<PreParser>>;
 
  public:
   typedef PreParserIdentifier Identifier;
   typedef PreParserExpression Expression;
   typedef PreParserStatement Statement;
 
   enum PreParseResult {
     kPreParseStackOverflow,
     kPreParseSuccess
   };
@@ skipping 182 matching lines @@
 
   V8_INLINE PreParserExpression
   RewriteAwaitExpression(PreParserExpression value, int pos) {
     return value;
   }
   V8_INLINE PreParserExpression RewriteYieldStar(PreParserExpression generator,
                                                  PreParserExpression expression,
                                                  int pos) {
     return PreParserExpression::Default();
   }
-  V8_INLINE void RewriteNonPattern(Type::ExpressionClassifier* classifier,
-                                   bool* ok) {
+  V8_INLINE void RewriteNonPattern(ExpressionClassifier* classifier, bool* ok) {
     ValidateExpression(classifier, ok);
   }
 
   V8_INLINE void QueueDestructuringAssignmentForRewriting(
       PreParserExpression assignment) {}
   V8_INLINE void QueueNonPatternForRewriting(PreParserExpression expr,
                                              bool* ok) {}
 
   // Helper functions for recursive descent.
   V8_INLINE bool IsEval(PreParserIdentifier identifier) const {
@@ skipping 234 matching lines @@
       bool is_async, bool* ok) {}
 
   V8_INLINE void AddFormalParameter(PreParserFormalParameters* parameters,
                                     PreParserExpression pattern,
                                     PreParserExpression initializer,
                                     int initializer_end_position,
                                     bool is_rest) {
     ++parameters->arity;
   }
 
-  V8_INLINE void DeclareFormalParameter(
-      DeclarationScope* scope, PreParserIdentifier parameter,
-      Type::ExpressionClassifier* classifier) {
+  V8_INLINE void DeclareFormalParameter(DeclarationScope* scope,
+                                        PreParserIdentifier parameter,
+                                        ExpressionClassifier* classifier) {
     if (!classifier->is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
     }
   }
 
   V8_INLINE void ParseArrowFunctionFormalParameterList(
       PreParserFormalParameters* parameters, PreParserExpression params,
       const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
       const Scope::Snapshot& scope_snapshot, bool* ok) {
     // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect
@@ skipping 20 matching lines @@
   V8_INLINE PreParserExpression
   ExpressionListToExpression(PreParserExpressionList args) {
     return PreParserExpression::Default();
   }
 
   V8_INLINE void SetFunctionNameFromPropertyName(PreParserExpression property,
                                                  PreParserIdentifier name) {}
   V8_INLINE void SetFunctionNameFromIdentifierRef(
       PreParserExpression value, PreParserExpression identifier) {}
 
-  V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
+  V8_INLINE ZoneList<typename ExpressionClassifier::Error>*
   GetReportedErrorList() const {
     return function_state_->GetReportedErrorList();
   }
 
   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const {
     return function_state_->non_patterns_to_rewrite();
   }
 
   // Preparser's private field members.
 
@@ skipping 40 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H