Inline Scope::Initialize into the only constructor that's always called right before

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 "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 80 matching lines @@
       variables_(zone),
       temps_(4, zone),
       params_(4, zone),
       decls_(4, zone),
       module_descriptor_(scope_type == MODULE_SCOPE ? new (zone)
                                                           ModuleDescriptor(zone)
                                                     : NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(false) {
   SetDefaults();
-  if (outer_scope != nullptr) {
+  if (outer_scope == nullptr) {
+    // If the outer scope is null, this cannot be a with scope. The outermost
+    // scope must be a script scope.
+    DCHECK_EQ(SCRIPT_SCOPE, scope_type);
+  } else {
     asm_function_ = outer_scope_->asm_module_;
     // Inherit the language mode from the parent scope unless we're a module
     // scope.
     if (!is_module_scope()) language_mode_ = outer_scope->language_mode_;
     force_context_allocation_ =
         !is_function_scope() && outer_scope->has_forced_context_allocation();
+    outer_scope_->inner_scopes_.Add(this, zone);
+    scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   }
-
-  // The outermost scope must be a script scope.
-  DCHECK(scope_type == SCRIPT_SCOPE || outer_scope != nullptr);
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : outer_scope_(nullptr),
       inner_scopes_(4, zone),
       scope_type_(scope_type),
       function_kind_(scope_info.is_null() ? kNormalFunction
                                           : scope_info->function_kind()),
       variables_(zone),
@@ skipping 155 matching lines @@
                                : FLAG_print_scopes) {
     scope->Print();
   }
   scope->CheckScopePositions();
 #endif
 
   info->set_scope(scope);
   return true;
 }
 
-
-void Scope::Initialize() {
-  DCHECK(!already_resolved());
-  if (outer_scope_ == nullptr) {
-    scope_inside_with_ = is_with_scope();
-  } else {
-    outer_scope_->inner_scopes_.Add(this, zone());
-    scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
-  }
-}
-
 void Scope::DeclareThis(AstValueFactory* ast_value_factory) {
   DCHECK(!already_resolved());
   DCHECK(is_declaration_scope());
   DCHECK(has_this_declaration());
 
   bool subclass_constructor = IsSubclassConstructor(function_kind_);
   Variable* var = variables_.Declare(
       this, ast_value_factory->this_string(),
       subclass_constructor ? CONST : VAR, Variable::THIS,
       subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
@@ skipping 1237 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