Replace CollectVariables with locals(), update callsites to walk locals instead

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 214 matching lines @@
 #endif
   inner_scope_ = nullptr;
   sibling_ = nullptr;
   unresolved_ = nullptr;
 
   start_position_ = kNoSourcePosition;
   end_position_ = kNoSourcePosition;
 
   num_stack_slots_ = 0;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
-  num_global_slots_ = 0;
 
   set_language_mode(SLOPPY);
 
   scope_calls_eval_ = false;
   scope_nonlinear_ = false;
   is_hidden_ = false;
   is_debug_evaluate_scope_ = false;
 
   inner_scope_calls_eval_ = false;
   force_context_allocation_ = false;
@@ skipping 87 matching lines @@
   script_scope->PropagateScopeInfo();
   return innermost_scope;
 }
 
 void Scope::DeserializeScopeInfo(Isolate* isolate,
                                  AstValueFactory* ast_value_factory) {
   if (scope_info_.is_null()) return;
 
   DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
 
-  // Internalize context local & globals variables.
-  for (int var = 0; var < scope_info_->ContextLocalCount() +
-                              scope_info_->ContextGlobalCount();
-       ++var) {
+  // Internalize context local variables.
+  for (int var = 0; var < scope_info_->ContextLocalCount(); ++var) {
     Handle<String> name_handle(scope_info_->ContextLocalName(var), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
     int index = Context::MIN_CONTEXT_SLOTS + var;
     VariableMode mode = scope_info_->ContextLocalMode(var);
     InitializationFlag init_flag = scope_info_->ContextLocalInitFlag(var);
     MaybeAssignedFlag maybe_assigned_flag =
         scope_info_->ContextLocalMaybeAssignedFlag(var);
-    VariableLocation location = var < scope_info_->ContextLocalCount()
-                                    ? VariableLocation::CONTEXT
-                                    : VariableLocation::GLOBAL;
+    VariableLocation location = VariableLocation::CONTEXT;
     Variable::Kind kind = Variable::NORMAL;
     if (index == scope_info_->ReceiverContextSlotIndex()) {
       kind = Variable::THIS;
     }
 
     Variable* result = variables_.Declare(zone(), this, name, mode, kind,
                                           init_flag, maybe_assigned_flag);
     result->AllocateTo(location, index);
   }
 
@@ skipping 229 matching lines @@
   // There should be no local slot with the given name.
   DCHECK_LT(scope_info_->StackSlotIndex(*name_handle), 0);
 
   VariableMode mode;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
 
   VariableLocation location = VariableLocation::CONTEXT;
   int index = ScopeInfo::ContextSlotIndex(scope_info_, name_handle, &mode,
                                           &init_flag, &maybe_assigned_flag);
-  if (index < 0) {
-    location = VariableLocation::GLOBAL;
-    index = ScopeInfo::ContextGlobalSlotIndex(scope_info_, name_handle, &mode,
-                                              &init_flag, &maybe_assigned_flag);
-    DCHECK(index < 0 || (is_script_scope() && mode == VAR));
-  }
   if (index < 0 && scope_type() == MODULE_SCOPE) {
     location = VariableLocation::MODULE;
     index = -1;  // TODO(neis): Find module variables in scope info.
   }
   if (index < 0) return nullptr;  // Nowhere found.
 
   Variable::Kind kind = Variable::NORMAL;
   if (location == VariableLocation::CONTEXT &&
       index == scope_info_->ReceiverContextSlotIndex()) {
     kind = Variable::THIS;
@@ skipping 161 matching lines @@
         if (decls_[j]->proxy()->raw_name() == name) {
           return decls_[j];
         }
       }
       DCHECK(false);
     }
   }
   return nullptr;
 }
 
