[parser] Refactor of ParseClass* and ParseNativeDeclaration

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 134 matching lines @@
 
   typedef v8::internal::Variable Variable;
 
   // Return types for traversing functions.
   typedef const AstRawString* Identifier;
   typedef v8::internal::Expression* Expression;
   typedef v8::internal::FunctionLiteral* FunctionLiteral;
   typedef ObjectLiteral::Property* ObjectLiteralProperty;
   typedef ClassLiteral::Property* ClassLiteralProperty;
   typedef ZoneList<v8::internal::Expression*>* ExpressionList;
-  typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
+  typedef ZoneList<ObjectLiteral::Property*>* ObjectPropertyList;
+  typedef ZoneList<ClassLiteral::Property*>* ClassPropertyList;
   typedef ParserFormalParameters FormalParameters;
   typedef v8::internal::Statement* Statement;
   typedef ZoneList<v8::internal::Statement*>* StatementList;
   typedef v8::internal::Block* Block;
   typedef v8::internal::BreakableStatement* BreakableStatement;
   typedef v8::internal::IterationStatement* IterationStatement;
 
   // For constructing objects returned by the traversing functions.
   typedef AstNodeFactory Factory;
 
@@ skipping 96 matching lines @@
     const AstRawString* local_name;
     const Scanner::Location location;
     NamedImport(const AstRawString* import_name, const AstRawString* local_name,
                 Scanner::Location location)
         : import_name(import_name),
           local_name(local_name),
           location(location) {}
   };
   ZoneList<const NamedImport*>* ParseNamedImports(int pos, bool* ok);
   Statement* ParseFunctionDeclaration(bool* ok);
-  Statement* ParseClassDeclaration(ZoneList<const AstRawString*>* names,
-                                   bool default_export, bool* ok);
-  Statement* ParseNativeDeclaration(bool* ok);
   Block* BuildInitializationBlock(DeclarationParsingResult* parsing_result,
                                   ZoneList<const AstRawString*>* names,
                                   bool* ok);
   void DeclareAndInitializeVariables(
       Block* block, const DeclarationDescriptor* declaration_descriptor,
       const DeclarationParsingResult::Declaration* declaration,
       ZoneList<const AstRawString*>* names, bool* ok);
   ZoneList<const AstRawString*>* DeclareLabel(
       ZoneList<const AstRawString*>* labels, VariableProxy* expr, bool* ok);
   bool ContainsLabel(ZoneList<const AstRawString*>* labels,
                      const AstRawString* label);
   Expression* RewriteReturn(Expression* return_value, int pos);
   Statement* RewriteSwitchStatement(Expression* tag,
                                     SwitchStatement* switch_statement,
                                     ZoneList<CaseClause*>* cases, Scope* scope);
   void RewriteCatchPattern(CatchInfo* catch_info, bool* ok);
   void ValidateCatchBlock(const CatchInfo& catch_info, bool* ok);
   Statement* RewriteTryStatement(Block* try_block, Block* catch_block,
                                  Block* finally_block,
                                  const CatchInfo& catch_info, int pos);
 
   Statement* DeclareFunction(const AstRawString* variable_name,
                              FunctionLiteral* function, int pos,
                              bool is_generator, bool is_async,
                              ZoneList<const AstRawString*>* names, bool* ok);
