Hook up compiler dispatcher jobs to lazy parser.

src/parsing/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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast.h"
@@ skipping 40 matching lines @@
       script_scope_(nullptr),
       unicode_cache_(nullptr),
       stack_limit_(0),
       hash_seed_(0),
       compiler_hints_(0),
       start_position_(0),
       end_position_(0),
       isolate_(nullptr),
       cached_data_(nullptr),
       ast_value_factory_(nullptr),
+      function_name_(nullptr),
       literal_(nullptr) {}
 
 ParseInfo::ParseInfo(Zone* zone, Handle<JSFunction> function)
     : ParseInfo(zone, Handle<SharedFunctionInfo>(function->shared())) {
   set_context(Handle<Context>(function->context()));
 }
 
 
 ParseInfo::ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared)
     : ParseInfo(zone) {
@@ skipping 1042 matching lines @@
           shared_info->start_position(), shared_info->end_position()));
     } else if (source->IsExternalOneByteString()) {
       stream.reset(new ExternalOneByteStringUtf16CharacterStream(
           Handle<ExternalOneByteString>::cast(source),
           shared_info->start_position(), shared_info->end_position()));
     } else {
       stream.reset(new GenericStringUtf16CharacterStream(
           source, shared_info->start_position(), shared_info->end_position()));
     }
     Handle<String> name(String::cast(shared_info->name()));
-    result = DoParseLazy(isolate, info, ast_value_factory()->GetString(name),
-                         stream.get());
+    result =
+        DoParseLazy(info, ast_value_factory()->GetString(name), stream.get());
     if (result != nullptr) {
       Handle<String> inferred_name(shared_info->inferred_name());
       result->set_inferred_name(inferred_name);
     }
   }
 
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     std::unique_ptr<char[]> name_chars = result->debug_name()->ToCString();
     PrintF("[parsing function: %s - took %0.3f ms]\n", name_chars.get(), ms);
   }
   return result;
 }
 
 static FunctionLiteral::FunctionType ComputeFunctionType(ParseInfo* info) {
   if (info->is_declaration()) {
     return FunctionLiteral::kDeclaration;
   } else if (info->is_named_expression()) {
     return FunctionLiteral::kNamedExpression;
   } else if (IsConciseMethod(info->function_kind()) ||
              IsAccessorFunction(info->function_kind())) {
     return FunctionLiteral::kAccessorOrMethod;
   }
   return FunctionLiteral::kAnonymousExpression;
 }
 
-FunctionLiteral* Parser::DoParseLazy(Isolate* isolate, ParseInfo* info,
+FunctionLiteral* Parser::DoParseLazy(ParseInfo* info,
                                      const AstRawString* raw_name,
                                      Utf16CharacterStream* source) {
   scanner_.Initialize(source);
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
   DCHECK(ast_value_factory());
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   fni_->PushEnclosingName(raw_name);
 
@@ skipping 4351 matching lines @@
   DCHECK(ast_value_factory()->IsInternalized());
   return (result != NULL);
 }
 
 
 void Parser::ParseOnBackground(ParseInfo* info) {
   parsing_on_main_thread_ = false;
 
   DCHECK(info->literal() == NULL);
   FunctionLiteral* result = NULL;
-  fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
 
   CompleteParserRecorder recorder;
   if (produce_cached_parse_data()) log_ = &recorder;
 
   std::unique_ptr<Utf16CharacterStream> stream;
   Utf16CharacterStream* stream_ptr;
   if (info->character_stream()) {
     DCHECK(info->source_stream() == nullptr);
     stream_ptr = info->character_stream();
   } else {
     DCHECK(info->character_stream() == nullptr);
     stream.reset(new ExternalStreamingStream(info->source_stream(),
                                              info->source_stream_encoding()));
     stream_ptr = stream.get();
   }
-  scanner_.Initialize(stream_ptr);
   DCHECK(info->context().is_null() || info->context()->IsNativeContext());
 
   DCHECK(original_scope_);
 
   // When streaming, we don't know the length of the source until we have parsed
   // it. The raw data can be UTF-8, so we wouldn't know the source length until
   // we have decoded it anyway even if we knew the raw data length (which we
   // don't). We work around this by storing all the scopes which need their end
   // position set at the end of the script (the top scope and possible eval
   // scopes) and set their end position after we know the script length.
-  result = DoParseProgram(info);
+  if (info->is_lazy()) {
+    result = DoParseLazy(info, info->function_name(), stream_ptr);
+  } else {
+    fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
+    scanner_.Initialize(stream_ptr);
+    result = DoParseProgram(info);
+  }
 
   info->set_literal(result);
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (produce_cached_parse_data()) {
     if (result != NULL) *info->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
@@ skipping 1598 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8