Move ParseHoistableDeclaration to ParserBase.

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 249 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* ParseHoistableDeclaration(ZoneList<const AstRawString*>* names,
-                                       bool default_export, bool* ok);
-  Statement* ParseHoistableDeclaration(int pos, ParseFunctionFlags flags,
-                                       ZoneList<const AstRawString*>* names,
-                                       bool default_export, bool* ok);
   Statement* ParseAsyncFunctionDeclaration(ZoneList<const AstRawString*>* names,
                                            bool default_export, bool* ok);
   Expression* ParseAsyncFunctionExpression(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);
 
+  Statement* DeclareFunction(const AstRawString* variable_name,
+                             FunctionLiteral* function, int pos,
+                             bool is_generator, bool is_async,
+                             ZoneList<const AstRawString*>* names, bool* ok);
+
   DoExpression* ParseDoExpression(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 393 matching lines @@
     if (e_stat == nullptr) return false;
     Literal* literal = e_stat->expression()->AsLiteral();
     if (literal == nullptr || !literal->raw_value()->IsString()) return false;
     return arg == nullptr || literal->raw_value()->AsString() == arg;
   }
 
   V8_INLINE static Expression* GetPropertyValue(LiteralProperty* property) {
     return property->value();
   }
 
+  V8_INLINE void GetDefaultStrings(
+      const AstRawString** default_string,
+      const AstRawString** star_default_star_string) {
+    *default_string = ast_value_factory()->default_string();
+    *star_default_star_string = ast_value_factory()->star_default_star_string();
+  }
+
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   V8_INLINE void PushLiteralName(const AstRawString* id) {
     DCHECK_NOT_NULL(fni_);
     fni_->PushLiteralName(id);
   }
 
   V8_INLINE void PushVariableName(const AstRawString* id) {
     DCHECK_NOT_NULL(fni_);
     fni_->PushVariableName(id);
   }
 
   V8_INLINE void PushPropertyName(Expression* expression) {
     DCHECK_NOT_NULL(fni_);
     if (expression->IsPropertyName()) {
       fni_->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
     } 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) {
     fni_->AddFunction(func_to_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()) {
@@ skipping 316 matching lines @@
 
 #ifdef DEBUG
   void Print(AstNode* node);
 #endif  // DEBUG
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_