[parser] Reorder traits methods

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"
@@ skipping 588 matching lines @@
 
     typedef v8::internal::ExpressionClassifier<PreParserTraits>
         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 PreParserExpression Literal;
     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;
   };
 
   explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
 
   // Helper functions for recursive descent.
   bool IsEval(PreParserIdentifier identifier) const {
     return identifier.IsEval();
   }
 
   bool IsArguments(PreParserIdentifier identifier) const {
     return identifier.IsArguments();
   }
 
-  bool IsAwait(PreParserIdentifier identifier) const {
-    return identifier.IsAwait();
-  }
-
   bool IsEvalOrArguments(PreParserIdentifier identifier) const {
     return identifier.IsEvalOrArguments();
   }
 
   bool IsUndefined(PreParserIdentifier identifier) const {
     return identifier.IsUndefined();
   }
 
-  bool IsPrototype(PreParserIdentifier identifier) const {
-    return identifier.IsPrototype();
+  bool IsAwait(PreParserIdentifier identifier) const {
+    return identifier.IsAwait();
   }
 
-  bool IsConstructor(PreParserIdentifier identifier) const {
-    return identifier.IsConstructor();
+  bool IsFutureStrictReserved(PreParserIdentifier identifier) const {
+    return identifier.IsFutureStrictReserved();
   }
 
   // Returns true if the expression is of type "this.foo".
   static bool IsThisProperty(PreParserExpression expression) {
     return expression.IsThisProperty();
   }
 
   static bool IsIdentifier(PreParserExpression expression) {
     return expression.IsIdentifier();
   }
 
   static PreParserIdentifier AsIdentifier(PreParserExpression expression) {
     return expression.AsIdentifier();
   }
 
+  bool IsPrototype(PreParserIdentifier identifier) const {
+    return identifier.IsPrototype();
+  }
+
+  bool IsConstructor(PreParserIdentifier identifier) const {
+    return identifier.IsConstructor();
+  }
+
   bool IsDirectEvalCall(PreParserExpression expression) const {
     return expression.IsDirectEvalCall();
   }
 
-  bool IsFutureStrictReserved(PreParserIdentifier identifier) const {
-    return identifier.IsFutureStrictReserved();
-  }
-
   static bool IsBoilerplateProperty(PreParserExpression property) {
     // PreParser doesn't count boilerplate properties.
     return false;
   }
 
   static bool IsArrayIndex(PreParserIdentifier string, uint32_t* index) {
     return false;
   }
 
   static PreParserExpression GetPropertyValue(PreParserExpression property) {
@@ skipping 71 matching lines @@
                        const AstRawString* arg,
                        ParseErrorType error_type = kSyntaxError);
 
   // A dummy function, just useful as an argument to CHECK_OK_CUSTOM.
   static void Void() {}
 
   // "null" return type creators.
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
-  static PreParserIdentifier EmptyIdentifierString() {
-    return PreParserIdentifier::Default();
-  }
   static PreParserExpression EmptyExpression() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyFunctionLiteral() {
     return PreParserExpression::Default();
   }
+
   static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
+  static PreParserIdentifier EmptyIdentifierString() {
+    return PreParserIdentifier::Default();
+  }
 
   // Odd-ball literal creators.
   PreParserExpression GetLiteralTheHole(int position,
                                         PreParserFactory* factory) const {
     return PreParserExpression::Default();
   }
 
   // Producing data during the recursive descent.
   PreParserIdentifier GetSymbol(Scanner* scanner);
-  PreParserIdentifier GetNumberAsSymbol(Scanner* scanner) {
-    return PreParserIdentifier::Default();
-  }
 
   PreParserIdentifier GetNextSymbol(Scanner* scanner) const {
     return PreParserIdentifier::Default();
   }
 
+  PreParserIdentifier GetNumberAsSymbol(Scanner* scanner) {
+    return PreParserIdentifier::Default();
+  }
+
   PreParserExpression ThisExpression(int pos = kNoSourcePosition) const {
     return PreParserExpression::This();
   }
 
   PreParserExpression NewSuperPropertyReference(PreParserFactory* factory,
                                                 int pos) const {
     return PreParserExpression::Default();
   }
 
   PreParserExpression NewSuperCallReference(PreParserFactory* factory,
@@ skipping 27 matching lines @@
 
   PreParserExpression GetIterator(PreParserExpression iterable,
                                   PreParserFactory* factory, int pos) {
     return PreParserExpression::Default();
   }
 
   PreParserExpressionList NewExpressionList(int size, Zone* zone) const {
     return PreParserExpressionList();
   }
 
+  PreParserExpressionList NewPropertyList(int size, Zone* zone) const {
+    return PreParserExpressionList();
+  }
+
   PreParserStatementList NewStatementList(int size, Zone* zone) const {
     return PreParserStatementList();
   }
 
-  PreParserExpressionList NewPropertyList(int size, Zone* zone) const {
-    return PreParserExpressionList();
-  }
-
   void AddParameterInitializationBlock(
       const PreParserFormalParameters& parameters, PreParserStatementList list,
       bool is_async, bool* ok) const {}
 
-  V8_INLINE void SkipLazyFunctionBody(
-      int* materialized_literal_count, int* expected_property_count, bool* ok,
-      Scanner::BookmarkScope* bookmark = nullptr) {
-    UNREACHABLE();
-  }
-
-  V8_INLINE PreParserStatementList ParseEagerFunctionBody(
-      PreParserIdentifier name, int pos,
-      const PreParserFormalParameters& parameters, FunctionKind kind,
-      FunctionLiteral::FunctionType function_type, bool* ok);
-
-  V8_INLINE void ParseArrowFunctionFormalParameterList(
-      PreParserFormalParameters* parameters, PreParserExpression expression,
-      const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
-      const Scope::Snapshot& scope_snapshot, bool* ok);
-
   void ParseAsyncArrowSingleExpressionBody(
       PreParserStatementList body, bool accept_IN,
       Type::ExpressionClassifier* classifier, int pos, bool* ok);
 
-  V8_INLINE PreParserExpression ParseAsyncFunctionExpression(bool* ok);
-
-  void ReindexLiterals(const PreParserFormalParameters& parameters) {}
-
-  struct TemplateLiteralState {};
-
-  TemplateLiteralState OpenTemplateLiteral(int pos) {
-    return TemplateLiteralState();
-  }
-  void AddTemplateSpan(TemplateLiteralState* state, bool tail) {}
-  void AddTemplateExpression(TemplateLiteralState* state,
-                             PreParserExpression expression) {}
-  V8_INLINE PreParserExpression CloseTemplateLiteral(
-      TemplateLiteralState* state, int start, PreParserExpression tag);
-  PreParserExpression NoTemplateTag() {
-    return PreParserExpression::NoTemplateTag();
-  }
-  static bool IsTaggedTemplate(const PreParserExpression tag) {
-    return !tag.IsNoTemplateTag();
-  }
 
   void AddFormalParameter(PreParserFormalParameters* parameters,
                           PreParserExpression pattern,
                           PreParserExpression initializer,
                           int initializer_end_position, bool is_rest) {
     ++parameters->arity;
   }
+
   void DeclareFormalParameter(DeclarationScope* scope,
                               PreParserIdentifier parameter,
                               Type::ExpressionClassifier* classifier) {
     if (!classifier->is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
     }
   }
 
-  void CheckConflictingVarDeclarations(Scope* scope, bool* ok) {}
+  V8_INLINE void ParseArrowFunctionFormalParameterList(
+      PreParserFormalParameters* parameters, PreParserExpression expression,
+      const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
+      const Scope::Snapshot& scope_snapshot, bool* ok);
+
+  V8_INLINE PreParserExpression ParseAsyncFunctionExpression(bool* ok);
+
+  V8_INLINE PreParserExpression ParseDoExpression(bool* ok);
+
+  void ReindexLiterals(const PreParserFormalParameters& parameters) {}
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
-  V8_INLINE PreParserExpression ParseDoExpression(bool* ok);
   PreParserExpression ParseFunctionLiteral(
       PreParserIdentifier name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
       LanguageMode language_mode, bool* ok);
 
+  V8_INLINE void SkipLazyFunctionBody(
+      int* materialized_literal_count, int* expected_property_count, bool* ok,
+      Scanner::BookmarkScope* bookmark = nullptr) {
+    UNREACHABLE();
+  }
+
+  V8_INLINE PreParserStatementList ParseEagerFunctionBody(
+      PreParserIdentifier name, int pos,
+      const PreParserFormalParameters& parameters, FunctionKind kind,
+      FunctionLiteral::FunctionType function_type, bool* ok);
+
   PreParserExpression ParseClassLiteral(Type::ExpressionClassifier* classifier,
                                         PreParserIdentifier name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok);
 
   V8_INLINE void MarkCollectedTailCallExpressions() {}
   V8_INLINE void MarkTailPosition(PreParserExpression expression) {}
 
-  PreParserExpressionList PrepareSpreadArguments(PreParserExpressionList list) {
+  void CheckConflictingVarDeclarations(Scope* scope, bool* ok) {}
+
+  struct TemplateLiteralState {};
+
+  V8_INLINE TemplateLiteralState OpenTemplateLiteral(int pos) {
+    return TemplateLiteralState();
+  }
+  V8_INLINE void AddTemplateSpan(TemplateLiteralState* state, bool tail) {}
+  V8_INLINE void AddTemplateExpression(TemplateLiteralState* state,
+                                       PreParserExpression expression) {}
+  V8_INLINE PreParserExpression CloseTemplateLiteral(
+      TemplateLiteralState* state, int start, PreParserExpression tag);
+  V8_INLINE PreParserExpression NoTemplateTag() {
+    return PreParserExpression::NoTemplateTag();
+  }
+  V8_INLINE static bool IsTaggedTemplate(const PreParserExpression tag) {
+    return !tag.IsNoTemplateTag();
+  }
+
+  V8_INLINE PreParserExpressionList
+  PrepareSpreadArguments(PreParserExpressionList list) {
     return list;
   }
 
   inline void MaterializeUnspreadArgumentsLiterals(int count);
 
   inline PreParserExpression SpreadCall(PreParserExpression function,
                                         PreParserExpressionList args, int pos);
 
   inline PreParserExpression SpreadCallNew(PreParserExpression function,
                                            PreParserExpressionList args,
                                            int pos);
 
   inline PreParserExpression ExpressionListToExpression(
       PreParserExpressionList args) {
     return PreParserExpression::Default();
   }
 
   inline void RewriteDestructuringAssignments() {}
 
   inline PreParserExpression RewriteExponentiation(PreParserExpression left,
                                                    PreParserExpression right,
                                                    int pos) {
     return left;
   }
   inline PreParserExpression RewriteAssignExponentiation(
       PreParserExpression left, PreParserExpression right, int pos) {
     return left;
   }
+  inline PreParserExpression RewriteAwaitExpression(PreParserExpression value,
+                                                    int pos);
 
   inline void QueueDestructuringAssignmentForRewriting(
       PreParserExpression assignment) {}
   inline void QueueNonPatternForRewriting(PreParserExpression expr, bool* ok) {}
 
   void SetFunctionNameFromPropertyName(PreParserExpression property,
                                        PreParserIdentifier name) {}
   void SetFunctionNameFromIdentifierRef(PreParserExpression value,
                                         PreParserExpression identifier) {}
 
   inline void RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                 bool* ok);
 
-  inline PreParserExpression RewriteAwaitExpression(PreParserExpression value,
-                                                    int pos);
-
   V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
       GetReportedErrorList() const;
   V8_INLINE Zone* zone() const;
   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const;
 
   inline PreParserExpression RewriteYieldStar(PreParserExpression generator,
                                               PreParserExpression expression,
                                               int pos);
 
  private:
@@ skipping 263 matching lines @@
     pre_parser_->function_state_->NextMaterializedLiteralIndex();
     pre_parser_->function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H