Proof of concept: API for doing only one parsing pass instead of first preparsing and then parsing.

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 192 matching lines @@
       new(zone()) RegExpQuantifier(min, max, quantifier_type, atom), zone());
   LAST(ADD_TERM);
 }
 
 
 Handle<String> Parser::LookupSymbol(int symbol_id) {
   // If there is no preparser symbol data, a negative number will be passed. In
   // that case, we'll just read the literal from Scanner. This also guards
   // against corrupt preparse data where the symbol id is larger than the symbol
   // count.
-  if (symbol_id < 0 ||
-      (pre_parse_data_ && symbol_id >= pre_parse_data_->symbol_count())) {
+  if (symbol_id < 0 || (cached_data_ && *cached_data_ &&
+                        symbol_id >= (*cached_data_)->symbol_count())) {
     if (scanner()->is_literal_ascii()) {
+      if (log_) {
+        log_->LogAsciiSymbol(position(), scanner()->literal_ascii_string());
+      }
       return isolate()->factory()->InternalizeOneByteString(
           Vector<const uint8_t>::cast(scanner()->literal_ascii_string()));
+
     } else {
+      if (log_) {
+        log_->LogUtf16Symbol(position(), scanner()->literal_utf16_string());
+      }
       return isolate()->factory()->InternalizeTwoByteString(
           scanner()->literal_utf16_string());
     }
   }
   return LookupCachedSymbol(symbol_id);
 }
 
 
 Handle<String> Parser::LookupCachedSymbol(int symbol_id) {
   // Make sure the cache is large enough to hold the symbol identifier.
@@ skipping 257 matching lines @@
     elements->set(i, *args[i]);
   }
   Handle<JSArray> array = factory->NewJSArrayWithElements(elements);
   Handle<Object> result = factory->NewSyntaxError(message, array);
   parser_->isolate()->Throw(*result, &location);
 }
 
 
 Handle<String> ParserTraits::GetSymbol(Scanner* scanner) {
   int symbol_id = -1;
-  if (parser_->pre_parse_data() != NULL) {
-    symbol_id = parser_->pre_parse_data()->GetSymbolIdentifier();
+  if (parser_->cached_data_ != NULL && *(parser_->cached_data_) != NULL) {
+    symbol_id = (*parser_->cached_data_)->GetSymbolIdentifier();
   }
   return parser_->LookupSymbol(symbol_id);
 }
 
 
 Handle<String> ParserTraits::NextLiteralString(Scanner* scanner,
                                                PretenureFlag tenured) {
   if (scanner->is_next_literal_ascii()) {
     return parser_->isolate_->factory()->NewStringFromAscii(
         scanner->next_literal_ascii_string(), tenured);
@@ skipping 89 matching lines @@
   return parser_->ParseFunctionLiteral(name, function_name_location,
                                        name_is_strict_reserved, is_generator,
                                        function_token_position, type, ok);
 }
 
 
 Parser::Parser(CompilationInfo* info)
     : ParserBase<ParserTraits>(&scanner_,
                                info->isolate()->stack_guard()->real_climit(),
                                info->extension(),
+                               NULL,
                                info->zone(),
                                this),
       isolate_(info->isolate()),
       symbol_cache_(0, info->zone()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
-      pre_parse_data_(NULL),
+      cached_data_(NULL),
       info_(info) {
   ASSERT(!script_.is_null());
   isolate_->set_ast_node_id(0);
   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
   set_allow_natives_syntax(FLAG_allow_natives_syntax || info->is_native());
   set_allow_lazy(false);  // Must be explicitly enabled.
   set_allow_generators(FLAG_harmony_generators);
   set_allow_for_of(FLAG_harmony_iteration);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
 }
 
 
 FunctionLiteral* Parser::ParseProgram() {
+  CompleteParserRecorder recorder;
+  if (cached_data_ != NULL && *cached_data_ == NULL) {
+    // We're asked to generate data to cache.
+    log_ = &recorder;
+  }
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
   HistogramTimerScope timer_scope(isolate()->counters()->parse(), true);
   Handle<String> source(String::cast(script_->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   fni_ = new(zone()) FuncNameInferrer(isolate(), zone());
@@ skipping 21 matching lines @@
       PrintF("[parsing eval");
     } else if (info()->script()->name()->IsString()) {
       String* name = String::cast(info()->script()->name());
       SmartArrayPointer<char> name_chars = name->ToCString();
       PrintF("[parsing script: %s", name_chars.get());
     } else {
       PrintF("[parsing script");
     }
     PrintF(" - took %0.3f ms]\n", ms);
   }
+  if (cached_data_ != NULL && *cached_data_ == NULL) {
+    Vector<unsigned> store = recorder.ExtractData();
+    *cached_data_ = new ScriptDataImpl(store);
+    log_ = NULL;
+  }
   return result;
 }
 
 
 FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,
                                         Handle<String> source) {
   ASSERT(scope_ == NULL);
   ASSERT(target_stack_ == NULL);
-  if (pre_parse_data_ != NULL) pre_parse_data_->Initialize();
+  if (cached_data_ != NULL && *cached_data_ != NULL) {
+    (*cached_data_)->Initialize();
+  }
 
   Handle<String> no_name = isolate()->factory()->empty_string();
 
   FunctionLiteral* result = NULL;
   { Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
     info->SetGlobalScope(scope);
     if (!info->context().is_null()) {
       scope = Scope::DeserializeScopeChain(*info->context(), scope, zone());
     }
     original_scope_ = scope;
@@ skipping 3098 matching lines @@
     // 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) {
       int function_block_pos = position();
       FunctionEntry entry;
-      if (pre_parse_data_ != NULL) {
-        // If we have pre_parse_data_, we use it to skip parsing the function
-        // body.  The preparser data contains the information we need to
+      if (cached_data_ != NULL && *cached_data_ != NULL) {
+        // 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.
-        entry = pre_parse_data()->GetFunctionEntry(function_block_pos);
+        entry = (*cached_data_)->GetFunctionEntry(function_block_pos);
         if (entry.is_valid()) {
           if (entry.end_pos() <= function_block_pos) {
             // End position greater than end of stream is safe, and hard
             // to check.
             ReportInvalidPreparseData(function_name, CHECK_OK);
           }
           scanner()->SeekForward(entry.end_pos() - 1);
 
           scope->set_end_position(entry.end_pos());
           Expect(Token::RBRACE, CHECK_OK);
@@ skipping 12 matching lines @@
           // lazily parsed, but PreParser thinks it should be eagerly parsed --
           // in that case we fall back to eager parsing in Parser, too. Note
           // that the opposite case is worse: if PreParser thinks a function
           // should be lazily parsed, but Parser thinks it should be eagerly
           // parsed, it will never advance the preparse data beyond that
           // function and all further laziness will fail (all functions will be
           // parsed eagerly).
           is_lazily_parsed = false;
         }
       } else {
+        if (log_) log_->PauseRecording();
         // With no preparser 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 = LazyParseFunctionLiteral(&logger);
         if (result == PreParser::kPreParseStackOverflow) {
           // Propagate stack overflow.
           set_stack_overflow();
           *ok = false;
           return NULL;
@@ skipping 11 matching lines @@
           *ok = false;
           return NULL;
         }
         scope->set_end_position(logger.end());
         Expect(Token::RBRACE, CHECK_OK);
         isolate()->counters()->total_preparse_skipped()->Increment(
             scope->end_position() - function_block_pos);
         materialized_literal_count = logger.literals();
         expected_property_count = logger.properties();
         scope_->SetStrictMode(logger.strict_mode());
+        if (log_) {
+          log_->ResumeRecording();
+          // Position right after terminal '}'.
+          int body_end = scanner()->location().end_pos;
+          log_->LogFunction(function_block_pos, body_end,
+                            materialized_literal_count,
+                            expected_property_count,
+                            scope_->strict_mode());
+        }
       }
     }
 
     if (!is_lazily_parsed) {
       // Everything inside an eagerly parsed function will be parsed eagerly
       // (see comment above).
       ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
       body = new(zone()) ZoneList<Statement*>(8, zone());
       if (fvar != NULL) {
         VariableProxy* fproxy = scope_->NewUnresolved(
@@ skipping 1279 matching lines @@
   ASSERT(info()->function() == NULL);
   FunctionLiteral* result = NULL;
   if (info()->is_lazy()) {
     ASSERT(!info()->is_eval());
     if (info()->shared_info()->is_function()) {
       result = ParseLazy();
     } else {
       result = ParseProgram();
     }
   } else {
-    ScriptDataImpl* pre_parse_data = info()->pre_parse_data();
-    set_pre_parse_data(pre_parse_data);
-    if (pre_parse_data != NULL && pre_parse_data->has_error()) {
-      Scanner::Location loc = pre_parse_data->MessageLocation();
-      const char* message = pre_parse_data->BuildMessage();
-      Vector<const char*> args = pre_parse_data->BuildArgs();
+    ScriptDataImpl** cached_data = info()->cached_data();
+    set_cached_data(cached_data);
+    if (cached_data != NULL && *cached_data != NULL &&
+        (*cached_data)->has_error()) {
+      Scanner::Location loc = (*cached_data)->MessageLocation();
+      const char* message = (*cached_data)->BuildMessage();
+      Vector<const char*> args = (*cached_data)->BuildArgs();
       ParserTraits::ReportMessageAt(loc, message, args);
       DeleteArray(message);
       for (int i = 0; i < args.length(); i++) {
         DeleteArray(args[i]);
       }
       DeleteArray(args.start());
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal