Mark ParseInfo as top-level in the constructors

src/parsing/parse-info.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/parsing/parse-info.h"
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/ast.h"
 
 namespace v8 {
 namespace internal {
 
 ParseInfo::ParseInfo(Zone* zone)

[marja, 2016/10/12 11:58:57]

Why not also set is_toplevel here?

Then the backgroundparsing task and the other ctor calling this don't need to
set it either. We could just default to top level, and whoever is parsing
something else than top level scripts can set it.

[Toon Verwaest, 2016/10/12 12:17:53]

Why is that a better default? Note that in the other constructors we'd have to
possibly set_toplevel(false) in that case. Also background parsing tasks in the
compiler dispatcher will have to set it to false.

     : zone_(zone),
       flags_(0),
       source_stream_(nullptr),
       source_stream_encoding_(ScriptCompiler::StreamedSource::ONE_BYTE),
       character_stream_(nullptr),
       extension_(nullptr),
       compile_options_(ScriptCompiler::kNoCompileOptions),
       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())) {}
 
 ParseInfo::ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared)
     : ParseInfo(zone) {
   isolate_ = shared->GetIsolate();
 
+  if (shared->is_toplevel()) set_toplevel();
   set_allow_lazy_parsing(FLAG_lazy_inner_functions);
   set_hash_seed(isolate_->heap()->HashSeed());
   set_is_named_expression(shared->is_named_expression());
   set_calls_eval(shared->scope_info()->CallsEval());
   set_compiler_hints(shared->compiler_hints());
   set_start_position(shared->start_position());
   set_end_position(shared->end_position());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_language_mode(shared->language_mode());
   set_shared_info(shared);
 
   Handle<Script> script(Script::cast(shared->script()));
   set_script(script);
   if (!script.is_null() && script->type() == Script::TYPE_NATIVE) {
     set_native();
   }
 
   Handle<HeapObject> scope_info(shared->outer_scope_info());
   if (!scope_info->IsTheHole(isolate()) &&
       Handle<ScopeInfo>::cast(scope_info)->length() > 0) {
     set_outer_scope_info(Handle<ScopeInfo>::cast(scope_info));
   }
 }
 
 ParseInfo::ParseInfo(Zone* zone, Handle<Script> script) : ParseInfo(zone) {
   isolate_ = script->GetIsolate();
 
+  set_toplevel();

[marja, 2016/10/12 11:58:57]

... and then this can go away since it's set in the other ctor.

   set_hash_seed(isolate_->heap()->HashSeed());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_script(script);
 
   if (script->type() == Script::TYPE_NATIVE) {
     set_native();
   }
 }
 
@@ skipping 25 matching lines @@
 }
 
 #ifdef DEBUG
 bool ParseInfo::script_is_native() const {
   return script_->type() == Script::TYPE_NATIVE;
 }
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8