Implement a 'trial parse' step, that will abort pre-parsing excessively

src/preparser.cc

 // Copyright 2011 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.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 81 matching lines @@
     bool name_is_strict_reserved, FunctionKind kind,
     int function_token_position, FunctionLiteral::FunctionType type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   return pre_parser_->ParseFunctionLiteral(
       name, function_name_location, name_is_strict_reserved, kind,
       function_token_position, type, arity_restriction, ok);
 }
 
 
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
-    LanguageMode language_mode, FunctionKind kind, ParserRecorder* log) {
+    LanguageMode language_mode, FunctionKind kind, ParserRecorder* log,
+    Scanner::BookmarkScope* bookmark) {
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   Scope* top_scope = NewScope(scope_, SCRIPT_SCOPE);
   PreParserFactory top_factory(NULL);
   FunctionState top_state(&function_state_, &scope_, top_scope, kNormalFunction,
                           &top_factory);
   scope_->SetLanguageMode(language_mode);
   Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE);
   PreParserFactory function_factory(NULL);
   FunctionState function_state(&function_state_, &scope_, function_scope, kind,
                                &function_factory);
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
   bool ok = true;
   int start_position = peek_position();
-  ParseLazyFunctionLiteralBody(&ok);
-  if (stack_overflow()) return kPreParseStackOverflow;
-  if (!ok) {
+  ParseLazyFunctionLiteralBody(&ok, bookmark);
+  if (bookmark && bookmark->HasBeenReset()) {
+    ;  // Do nothing, as we've just aborted scanning this function.
+  } else if (stack_overflow()) {
+    return kPreParseStackOverflow;
+  } else if (!ok) {
     ReportUnexpectedToken(scanner()->current_token());
   } else {
     DCHECK_EQ(Token::RBRACE, scanner()->peek());
     if (is_strict(scope_->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
     }
   }
   return kPreParseSuccess;
 }
@@ skipping 50 matching lines @@
       if (is_strict(language_mode())) {
         return ParseVariableStatement(kStatementListItem, ok);
       }
       // Fall through.
     default:
       return ParseStatement(ok);
   }
 }
 
 
-void PreParser::ParseStatementList(int end_token, bool* ok) {
+void PreParser::ParseStatementList(int end_token, bool* ok,
+                                   Scanner::BookmarkScope* bookmark) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
+  // Bookkeeping for trial parse if bookmark is set:
+  DCHECK_IMPLIES(bookmark, bookmark->HasBeenSet());
+  bool maybe_reset = bookmark != nullptr;
+  int start_pos = scanner()->location().beg_pos;
+  int count_lines = 0;
+
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
     Token::Value token = peek();
     Scanner::Location old_super_loc = function_state_->super_call_location();
     Statement statement = ParseStatementListItem(ok);
     if (!*ok) return;
     Scanner::Location super_loc = function_state_->super_call_location();
     if (is_strong(language_mode()) &&
         i::IsConstructor(function_state_->kind()) &&
         !old_super_loc.IsValid() && super_loc.IsValid() &&
         token != Token::SUPER) {
       ReportMessageAt(super_loc, "strong_super_call_nested");
       *ok = false;
       return;
     }
     if (directive_prologue) {
       if (statement.IsUseStrictLiteral()) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
       } else if (statement.IsUseStrongLiteral() && allow_strong_mode()) {
         scope_->SetLanguageMode(static_cast<LanguageMode>(
             scope_->language_mode() | STRICT_BIT | STRONG_BIT));
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
     }
+
+    // If we're allowed to reset to a bookmark, we will do so when we see a long
+    // and trivial function.
+    // Our current definition of 'long and trivial) is:
+    // - within the first 10k characters,
+    // - over 200 statements
+    // - all starting with an identifier (i.e., no if, for, while, etc.)
+    if (maybe_reset) {
+      if (token != Token::IDENTIFIER) {
+        maybe_reset = false;
+      } else if (scanner()->location().end_pos - start_pos > 10000) {
+        maybe_reset = false;
+        if (count_lines++ > 200 && bookmark->CanReset()) {

[marja, 2015/04/22 16:40:55]

Hmm, I find this is quite a late point to check whether we can reset the
bookmark... (and my other comments were also assuming we can know it pretty
early). The code might get cleaner if we can know that early. Is there some
reason why we couldn't? So here we'd only have the bookmark in those cases where
we can reset.

[vogelheim, 2015/04/22 17:08:35]

The code certainly gets a lot cleaner if we can predict whether we can reset or
not.

I did this on purpose, to support streaming parsing: When you have an
implementation that looks at the source block-by-block, then it's fully well
possible that you can reset while you're still in the same block, but you can't
if you've progressed to a new block in the mean time.

If we don't want to support this, we can make both API & implementation simpler
by assuming we can always reset if we have successfully set a bookmark.

Not sure which way we'd want to go...

+          bookmark->Reset();
+          return;
+        }
+      }
+    }
   }
 }
 
 
 #define CHECK_OK  ok);                   \
   if (!*ok) return Statement::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
@@ skipping 783 matching lines @@
                       kReferenceError);
       *ok = false;
       return Expression::Default();
     }
   }
 
   return Expression::Default();
 }
 
 
-void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
+void PreParser::ParseLazyFunctionLiteralBody(bool* ok,
+                                             Scanner::BookmarkScope* bookmark) {
   int body_start = position();
-  ParseStatementList(Token::RBRACE, ok);
+  ParseStatementList(Token::RBRACE, ok, bookmark);
   if (!*ok) return;
+  if (bookmark && bookmark->HasBeenReset()) return;
 
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   log_->LogFunction(body_start, body_end,
                     function_state_->materialized_literal_count(),
                     function_state_->expected_property_count(), language_mode(),
                     scope_->uses_super_property());
 }
 
@@ skipping 66 matching lines @@
 
   DCHECK(!spread_pos.IsValid());
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal