Move ParseVariableDeclarations to ParserBase.

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/parsing/parser-base.h"
 
@@ skipping 596 matching lines @@
   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;
+  typedef PreParserStatement Block;
 
   // 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.
 
@@ skipping 102 matching lines @@
   Statement ParseHoistableDeclaration(bool* ok);
   Statement ParseHoistableDeclaration(int pos, ParseFunctionFlags flags,
                                       bool* ok);
   Statement ParseFunctionDeclaration(bool* ok);
   Statement ParseAsyncFunctionDeclaration(bool* ok);
   Expression ParseAsyncFunctionExpression(bool* ok);
   Statement ParseClassDeclaration(bool* ok);
   Statement ParseBlock(bool* ok);
   Statement ParseVariableStatement(VariableDeclarationContext var_context,
                                    bool* ok);
-  Statement ParseVariableDeclarations(VariableDeclarationContext var_context,
-                                      int* num_decl, bool* is_lexical,
-                                      bool* is_binding_pattern,
-                                      Scanner::Location* first_initializer_loc,
-                                      Scanner::Location* bindings_loc,
-                                      bool* ok);
   Statement ParseExpressionOrLabelledStatement(
       AllowLabelledFunctionStatement allow_function, bool* ok);
   Statement ParseIfStatement(bool* ok);
   Statement ParseContinueStatement(bool* ok);
   Statement ParseBreakStatement(bool* ok);
   Statement ParseReturnStatement(bool* ok);
   Statement ParseWithStatement(bool* ok);
   Statement ParseSwitchStatement(bool* ok);
   Statement ParseDoWhileStatement(bool* ok);
   Statement ParseWhileStatement(bool* ok);
@@ skipping 76 matching lines @@
   RewriteAwaitExpression(PreParserExpression value, int pos) {
     return value;
   }
   V8_INLINE PreParserExpression RewriteYieldStar(PreParserExpression generator,
                                                  PreParserExpression expression,
                                                  int pos) {
     return PreParserExpression::Default();
   }
   V8_INLINE void RewriteNonPattern(bool* ok) { ValidateExpression(ok); }
 
+  V8_INLINE void DeclareAndInitializeVariables(
+      PreParserStatement block,
+      const DeclarationDescriptor* declaration_descriptor,
+      const DeclarationParsingResult::Declaration* declaration,
+      ZoneList<const AstRawString*>* names, bool* 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 {
     return identifier.IsEval();
   }
 
@@ skipping 59 matching lines @@
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   V8_INLINE static void PushLiteralName(FuncNameInferrer* fni,
                                         PreParserIdentifier id) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
 
+  V8_INLINE static void PushVariableName(FuncNameInferrer* fni,
+                                         PreParserIdentifier id) {
+    // PreParser should not use FuncNameInferrer.
+    UNREACHABLE();
+  }
+
   V8_INLINE void PushPropertyName(FuncNameInferrer* fni,
                                   PreParserExpression expression) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
 
   V8_INLINE static void InferFunctionName(FuncNameInferrer* fni,
                                           PreParserExpression expression) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
@@ skipping 74 matching lines @@
     return PreParserExpression::Default();
   }
 
   V8_INLINE static bool IsEmptyExpression(PreParserExpression expr) {
     return expr.IsEmpty();
   }
 
   V8_INLINE static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
+
   V8_INLINE static PreParserStatementList NullStatementList() {
     return PreParserStatementList();
   }
+
+  V8_INLINE static PreParserStatement NullBlock() {
+    return PreParserStatement::Default();
+  }
+
   V8_INLINE PreParserIdentifier EmptyIdentifierString() const {
     return PreParserIdentifier::Default();
   }
 
   // Odd-ball literal creators.
   V8_INLINE PreParserExpression GetLiteralTheHole(int position) {
     return PreParserExpression::Default();
   }
 
+  V8_INLINE PreParserExpression GetLiteralUndefined(int position) {
+    return PreParserExpression::Default();
+  }
+
   // Producing data during the recursive descent.
   PreParserIdentifier GetSymbol() const;
 
   V8_INLINE PreParserIdentifier GetNextSymbol() const {
     return PreParserIdentifier::Default();
   }
 
   V8_INLINE PreParserIdentifier GetNumberAsSymbol() const {
     return PreParserIdentifier::Default();
   }
@@ skipping 41 matching lines @@
   }
 
   V8_INLINE PreParserExpressionList NewPropertyList(int size) const {
     return PreParserExpressionList();
   }
 
   V8_INLINE PreParserStatementList NewStatementList(int size) const {
     return PreParserStatementList();
   }
 
+  V8_INLINE static PreParserStatement NewBlock(
+      ZoneList<const AstRawString*>* labels, int capacity,
+      bool ignore_completion_value, int pos) {
+    return PreParserStatement::Default();
+  }
+
   V8_INLINE void AddParameterInitializationBlock(
       const PreParserFormalParameters& parameters, PreParserStatementList body,
       bool is_async, bool* ok) {}
 
   V8_INLINE void AddFormalParameter(PreParserFormalParameters* parameters,
                                     PreParserExpression pattern,
                                     PreParserExpression initializer,
                                     int initializer_end_position,
                                     bool is_rest) {
     ++parameters->arity;
@@ skipping 95 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H