[parser] Refactor bookmark in SkipLazyFunctionBody

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 274 matching lines @@
     return TypeField::decode(code_) == kBinaryOperationExpression;
   }
 
   // Dummy implementation for making expression->somefunc() work in both Parser
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
   void set_should_eager_compile() {}
+  void set_should_be_used_once_hint() {}
 
   int position() const { return kNoSourcePosition; }
   void set_function_token_position(int position) {}
 
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
     kBinaryOperationExpression,
@@ skipping 325 matching lines @@
   friend class ParserBase<PreParser>;
   friend class v8::internal::ExpressionClassifier<ParserTypes<PreParser>>;
 
  public:
   typedef PreParserIdentifier Identifier;
   typedef PreParserExpression Expression;
   typedef PreParserStatement Statement;
 
   enum PreParseResult {
     kPreParseStackOverflow,
+    kPreParseAbort,
     kPreParseSuccess
   };
 
   PreParser(Zone* zone, Scanner* scanner, AstValueFactory* ast_value_factory,
             ParserRecorder* log, uintptr_t stack_limit)
       : ParserBase<PreParser>(zone, scanner, stack_limit, NULL,
                               ast_value_factory, log),
         use_counts_(nullptr) {}
 
   // Pre-parse the program from the character stream; returns true on
@@ skipping 36 matching lines @@
   // Returns a FunctionEntry describing the body of the function in enough
   // detail that it can be lazily compiled.
   // The scanner is expected to have matched the "function" or "function*"
   // keyword and parameters, and have consumed the initial '{'.
   // At return, unless an error occurred, the scanner is positioned before the
   // the final '}'.
   PreParseResult PreParseLazyFunction(LanguageMode language_mode,
                                       FunctionKind kind,
                                       bool has_simple_parameters,
                                       bool parsing_module, ParserRecorder* log,
-                                      Scanner::BookmarkScope* bookmark,
-                                      int* use_counts);
+                                      bool may_abort, int* use_counts);
 
   // A dummy function, just useful as an argument to CHECK_OK_CUSTOM.
   static void Void() {}
 
  private:
   static const int kLazyParseTrialLimit = 200;
 
   // These types form an algebra over syntactic categories that is just
   // rich enough to let us recognize and propagate the constructs that
   // are either being counted in the preparser data, or is important
   // to throw the correct syntax error exceptions.
 
   // All ParseXXX functions take as the last argument an *ok parameter
   // which is set to false if parsing failed; it is unchanged otherwise.
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
   Statement ParseStatementListItem(bool* ok);
-  void ParseStatementList(int end_token, bool* ok,
-                          Scanner::BookmarkScope* bookmark = nullptr);
+  V8_INLINE bool ParseStatementList(int end_token, bool* ok) {
+    return ParseStatementList(end_token, false, ok);

[vogelheim, 2016/08/30 16:28:42]

If may_abort is set to false, ParseStatementList would only ever return false,
right?

Then maybe just have this:

V8_INLINE void ParseStatementList(int end_token, bool* ok) {
  ParseStatementList(end_token, false, ok);
}

Or maybe add a DCHECK for the ParserStatementList's return value.

[nickie, 2016/08/31 13:23:36]

Done.

+  }
+  bool ParseStatementList(int end_token, bool may_abort, bool* ok);
   Statement ParseStatement(AllowLabelledFunctionStatement allow_function,
                            bool* ok);
   Statement ParseSubStatement(AllowLabelledFunctionStatement allow_function,
                               bool* ok);
   Statement ParseScopedStatement(bool legacy, bool* ok);
   Statement ParseHoistableDeclaration(bool* ok);
   Statement ParseHoistableDeclaration(int pos, ParseFunctionFlags flags,
                                       bool* ok);
   Statement ParseFunctionDeclaration(bool* ok);
   Statement ParseAsyncFunctionDeclaration(bool* ok);
@@ skipping 25 matching lines @@
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
   Expression ParseV8Intrinsic(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 void SkipLazyFunctionBody(
-      int* materialized_literal_count, int* expected_property_count, bool* ok,
-      Scanner::BookmarkScope* bookmark = nullptr) {
+  V8_INLINE bool SkipLazyFunctionBody(int* materialized_literal_count,
+                                      int* expected_property_count,
+                                      bool may_abort, bool* ok) {
     UNREACHABLE();
   }
   Expression ParseFunctionLiteral(
       Identifier name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_pos, FunctionLiteral::FunctionType function_type,
       LanguageMode language_mode, bool* ok);
-  void ParseLazyFunctionLiteralBody(bool* ok,
-                                    Scanner::BookmarkScope* bookmark = nullptr);
+  bool ParseLazyFunctionLiteralBody(bool may_abort, bool* ok);
 
   PreParserExpression ParseClassLiteral(PreParserIdentifier name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok);
 
   struct TemplateLiteralState {};
 
   V8_INLINE TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
@@ skipping 209 matching lines @@
   V8_INLINE static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
   V8_INLINE static PreParserExpression EmptyFunctionLiteral() {
     return PreParserExpression::Default();
   }
 
   V8_INLINE static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
+  V8_INLINE static PreParserStatementList NullStatementList() {
+    return PreParserStatementList();
+  }
   V8_INLINE PreParserIdentifier EmptyIdentifierString() const {
     return PreParserIdentifier::Default();
   }
 
   // Odd-ball literal creators.
   V8_INLINE PreParserExpression GetLiteralTheHole(int position) {
     return PreParserExpression::Default();
   }
 
   // Producing data during the recursive descent.
@@ skipping 165 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H