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

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 4019 matching lines @@
     // possible reference to the variable in foo's scope. However, it's possible
     // that it will be compiled lazily.
 
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
                              scope_->AllowsLazyCompilation() &&
                              !parenthesized_function_);
     parenthesized_function_ = false;  // The bit was set for this function only.
 
-    if (is_lazily_parsed) {
+    // Trial parse.
+    Scanner::BookmarkScope bookmark(scanner());
+    if (is_lazily_parsed && bookmark.Set()) {
+      // We call SkipLazyFunctionBody with a bookmark, meaning that
+      // SkipLazyFunctionBody may decide to abort the skipping if it
+      // finds out the function should really have been eagerly parsed
+      // afterall.
       SkipLazyFunctionBody(function_name, &materialized_literal_count,
-                           &expected_property_count, CHECK_OK);
-    } else {
+                           &expected_property_count, ok /*CHECK_OK*/,
+                           &bookmark);
+    }
+
+    // Following the trial parse we can be in one of these states now:
+    // - we wanted to eagerly parse all along
+    //   condition: !is_lazily_parsed
+    //   action: eager parse.
+    // - we wanted to lazy parse and have not tried trial parsing
+    //   condition: is_lazily_parsed (but none of the conditions below)

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

... is this the same as "couldn't trial parse because cannot set bookmark" or
are there some othere reasons why we "have not tried trial parsing"?

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

Yes. Cannot bookmark, or !is_lazily_parsed

+    //   action: lazy parse
+    // - we trial parsed, and trial parsing finished
+    //   condition: is_lazily_parsed && bookmark.HasBeenSet()
+    //   action: we're done.
+    // - we trial parsed, and trial parsing aborted
+    //   condition: is_lazily_parsed && bookmark.HasBeenReset()
+    //   action: eager parse.

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

The logic sounds correct, but... isn't there a simpler way to express it? I'm
assuming we can know early that we cannot trial parse (and that the only reason
for that is not being able to set the bookmark).

So after we have trial parsed (and we know we can successfully do it),
HasBeenReset and HasBeenSet are complements, right, the first means "trial
aborted" and the latter "trial finished"?

How about:

if (is_lazily_parsed) {
  if (bookmark.Set()) { // can set bookmarks
    Skip(..); // trial
    if (trial parsing aborted) {
      is_lazily_parsed = false;
    } // else: trial parsing finished, we're done
  } else {
    Skip(...); // normal lazy parsing without bookmark
  }
}
if (!is_lazily_parsed) {
  ParseEager(..);
}

That puts the trial parsing logic into the same control flow, so we don't need
to try to figure out in retrospect whether we even tried trial parsing or not.

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

That'd work as well. I'll change it.