-void Scope::CollectVariables(ZoneList<Variable*>* stack_locals,
-                             ZoneList<Variable*>* context_locals,
-                             ZoneList<Variable*>* context_globals) {
-  // TODO(verwaest): Just pass out locals_ directly and walk it?
-  DCHECK_NOT_NULL(stack_locals);
-  DCHECK_NOT_NULL(context_locals);
-  DCHECK_NOT_NULL(context_globals);
-
-  for (int i = 0; i < locals_.length(); i++) {
-    Variable* var = locals_[i];
-    if (var->IsStackLocal()) {
-      stack_locals->Add(var, zone());
-    } else if (var->IsContextSlot()) {
-      context_locals->Add(var, zone());
-    } else if (var->IsGlobalSlot()) {
-      context_globals->Add(var, zone());
-    }
-  }
-}
-
 void DeclarationScope::AllocateVariables(ParseInfo* info) {
   // 1) Propagate scope information.
   PropagateScopeInfo();
 
   // 2) Resolve variables.
   ResolveVariablesRecursively(info);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively();
 }
@@ skipping 286 matching lines @@
   if (is_declaration_scope() && AsDeclarationScope()->uses_super_property()) {
     Indent(n1, "// scope uses 'super' property\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (num_stack_slots_ > 0) {
     Indent(n1, "// ");
     PrintF("%d stack slots\n", num_stack_slots_);
   }
   if (num_heap_slots_ > 0) {
     Indent(n1, "// ");
-    PrintF("%d heap slots (including %d global slots)\n", num_heap_slots_,
-           num_global_slots_);
+    PrintF("%d heap slots\n", num_heap_slots_);
   }
 
   // Print locals.
   if (function != nullptr) {
     Indent(n1, "// function var:\n");
     PrintVar(n1, function);
   }
 
   if (variables_.Start() != NULL) {
     Indent(n1, "// local vars:\n");
@@ skipping 330 matching lines @@
       DCHECK(var->IsUnallocated() || var->IsContextSlot());
       if (var->IsUnallocated()) {
         AllocateHeapSlot(var);
       }
     } else {
       DCHECK(var->IsUnallocated() || var->IsParameter());
       if (var->IsUnallocated()) {
         var->AllocateTo(VariableLocation::PARAMETER, index);
       }
     }
-  } else {
-    DCHECK(!var->IsGlobalSlot());
   }
 }
 
 void DeclarationScope::AllocateReceiver() {
   if (!has_this_declaration()) return;
   DCHECK_NOT_NULL(receiver());
   DCHECK_EQ(receiver()->scope(), this);
   AllocateParameter(receiver(), -1);
 }
 
 void Scope::AllocateNonParameterLocal(Variable* var) {
   DCHECK(var->scope() == this);
   if (var->IsUnallocated() && MustAllocate(var)) {
     if (MustAllocateInContext(var)) {
       AllocateHeapSlot(var);
     } else {
       AllocateStackSlot(var);
     }
   }
 }
 
-void Scope::AllocateDeclaredGlobal(Variable* var) {
-  DCHECK(var->scope() == this);
-  if (var->IsUnallocated()) {
-    if (var->IsStaticGlobalObjectProperty()) {
-      DCHECK_EQ(-1, var->index());
-      DCHECK(var->name()->IsString());
-      var->AllocateTo(VariableLocation::GLOBAL, num_heap_slots_++);
-      num_global_slots_++;
-    } else {
-      // There must be only DYNAMIC_GLOBAL in the script scope.
-      DCHECK(!is_script_scope() || DYNAMIC_GLOBAL == var->mode());
-    }
-  }
-}
-
 void Scope::AllocateNonParameterLocalsAndDeclaredGlobals() {
   for (int i = 0; i < locals_.length(); i++) {
     AllocateNonParameterLocal(locals_[i]);
   }
 
-  if (FLAG_global_var_shortcuts) {
-    for (int i = 0; i < locals_.length(); i++) {
-      AllocateDeclaredGlobal(locals_[i]);
-    }
-  }
-
   if (is_declaration_scope()) {
     AsDeclarationScope()->AllocateLocals();
   }
 }
 
 void DeclarationScope::AllocateLocals() {
   // For now, function_ must be allocated at the very end.  If it gets
   // allocated in the context, it must be the last slot in the context,
   // because of the current ScopeInfo implementation (see
   // ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
@@ skipping 77 matching lines @@
          (function != nullptr && function->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
-  return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
+  return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
-
-int Scope::ContextGlobalCount() const { return num_global_slots(); }
-
 }  // namespace internal
 }  // namespace v8