[parser] Refactor of Parse*Statement*, part 5

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 430 matching lines @@
   bool IsNullStatement() { return code_ == kNullStatement; }
 
   bool IsEmptyStatement() { return code_ == kEmptyStatement; }
 
   // Dummy implementation for making statement->somefunc() work in both Parser
   // and PreParser.
   PreParserStatement* operator->() { return this; }
 
   PreParserStatementList statements() { return PreParserStatementList(); }
   void set_scope(Scope* scope) {}
+  void Initialize(PreParserExpression cond, PreParserStatement body) {}
 
  private:
   enum Type {
     kNullStatement,
     kEmptyStatement,
     kUnknownStatement,
     kJumpStatement,
     kStringLiteralExpressionStatement,
     kUseStrictExpressionStatement,
     kUseAsmExpressionStatement,
@@ skipping 172 matching lines @@
   PreParserStatement NewContinueStatement(PreParserStatement target, int pos) {
     return PreParserStatement::Jump();
   }
 
   PreParserStatement NewWithStatement(Scope* scope,
                                       PreParserExpression expression,
                                       PreParserStatement statement, int pos) {
     return PreParserStatement::Default();
   }
 
+  PreParserStatement NewDoWhileStatement(ZoneList<const AstRawString*>* labels,
+                                         int pos) {
+    return PreParserStatement::Default();
+  }
+
+  PreParserStatement NewWhileStatement(ZoneList<const AstRawString*>* labels,
+                                       int pos) {
+    return PreParserStatement::Default();
+  }
+
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
   }
 };
 
 
@@ skipping 145 matching lines @@
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
   Statement ParseFunctionDeclaration(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 ParseSwitchStatement(ZoneList<const AstRawString*>* labels,
                                  bool* ok);
-  Statement ParseDoWhileStatement(ZoneList<const AstRawString*>* labels,
-                                  bool* ok);
-  Statement ParseWhileStatement(ZoneList<const AstRawString*>* labels,
-                                bool* ok);
   Statement ParseForStatement(ZoneList<const AstRawString*>* labels, bool* ok);
-  Statement ParseThrowStatement(bool* ok);
   Statement ParseTryStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
-  Expression ParseDoExpression(bool* ok);
 
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE LazyParsingResult
   SkipLazyFunctionBody(int* materialized_literal_count,
                        int* expected_property_count, bool may_abort, bool* ok) {
     UNREACHABLE();
@@ skipping 94 matching lines @@
   V8_INLINE bool ContainsLabel(ZoneList<const AstRawString*>* labels,
                                PreParserIdentifier label) {
     return false;
   }
 
   V8_INLINE PreParserExpression RewriteReturn(PreParserExpression return_value,
                                               int pos) {
     return return_value;
   }
 
+  V8_INLINE PreParserExpression RewriteDoExpression(PreParserStatement body,
+                                                    int pos, bool* ok) {
+    return PreParserExpression::Default();
+  }
+
   // TODO(nikolaos): The preparser currently does not keep track of labels
   // and targets.
   V8_INLINE PreParserStatement LookupBreakTarget(PreParserIdentifier label,
                                                  bool* ok) {
     return PreParserStatement::Default();
   }
   V8_INLINE PreParserStatement LookupContinueTarget(PreParserIdentifier label,
                                                     bool* ok) {
     return PreParserStatement::Default();
   }
@@ skipping 309 matching lines @@
       bool ignore_completion_value, int pos) {
     return PreParserStatement::Default();
   }
 
   V8_INLINE PreParserExpression
   NewV8Intrinsic(PreParserIdentifier name, PreParserExpressionList arguments,
                  int pos, bool* ok) {
     return PreParserExpression::Default();
   }
 
+  V8_INLINE PreParserStatement NewThrowStatement(PreParserExpression exception,
+                                                 int pos) {
+    return PreParserStatement::Jump();
+  }
+
   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 103 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H