Fully deserialize the scope chain after parsing, not before

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 545 matching lines @@
   }
 
   return factory()->NewCallRuntime(context_index, args, pos);
 }
 
 Parser::Parser(ParseInfo* info)
     : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
                          info->extension(), info->ast_value_factory(), NULL),
       scanner_(info->unicode_cache()),
       reusable_preparser_(NULL),
-      original_scope_(NULL),
       target_stack_(NULL),
       compile_options_(info->compile_options()),
       cached_parse_data_(NULL),
       total_preparse_skipped_(0),
       pre_parse_timer_(NULL),
       parsing_on_main_thread_(true) {
   // Even though we were passed ParseInfo, we should not store it in
   // Parser - this makes sure that Isolate is not accidentally accessed via
   // ParseInfo during background parsing.
   DCHECK(!info->script().is_null() || info->source_stream() != nullptr ||
@@ skipping 16 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, Handle<Context> context,
-    Scope::DeserializationMode deserialization_mode) {
+void Parser::InspectScopeChain(ParseInfo* info,
+                               MaybeHandle<ScopeInfo> maybe_outer_scope) {
   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;
-  if (!context.is_null() && !context->IsNativeContext()) {
-    scope = Scope::DeserializeScopeChain(info->isolate(), zone(), *context,
-                                         script_scope, ast_value_factory(),
-                                         deserialization_mode);
-    DCHECK(!info->is_module() || scope->is_module_scope());
-    if (info->context().is_null()) {
-      DCHECK(deserialization_mode ==
-             Scope::DeserializationMode::kDeserializeOffHeap);
-    } else {
-      // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
-      // means the Parser cannot operate independent of the V8 heap. Tell the
-      // string table to internalize strings and values right after they're
-      // created. This kind of parsing can only be done in the main thread.
-      DCHECK(parsing_on_main_thread_);
-      ast_value_factory()->Internalize(info->isolate());
+  Handle<ScopeInfo> outer_scope;
+  if (maybe_outer_scope.ToHandle(&outer_scope)) {
+    if (outer_scope->scope_type() != SCRIPT_SCOPE) {
+      info->set_allow_lazy_parsing(false);
+    }
+    Handle<ScopeInfo> receiver_scope = outer_scope;
+    while (receiver_scope->scope_type() != SCRIPT_SCOPE &&
+           (receiver_scope->scope_type() != FUNCTION_SCOPE ||
+            IsArrowFunction(receiver_scope->function_kind()))) {
+      if (!receiver_scope->HasOuterScopeInfo()) {
+        receiver_scope = Handle<ScopeInfo>::null();
+        break;
+      }
+      receiver_scope = Handle<ScopeInfo>(receiver_scope->OuterScopeInfo());
+    }
+    if (!receiver_scope.is_null()) {
+      outermost_receiver_function_kind_ = receiver_scope->function_kind();
+      outermost_receiver_scope_type_ = receiver_scope->scope_type();
     }
   }
-  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
   // called in the main thread.
   DCHECK(parsing_on_main_thread_);
 
@@ skipping 10 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(),
-                        Scope::DeserializationMode::kKeepScopeInfo);
+  InspectScopeChain(
+      info,
+      info->context().is_null() || info->context()->IsNativeContext()
+          ? MaybeHandle<ScopeInfo>()
+          : MaybeHandle<ScopeInfo>(info->context()->scope_info(), isolate));
 
   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 37 matching lines @@
   // background thread. We should not access anything Isolate / heap dependent
   // via ParseInfo, and also not pass it forward.
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
   Mode parsing_mode = FLAG_lazy && allow_lazy() ? PARSE_LAZILY : PARSE_EAGERLY;
   if (allow_natives() || extension_ != NULL) parsing_mode = PARSE_EAGERLY;
 
   FunctionLiteral* result = NULL;
   {
-    Scope* outer = original_scope_;
+    Scope* outer = info->script_scope();
     DCHECK_NOT_NULL(outer);
     if (info->is_eval()) {
-      if (!outer->is_script_scope() || is_strict(info->language_mode())) {
+      if (is_strict(info->language_mode())) {
         parsing_mode = PARSE_EAGERLY;
       }
       outer = NewEvalScope(outer);
     } else if (info->is_module()) {
       DCHECK_EQ(outer, info->script_scope());
       outer = NewModuleScope(info->script_scope());
     }
 
     DeclarationScope* scope = outer->AsDeclarationScope();
 
@@ skipping 27 matching lines @@
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
       CheckDecimalLiteralWithLeadingZero(beg_pos,
                                          scanner()->location().end_pos);
     }
     if (ok && is_sloppy(language_mode())) {
       // TODO(littledan): Function bindings on the global object that modify
       // pre-existing bindings should be made writable, enumerable and
       // nonconfigurable if possible, whereas this code will leave attributes
       // unchanged if the property already exists.
-      InsertSloppyBlockFunctionVarBindings(scope, &ok);
+      scope->HoistSloppyBlockFunctions(factory(), &ok);
     }
     if (ok) {
       CheckConflictingVarDeclarations(scope, &ok);
     }
 
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
@@ skipping 24 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(),
-                        Scope::DeserializationMode::kKeepScopeInfo);
+  InspectScopeChain(
+      info,
+      info->context().is_null() || info->context()->IsNativeContext()
+          ? MaybeHandle<ScopeInfo>()
+          : MaybeHandle<ScopeInfo>(info->context()->scope_info(), isolate));
 
   // 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 45 matching lines @@
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   fni_->PushEnclosingName(raw_name);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
-    Scope* outer = original_scope_;
+    Scope* outer = info->script_scope();
     DCHECK(outer);
     FunctionState function_state(&function_state_, &scope_state_, outer,
                                  info->function_kind());
-    DCHECK(is_sloppy(outer->language_mode()) ||
-           is_strict(info->language_mode()));
     FunctionLiteral::FunctionType function_type = ComputeFunctionType(info);
     bool ok = true;
 
     if (info->is_arrow()) {
       bool is_async = allow_harmony_async_await() && info->is_async();
       if (is_async) {
         DCHECK(!scanner()->HasAnyLineTerminatorAfterNext());
         if (!Check(Token::ASYNC)) {
           CHECK(stack_overflow());
           return nullptr;
@@ skipping 3113 matching lines @@
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(function_scope, scope());
     DCHECK_EQ(function_scope, inner_scope->outer_scope());
     DCHECK_EQ(body, inner_block->statements());
     SetLanguageMode(function_scope, inner_scope->language_mode());
     Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
 
     if (is_sloppy(inner_scope->language_mode())) {
-      InsertSloppyBlockFunctionVarBindings(inner_scope, CHECK_OK);
+      inner_scope->HoistSloppyBlockFunctions(factory(), CHECK_OK);
     }
 
     // TODO(littledan): Merge the two rejection blocks into one
     if (IsAsyncFunction(kind)) {
       init_block = BuildRejectPromiseOnException(init_block, CHECK_OK);
     }
 
     DCHECK_NOT_NULL(init_block);
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     if (inner_scope->FinalizeBlockScope() != nullptr) {
       CheckConflictingVarDeclarations(inner_scope, CHECK_OK);
       InsertShadowingVarBindingInitializers(inner_block);
     }
     inner_scope = nullptr;
 
     result->Add(init_block, zone());
     result->Add(inner_block, zone());
   } else {
     DCHECK_EQ(inner_scope, function_scope);
     if (is_sloppy(function_scope->language_mode())) {
-      InsertSloppyBlockFunctionVarBindings(function_scope, CHECK_OK);
+      function_scope->HoistSloppyBlockFunctions(factory(), CHECK_OK);
     }
   }
 
   if (function_type == FunctionLiteral::kNamedExpression) {
     // Now that we know the language mode, we can create the const assignment
     // in the previously reserved spot.
     DCHECK_EQ(function_scope, scope());
     Variable* fvar = function_scope->DeclareFunctionVar(function_name);
     VariableProxy* fproxy = factory()->NewVariableProxy(fvar);
     result->Set(kFunctionNameAssignmentIndex,
@@ skipping 197 matching lines @@
     VariableProxy* to = NewUnresolved(name);
     VariableProxy* from = factory()->NewVariableProxy(parameter);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, to, from, kNoSourcePosition);
     Statement* statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
     inner_block->statements()->InsertAt(0, statement, zone());
   }
 }
 
-void Parser::InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope,
-                                                  bool* ok) {
-  scope->HoistSloppyBlockFunctions(factory(), CHECK_OK_VOID);
-
-  SloppyBlockFunctionMap* map = scope->sloppy_block_function_map();
-  for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
-    // Write in assignments to var for each block-scoped function declaration
-    auto delegates = static_cast<SloppyBlockFunctionStatement*>(p->value);
-    for (SloppyBlockFunctionStatement* delegate = delegates;
-         delegate != nullptr; delegate = delegate->next()) {
-      if (delegate->to() == nullptr) {
-        continue;
-      }
-      Expression* assignment = factory()->NewAssignment(
-          Token::ASSIGN, delegate->to(), delegate->from(), kNoSourcePosition);
-      Statement* statement =
-          factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-      delegate->set_statement(statement);
-    }
-  }
-}
-
-
 // ----------------------------------------------------------------------------
 // Parser support
 
 bool Parser::TargetStackContainsLabel(const AstRawString* label) {
   for (ParserTarget* t = target_stack_; t != NULL; t = t->previous()) {
     if (ContainsLabel(t->statement()->labels(), label)) return true;
   }
   return false;
 }
 
@@ skipping 134 matching lines @@
     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(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()) {
     result = DoParseLazy(info, info->function_name(), stream_ptr);
   } else {
     fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
@@ skipping 1524 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8