Hook up compiler dispatcher jobs to lazy parser.

src/compiler-dispatcher/compiler-dispatcher-job.cc

 // Copyright 2016 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/compiler-dispatcher/compiler-dispatcher-job.h"
 
 #include "src/assert-scope.h"
 #include "src/global-handles.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 28 matching lines @@
 }
 
 void CompilerDispatcherJob::PrepareToParseOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kInitial);
   HandleScope scope(isolate_);
   unicode_cache_.reset(new UnicodeCache());
   zone_.reset(new Zone(isolate_->allocator()));
   Handle<SharedFunctionInfo> shared(function_->shared(), isolate_);
   Handle<Script> script(Script::cast(shared->script()), isolate_);
+  DCHECK(script->type() != Script::TYPE_NATIVE);
+
   Handle<String> source(String::cast(script->source()), isolate_);
   if (source->IsExternalTwoByteString()) {
     character_stream_.reset(new ExternalTwoByteStringUtf16CharacterStream(
         Handle<ExternalTwoByteString>::cast(source), shared->start_position(),
         shared->end_position()));
   } else if (source->IsExternalOneByteString()) {
     character_stream_.reset(new ExternalOneByteStringUtf16CharacterStream(
         Handle<ExternalOneByteString>::cast(source), shared->start_position(),
         shared->end_position()));
   } else {
     source = String::Flatten(source);
     // Have to globalize the reference here, so it survives between function
     // calls.
     source_ = Handle<String>::cast(isolate_->global_handles()->Create(*source));
     character_stream_.reset(new GenericStringUtf16CharacterStream(
         source_, shared->start_position(), shared->end_position()));
   }
   parse_info_.reset(new ParseInfo(zone_.get()));
   parse_info_->set_isolate(isolate_);
   parse_info_->set_character_stream(character_stream_.get());
-  parse_info_->set_hash_seed(isolate_->heap()->HashSeed());

[marja, 2016/08/05 09:43:05]

Why don't you need the hash seed any more?

[jochen (gone - plz use gerrit), 2016/08/05 11:20:16]

Oops, didn't want to delete that

+  parse_info_->set_lazy();

[marja, 2016/08/05 09:43:05]

Why? Don't we need to at least check some FLAG_s to find out if lazy parsing is
allowed?

[jochen (gone - plz use gerrit), 2016/08/05 11:20:15]

In the spirit of ParseLazy this flag means that the function was compiled lazily
before, and now should be eagerly compiled :-/

+  parse_info_->set_is_named_expression(shared->is_named_expression());
+  parse_info_->set_calls_eval(shared->scope_info()->CallsEval());
+  parse_info_->set_compiler_hints(shared->compiler_hints());
+  parse_info_->set_start_position(shared->start_position());
+  parse_info_->set_end_position(shared->end_position());
   parse_info_->set_unicode_cache(unicode_cache_.get());
+  parse_info_->set_language_mode(shared->language_mode());
+
   parser_.reset(new Parser(parse_info_.get()));
   parser_->DeserializeScopeChain(
       parse_info_.get(), handle(function_->context(), isolate_),
       Scope::DeserializationMode::kDeserializeOffHeap);
+
+  Handle<String> name(String::cast(shared->name()));
+  parse_info_->set_function_name(
+      parse_info_->ast_value_factory()->GetString(name));
   status_ = CompileJobStatus::kReadyToParse;
 }
 
 void CompilerDispatcherJob::Parse() {
   DCHECK(can_parse_on_background_thread_ ||
          ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kReadyToParse);
 
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
@@ skipping 26 matching lines @@
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
 
   if (parse_info_->literal() == nullptr) {
     status_ = CompileJobStatus::kFailed;
     return;
   }
 
+  {
+    HandleScope scope(isolate_);
+    Handle<String> inferred_name(function_->shared()->inferred_name());
+    parse_info_->literal()->set_inferred_name(inferred_name);
+  }

[marja, 2016/08/05 09:43:05]

Why is this good - the HandleScope goes out of Scope but FunctionLiteral stored
the Handle... Why is that working?

[jochen (gone - plz use gerrit), 2016/08/05 11:20:15]

True. I'll just do that when preparing the compilation, because I'll need a
DeferredHandleScope then anyways

+
   InternalizeParsingResult();
 
   status_ = CompileJobStatus::kReadyToCompile;
 }
 
 void CompilerDispatcherJob::ReportErrorsOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kFailed);
 
   // Internalizing the parsing result will throw the error.
@@ skipping 38 matching lines @@
 
   parse_info_->set_character_stream(nullptr);
   parse_info_->set_unicode_cache(nullptr);
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
 }
 
 }  // namespace internal
 }  // namespace v8