+  V8_INLINE Statement* DeclareClass(const AstRawString* variable_name,
+                                    Expression* value,
+                                    ZoneList<const AstRawString*>* names,
+                                    int class_token_pos, int end_pos, bool* ok);
+  V8_INLINE void DeclareClassVariable(const AstRawString* name,
+                                      Scope* block_scope, ClassInfo* class_info,
+                                      int class_token_pos, bool* ok);
+  V8_INLINE void DeclareClassProperty(const AstRawString* class_name,
+                                      ClassLiteralProperty* property,
+                                      ClassInfo* class_info, bool* ok);
+  V8_INLINE Expression* RewriteClassLiteral(const AstRawString* name,
+                                            ClassInfo* class_info, int pos,
+                                            bool* ok);
+  V8_INLINE Statement* DeclareNative(const AstRawString* name, int pos,
+                                     bool* ok);
 
   Expression* ParseYieldStarExpression(bool* ok);
 
   class PatternRewriter final : public AstVisitor<PatternRewriter> {
    public:
     static void DeclareAndInitializeVariables(
         Parser* parser, Block* block,
         const DeclarationDescriptor* declaration_descriptor,
         const DeclarationParsingResult::Declaration* declaration,
         ZoneList<const AstRawString*>* names, bool* ok);
@@ skipping 102 matching lines @@
       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);
 
   Expression* InstallHomeObject(Expression* function_literal,
                                 Expression* home_object);
   FunctionLiteral* SynthesizeClassFieldInitializer(int count);
   FunctionLiteral* InsertClassFieldInitializer(FunctionLiteral* constructor);
 
-  Expression* ParseClassLiteral(const AstRawString* name,
-                                Scanner::Location class_name_location,
-                                bool name_is_strict_reserved, int pos,
-                                bool* ok);
-
   // Get odd-ball literals.
   Literal* GetLiteralUndefined(int position);
 
   // Check if the scope has conflicting var/let declarations from different
   // scopes. This covers for example
   //
   // function f() { { { var x; } let x; } }
   // function g() { { var x; let x; } }
   //
   // The var declarations are hoisted to the function scope, but originate from
@@ skipping 295 matching lines @@
     } else {
       fni_->PushLiteralName(ast_value_factory()->anonymous_function_string());
     }
   }
 
   V8_INLINE void PushEnclosingName(const AstRawString* name) {
     DCHECK_NOT_NULL(fni_);
     fni_->PushEnclosingName(name);
   }
 
-  V8_INLINE void InferFunctionName(FunctionLiteral* func_to_infer) {
+  V8_INLINE void AddFunctionForNameInference(FunctionLiteral* func_to_infer) {
+    DCHECK_NOT_NULL(fni_);
     fni_->AddFunction(func_to_infer);
   }
 
+  V8_INLINE void InferFunctionName() {
+    DCHECK_NOT_NULL(fni_);
+    fni_->Infer();
+  }
+
   // If we assign a function literal to a property we pretenure the
   // literal so it can be added as a constant function property.
   V8_INLINE static void CheckAssigningFunctionLiteralToProperty(
       Expression* left, Expression* right) {
     DCHECK(left != NULL);
     if (left->IsProperty() && right->IsFunctionLiteral()) {
       right->AsFunctionLiteral()->set_pretenure();
     }
   }
 
@@ skipping 173 matching lines @@
 
   V8_INLINE Expression* ExpressionFromString(int pos) {
     const AstRawString* symbol = GetSymbol();
     fni_->PushLiteralName(symbol);
     return factory()->NewStringLiteral(symbol, pos);
   }
 
   V8_INLINE ZoneList<Expression*>* NewExpressionList(int size) const {
     return new (zone()) ZoneList<Expression*>(size, zone());
   }
-  V8_INLINE ZoneList<ObjectLiteral::Property*>* NewPropertyList(
+  V8_INLINE ZoneList<ObjectLiteral::Property*>* NewObjectPropertyList(
       int size) const {
     return new (zone()) ZoneList<ObjectLiteral::Property*>(size, zone());
   }
   V8_INLINE ZoneList<ClassLiteral::Property*>* NewClassPropertyList(
       int size) const {
     return new (zone()) ZoneList<ClassLiteral::Property*>(size, zone());
   }
   V8_INLINE ZoneList<Statement*>* NewStatementList(int size) const {
     return new (zone()) ZoneList<Statement*>(size, zone());
   }
@@ skipping 126 matching lines @@
   int total_preparse_skipped_;
   HistogramTimer* pre_parse_timer_;
 
   bool parsing_on_main_thread_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_