+    if (!is_lazily_parsed || (is_lazily_parsed && bookmark.HasBeenReset())) {
+      if (bookmark.HasBeenReset()) {
+        // TODO(vogelheim): We're lying, the function is not parenthesized.
+        //     But this will cause the compiler to actually compile it.

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

... we might want to use the non-hacky way of saying "please compile this"
already in this CL...

+        parenthesized = FunctionLiteral::kIsParenthesized;
+      }
+
       body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
                                     kind, CHECK_OK);
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
+    } else if (is_lazily_parsed && bookmark.HasBeenSet()) {
+      ;  // Work was already done in trial parse, above.
+    } else {
+      SkipLazyFunctionBody(function_name, &materialized_literal_count,
+                           &expected_property_count, /*CHECK_OK*/ ok);
     }
 
     // Validate name and parameter names. We can do this only after parsing the
     // function, since the function can declare itself strict.
     CheckFunctionName(language_mode(), kind, function_name,
                       name_is_strict_reserved, function_name_location,
                       CHECK_OK);
     const bool use_strict_params = is_rest || IsConciseMethod(kind);
     CheckFunctionParameterNames(language_mode(), use_strict_params,
                                 eval_args_loc, undefined_loc, dupe_loc,
@@ skipping 28 matching lines @@
     function_literal->set_dont_optimize_reason(kRestParameter);
   }
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 void Parser::SkipLazyFunctionBody(const AstRawString* function_name,
                                   int* materialized_literal_count,
-                                  int* expected_property_count,
-                                  bool* ok) {
+                                  int* expected_property_count, bool* ok,
+                                  Scanner::BookmarkScope* bookmark) {
+  DCHECK_IMPLIES(bookmark, bookmark->HasBeenSet());
   if (produce_cached_parse_data()) CHECK(log_);
 
   int function_block_pos = position();
   if (consume_cached_parse_data() && !cached_parse_data_->rejected()) {
     // If we have cached data, we use it to skip parsing the function body. The
     // data contains the information we need to construct the lazy function.
     FunctionEntry entry =
         cached_parse_data_->GetFunctionEntry(function_block_pos);
     // Check that cached data is valid. If not, mark it as invalid (the embedder
     // handles it). Note that end position greater than end of stream is safe,
@@ skipping 12 matching lines @@
       scope_->SetLanguageMode(entry.language_mode());
       if (entry.uses_super_property()) scope_->RecordSuperPropertyUsage();
       return;
     }
     cached_parse_data_->Reject();
   }
   // With no cached data, we partially parse the function, without building an
   // AST. This gathers the data needed to build a lazy function.
   SingletonLogger logger;
   PreParser::PreParseResult result =
-      ParseLazyFunctionBodyWithPreParser(&logger);
+      ParseLazyFunctionBodyWithPreParser(&logger, bookmark);
+  if (bookmark && bookmark->HasBeenReset()) {
+    return;  // Return immediately if pre-parser devided to abort parsing.
+  }
   if (result == PreParser::kPreParseStackOverflow) {
     // Propagate stack overflow.
     set_stack_overflow();
     *ok = false;
     return;
   }
   if (logger.has_error()) {
     ParserTraits::ReportMessageAt(
         Scanner::Location(logger.start(), logger.end()), logger.message(),
         logger.argument_opt(), logger.error_type());
@@ skipping 108 matching lines @@
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
 
   return body;
 }
 
 
 PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
-    SingletonLogger* logger) {
+    SingletonLogger* logger, Scanner::BookmarkScope* bookmark) {
   // This function may be called on a background thread too; record only the
   // main thread preparse times.
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Start();
   }
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
 
   if (reusable_preparser_ == NULL) {
     reusable_preparser_ = new PreParser(zone(), &scanner_, ast_value_factory(),
                                         NULL, stack_limit_);
     reusable_preparser_->set_allow_lazy(true);
     reusable_preparser_->set_allow_natives(allow_natives());
     reusable_preparser_->set_allow_harmony_modules(allow_harmony_modules());
     reusable_preparser_->set_allow_harmony_arrow_functions(
         allow_harmony_arrow_functions());
     reusable_preparser_->set_allow_harmony_classes(allow_harmony_classes());
     reusable_preparser_->set_allow_harmony_object_literals(
         allow_harmony_object_literals());
     reusable_preparser_->set_allow_harmony_sloppy(allow_harmony_sloppy());
     reusable_preparser_->set_allow_harmony_unicode(allow_harmony_unicode());
     reusable_preparser_->set_allow_harmony_computed_property_names(
         allow_harmony_computed_property_names());
     reusable_preparser_->set_allow_harmony_rest_params(
         allow_harmony_rest_params());
     reusable_preparser_->set_allow_harmony_spreadcalls(
         allow_harmony_spreadcalls());
     reusable_preparser_->set_allow_strong_mode(allow_strong_mode());
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
-      language_mode(), function_state_->kind(), logger);
+      language_mode(), function_state_->kind(), logger, bookmark);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
 
 ClassLiteral* Parser::ParseClassLiteral(const AstRawString* name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
@@ skipping 1478 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal