Only conditionally add inner scope when deserializing

src/ast/scopes.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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 122 matching lines @@
       already_resolved_(true) {
   SetDefaults();
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
-  AddInnerScope(inner_scope);
+  if (inner_scope != nullptr) AddInnerScope(inner_scope);
 }
 
 DeclarationScope::DeclarationScope(Zone* zone, Scope* inner_scope,
                                    ScopeType scope_type,
                                    Handle<ScopeInfo> scope_info)
     : Scope(zone, inner_scope, scope_type, scope_info),
       function_kind_(scope_info.is_null() ? kNormalFunction
                                           : scope_info->function_kind()),
       temps_(4, zone),
       params_(4, zone),
       sloppy_block_function_map_(zone),
       module_descriptor_(nullptr) {
   SetDefaults();
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
              const AstRawString* catch_variable_name)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       decls_(0, zone),
       scope_type_(CATCH_SCOPE),
       already_resolved_(true) {
   SetDefaults();
-  AddInnerScope(inner_scope);
+  if (inner_scope != nullptr) AddInnerScope(inner_scope);
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable =
       variables_.Declare(zone, this, catch_variable_name, VAR, Variable::NORMAL,
                          kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 void DeclarationScope::SetDefaults() {
   is_declaration_scope_ = true;
   has_simple_parameters_ = true;
@@ skipping 46 matching lines @@
   DeclarationScope* scope = GetClosureScope();
   return !scope->is_function_scope() || scope->has_simple_parameters();
 }
 
 Scope* Scope::DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                     Context* context,
                                     DeclarationScope* script_scope,
                                     AstValueFactory* ast_value_factory,
                                     DeserializationMode deserialization_mode) {
   // Reconstruct the outer scope chain from a closure's context chain.
-  Scope* current_scope = NULL;
-  Scope* innermost_scope = NULL;
+  Scope* current_scope = nullptr;
+  Scope* innermost_scope = nullptr;
   while (!context->IsNativeContext()) {
     if (context->IsWithContext() || context->IsDebugEvaluateContext()) {
       // For scope analysis, debug-evaluate is equivalent to a with scope.
       Scope* with_scope = new (zone)
           Scope(zone, current_scope, WITH_SCOPE, Handle<ScopeInfo>::null());
       current_scope = with_scope;
       // All the inner scopes are inside a with.
-      for (Scope* s = innermost_scope; s != NULL; s = s->outer_scope()) {
+      for (Scope* s = innermost_scope; s != nullptr; s = s->outer_scope()) {
         s->scope_inside_with_ = true;
       }
     } else if (context->IsScriptContext()) {
       ScopeInfo* scope_info = context->scope_info();
       current_scope = new (zone) DeclarationScope(
           zone, current_scope, SCRIPT_SCOPE, Handle<ScopeInfo>(scope_info));
     } else if (context->IsFunctionContext()) {
       ScopeInfo* scope_info = context->closure()->shared()->scope_info();
       current_scope = new (zone) DeclarationScope(
           zone, current_scope, FUNCTION_SCOPE, Handle<ScopeInfo>(scope_info));
@@ skipping 11 matching lines @@
     } else {
       DCHECK(context->IsCatchContext());
       String* name = context->catch_name();
       current_scope =
           new (zone) Scope(zone, current_scope,
                            ast_value_factory->GetString(handle(name, isolate)));
     }
     if (deserialization_mode == DeserializationMode::kDeserializeOffHeap) {
       current_scope->DeserializeScopeInfo(isolate, ast_value_factory);
     }
-    if (innermost_scope == NULL) innermost_scope = current_scope;
+    if (innermost_scope == nullptr) innermost_scope = current_scope;
     context = context->previous();
   }
 
   script_scope->AddInnerScope(current_scope);
   script_scope->PropagateScopeInfo(false);
   return (innermost_scope == NULL) ? script_scope : innermost_scope;
 }
 
 void Scope::DeserializeScopeInfo(Isolate* isolate,
                                  AstValueFactory* ast_value_factory) {
@@ skipping 1472 matching lines @@
       function != NULL && function->proxy()->var()->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8