Don't preallocate temps, params, decls space if we're ScopeInfo backed

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 109 matching lines @@
                                                           ModuleDescriptor(zone)
                                                     : NULL) {
   SetDefaults();
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
-      decls_(4, zone),
+      decls_(0, zone),
       scope_info_(scope_info),
       scope_type_(scope_type),
       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));
   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),
+      temps_(0, zone),
+      params_(0, 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),
@@ skipping 534 matching lines @@
       var->set_next_unresolved(nullptr);
       return true;
     }
     current = next;
   }
   return false;
 }
 
 
 Variable* Scope::NewTemporary(const AstRawString* name) {
-  DCHECK(!already_resolved());
   DeclarationScope* scope = GetClosureScope();
   Variable* var = new(zone()) Variable(scope,
                                        name,
                                        TEMPORARY,
                                        Variable::NORMAL,
                                        kCreatedInitialized);
   scope->AddTemporary(var);
   return var;
 }
 
 int DeclarationScope::RemoveTemporary(Variable* var) {
+  DCHECK(!already_resolved());
   DCHECK_NOT_NULL(var);
   // Temporaries are only placed in ClosureScopes.
   DCHECK_EQ(GetClosureScope(), this);
   DCHECK_EQ(var->scope()->GetClosureScope(), var->scope());
   // If the temporary is not here, return quickly.
   if (var->scope() != this) return -1;
   // Most likely (always?) any temporary variable we want to remove
   // was just added before, so we search backwards.
   for (int i = temps_.length(); i-- > 0;) {
     if (temps_[i] == var) {
       // Don't shrink temps_, as callers of this method expect
       // the returned indices to be unique per-scope.
       temps_[i] = nullptr;
       return i;
     }
   }
   return -1;
 }
 
 
 void Scope::AddDeclaration(Declaration* declaration) {
+  DCHECK(!already_resolved());
   decls_.Add(declaration, zone());
 }
 
 
 Declaration* Scope::CheckConflictingVarDeclarations() {
   int length = decls_.length();
   for (int i = 0; i < length; i++) {
     Declaration* decl = decls_[i];
     // We don't create a separate scope to hold the function name of a function
     // expression, so we have to make sure not to consider it when checking for
@@ skipping 1031 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