Only pass the outer scope info with ParseInfo

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-expression-rewriter.h"
@@ skipping 585 matching lines @@
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed()));
     info->set_ast_value_factory_owned();
     ast_value_factory_ = info->ast_value_factory();
     ast_node_factory_.set_ast_value_factory(ast_value_factory_);
   }
 }
 
-void Parser::DeserializeScopeChain(ParseInfo* info,
-                                   MaybeHandle<Context> maybe_context) {
+void Parser::DeserializeScopeChain(
+    ParseInfo* info, MaybeHandle<ScopeInfo> maybe_outer_scope_info) {
   DCHECK(ThreadId::Current().Equals(info->isolate()->thread_id()));
   // TODO(wingo): Add an outer SCRIPT_SCOPE corresponding to the native
   // context, which will have the "this" binding for script scopes.
   DeclarationScope* script_scope = NewScriptScope();
   info->set_script_scope(script_scope);
   Scope* scope = script_scope;
-  Handle<Context> context;
-  if (maybe_context.ToHandle(&context) && !context->IsNativeContext()) {
+  Handle<ScopeInfo> outer_scope_info;
+  if (maybe_outer_scope_info.ToHandle(&outer_scope_info)) {
     scope = Scope::DeserializeScopeChain(
-        info->isolate(), zone(), *context, script_scope, ast_value_factory(),
-        Scope::DeserializationMode::kScopesOnly);
+        info->isolate(), zone(), *outer_scope_info, script_scope,
+        ast_value_factory(), Scope::DeserializationMode::kScopesOnly);
     DCHECK(!info->is_module() || scope->is_module_scope());
   }
   original_scope_ = scope;
 }
 
 FunctionLiteral* Parser::ParseProgram(Isolate* isolate, ParseInfo* info) {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
 
   // It's OK to use the Isolate & counters here, since this function is only
@@ skipping 13 matching lines @@
 
   // Initialize parser state.
   CompleteParserRecorder recorder;
 
   if (produce_cached_parse_data()) {
     log_ = &recorder;
   } else if (consume_cached_parse_data()) {
     cached_parse_data_->Initialize();
   }
 
-  DeserializeScopeChain(info, info->context());
+  DeserializeScopeChain(info, info->maybe_outer_scope_info());
 
   source = String::Flatten(source);
   FunctionLiteral* result;
 
   {
     std::unique_ptr<Utf16CharacterStream> stream;
     if (source->IsExternalTwoByteString()) {
       stream.reset(new ExternalTwoByteStringUtf16CharacterStream(
           Handle<ExternalTwoByteString>::cast(source), 0, source->length()));
     } else if (source->IsExternalOneByteString()) {
@@ skipping 144 matching lines @@
   RuntimeCallTimerScope runtime_timer(isolate, &RuntimeCallStats::ParseLazy);
   HistogramTimerScope timer_scope(isolate->counters()->parse_lazy());
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseLazy");
   Handle<String> source(String::cast(info->script()->source()));
   isolate->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info->shared_info();
-  DeserializeScopeChain(info, info->context());
+  DeserializeScopeChain(info, info->maybe_outer_scope_info());
 
   // Initialize parser state.
   source = String::Flatten(source);
   FunctionLiteral* result;
   {
     std::unique_ptr<Utf16CharacterStream> stream;
     if (source->IsExternalTwoByteString()) {
       stream.reset(new ExternalTwoByteStringUtf16CharacterStream(
           Handle<ExternalTwoByteString>::cast(source),
           shared_info->start_position(), shared_info->end_position()));
@@ skipping 3217 matching lines @@
   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();
   }
-  DCHECK(info->context().is_null() || info->context()->IsNativeContext());
+  DCHECK(info->maybe_outer_scope_info().is_null());
 
   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.
   if (info->is_lazy()) {
@@ skipping 1536 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8