Extract ParseInfo from CompilationInfo.

src/background-parsing-task.cc

 // Copyright 2014 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/background-parsing-task.h"
 
 namespace v8 {
 namespace internal {
 
 BackgroundParsingTask::BackgroundParsingTask(
     StreamedSource* source, ScriptCompiler::CompileOptions options,
     int stack_size, Isolate* isolate)
     : source_(source), options_(options), stack_size_(stack_size) {
-  // Prepare the data for the internalization phase and compilation phase, which
-  // will happen in the main thread after parsing.
-  source->info.Reset(new i::CompilationInfoWithZone(source->source_stream.get(),
-                                                    source->encoding, isolate));
-  source->info->MarkAsGlobal();
 
-  // We don't set the context to the CompilationInfo yet, because the background
-  // thread cannot do anything with it anyway. We set it just before compilation
-  // on the foreground thread.
   DCHECK(options == ScriptCompiler::kProduceParserCache ||
          options == ScriptCompiler::kProduceCodeCache ||
          options == ScriptCompiler::kNoCompileOptions);
-  source->allow_lazy =
-      !i::Compiler::DebuggerWantsEagerCompilation(source->info.get());
 
-  if (!source->allow_lazy && options_ == ScriptCompiler::kProduceParserCache) {
+  // Prepare the data for the internalization phase and compilation phase, which
+  // will happen in the main thread after parsing.
+  Zone* zone = new Zone();
+  ParseInfo* info = new ParseInfo(zone);
+  source->zone.Reset(zone);
+  source->info.Reset(info);
+  info->set_source_stream(source->source_stream.get());

[marja, 2015/03/04 09:24:40]

Would it make sense to have a ctor of ParseInfo which takes these things as
params?

[titzer, 2015/03/04 22:39:35]

I tried that, and you end up with ctor hell with default-initializing all the
fields three different times in three different constructors. I changed the
InitFrom* functions to return this, to allow chaining.

+  info->set_source_stream_encoding(source->encoding);
+  info->set_hash_seed(isolate->heap()->HashSeed());
+  info->set_global();
+  info->set_unicode_cache(&source_->unicode_cache);
+
+  bool disable_lazy = !Compiler::DebuggerWantsEagerCompilation(isolate);
+  if (disable_lazy && options_ == ScriptCompiler::kProduceParserCache) {
     // Producing cached data while parsing eagerly is not supported.
-    options_ = ScriptCompiler::kNoCompileOptions;
+    options = ScriptCompiler::kNoCompileOptions;

[marja, 2015/03/04 09:24:40]

Huh, the options & options_ modifying is a bit unclear and hard to see that it's
going correctly now.

[titzer, 2015/03/04 22:39:35]

Ok, I've fixed this so the options are only stored in the ParseInfo now.

+    info->set_compile_options(ScriptCompiler::kNoCompileOptions);
   }
+
+  options_ = ScriptCompiler::kNoCompileOptions;

[marja, 2015/03/04 09:24:40]

... why is this correct? Won't this just always kill the compile options? (and
we'll never get into the source_->info->set_cached_data(&script_data); branch in
Run).

Some tests *should* fail if you mess this up, though :)

[titzer, 2015/03/04 22:39:35]

Fixed.

+  info->set_compile_options(options);
+  info->set_allow_lazy_parsing(!disable_lazy);
+  source->allow_lazy = !disable_lazy;
   source->hash_seed = isolate->heap()->HashSeed();
 }
 
 
 void BackgroundParsingTask::Run() {
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
 
   ScriptData* script_data = NULL;
   if (options_ == ScriptCompiler::kProduceParserCache ||
       options_ == ScriptCompiler::kProduceCodeCache) {
-    source_->info->SetCachedData(&script_data, options_);
+    source_->info->set_cached_data(&script_data);
+    // TODO(titzer): this seems redundant to set the options again.
+    source_->info->set_compile_options(options_);
   }
 
   uintptr_t stack_limit =
       reinterpret_cast<uintptr_t>(&stack_limit) - stack_size_ * KB;
 
+  source_->info->set_stack_limit(stack_limit);
   // Parser needs to stay alive for finalizing the parsing on the main
   // thread. Passing &parse_info is OK because Parser doesn't store it.
-  source_->parser.Reset(new Parser(source_->info.get(), stack_limit,
-                                   source_->hash_seed,
-                                   &source_->unicode_cache));
+  source_->parser.Reset(new Parser(source_->info.get()));
   source_->parser->set_allow_lazy(source_->allow_lazy);
   source_->parser->ParseOnBackground(source_->info.get());
 
   if (script_data != NULL) {
     source_->cached_data.Reset(new ScriptCompiler::CachedData(
         script_data->data(), script_data->length(),
         ScriptCompiler::CachedData::BufferOwned));
     script_data->ReleaseDataOwnership();
     delete script_data;
   }
 }
 }
 }  // namespace v8::internal