Pass isolate to AST ID functions.

src/scopes.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 286 matching lines @@
   if (is_catch_scope()) {
     ASSERT(outer_scope() != NULL);
     receiver_ = outer_scope()->receiver();
   } else {
     Variable* var =
         variables_.Declare(this,
                            isolate_->factory()->this_symbol(),
                            Variable::VAR,
                            false,
                            Variable::THIS);
-    var->set_rewrite(new(isolate_->zone()) Slot(var, Slot::PARAMETER, -1));
+    var->set_rewrite(new(isolate_->zone()) Slot(
+        isolate_, var, Slot::PARAMETER, -1));
     receiver_ = var;
   }
 
   if (is_function_scope()) {
     // Declare 'arguments' variable which exists in all functions.
     // Note that it might never be accessed, in which case it won't be
     // allocated during variable allocation.
     variables_.Declare(this,
                        isolate_->factory()->arguments_symbol(),
                        Variable::VAR,
@@ skipping 25 matching lines @@
     index = scope_info_->ParameterIndex(*name);
     if (index < 0) {
       // Check the function name.
       index = scope_info_->FunctionContextSlotIndex(*name);
       if (index < 0) return NULL;
     }
   }
 
   Variable* var =
       variables_.Declare(this, name, mode, true, Variable::NORMAL);
-  var->set_rewrite(new(isolate_->zone()) Slot(var, Slot::CONTEXT, index));
+  var->set_rewrite(
+      new(isolate_->zone()) Slot(isolate_, var, Slot::CONTEXT, index));
   return var;
 }
 
 
 Variable* Scope::Lookup(Handle<String> name) {
   for (Scope* scope = this;
        scope != NULL;
        scope = scope->outer_scope()) {
     Variable* var = scope->LocalLookup(name);
     if (var != NULL) return var;
@@ skipping 36 matching lines @@
 }
 
 
 VariableProxy* Scope::NewUnresolved(Handle<String> name,
                                     bool inside_with,
                                     int position) {
   // Note that we must not share the unresolved variables with
   // the same name because they may be removed selectively via
   // RemoveUnresolved().
   ASSERT(!already_resolved());
-  VariableProxy* proxy =
-      new(isolate_->zone()) VariableProxy(name, false, inside_with, position);
+  VariableProxy* proxy = new(isolate_->zone()) VariableProxy(
+      isolate_, name, false, inside_with, position);
   unresolved_.Add(proxy);
   return proxy;
 }
 
 
 void Scope::RemoveUnresolved(VariableProxy* var) {
   // Most likely (always?) any variable we want to remove
   // was just added before, so we search backwards.
   for (int i = unresolved_.length(); i-- > 0;) {
     if (unresolved_[i] == var) {
@@ skipping 279 matching lines @@
 
 
 Variable* Scope::NonLocal(Handle<String> name, Variable::Mode mode) {
   if (dynamics_ == NULL) dynamics_ = new DynamicScopePart();
   VariableMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
     var = map->Declare(NULL, name, mode, true, Variable::NORMAL);
     // Allocate it by giving it a dynamic lookup.
-    var->set_rewrite(new(isolate_->zone()) Slot(var, Slot::LOOKUP, -1));
+    var->set_rewrite(
+        new(isolate_->zone()) Slot(isolate_, var, Slot::LOOKUP, -1));
   }
   return var;
 }
 
 
 // Lookup a variable starting with this scope. The result is either
 // the statically resolved variable belonging to an outer scope, or
 // NULL. It may be NULL because a) we couldn't find a variable, or b)
 // because the variable is just a guess (and may be shadowed by
 // another variable that is introduced dynamically via an 'eval' call
@@ skipping 235 matching lines @@
     if (params_[i]->name().is_identical_to(
             isolate_->factory()->arguments_symbol())) {
       return true;
     }
   }
   return false;
 }
 
 
 void Scope::AllocateStackSlot(Variable* var) {
-  var->set_rewrite(
-      new(isolate_->zone()) Slot(var, Slot::LOCAL, num_stack_slots_++));
+  var->set_rewrite(new(isolate_->zone()) Slot(
+      isolate_, var, Slot::LOCAL, num_stack_slots_++));
 }
 
 
 void Scope::AllocateHeapSlot(Variable* var) {
-  var->set_rewrite(
-      new(isolate_->zone()) Slot(var, Slot::CONTEXT, num_heap_slots_++));
+  var->set_rewrite(new(isolate_->zone()) Slot(
+      isolate_, var, Slot::CONTEXT, num_heap_slots_++));
 }
 
 
 void Scope::AllocateParameterLocals() {
   ASSERT(is_function_scope());
   Variable* arguments = LocalLookup(isolate_->factory()->arguments_symbol());
   ASSERT(arguments != NULL);  // functions have 'arguments' declared implicitly
 
   bool uses_nonstrict_arguments = false;
 
@@ skipping 32 matching lines @@
 
     if (MustAllocate(var)) {
       if (MustAllocateInContext(var)) {
         ASSERT(var->rewrite() == NULL || var->IsContextSlot());
         if (var->rewrite() == NULL) {
           AllocateHeapSlot(var);
         }
       } else {
         ASSERT(var->rewrite() == NULL || var->IsParameter());
         if (var->rewrite() == NULL) {
-          var->set_rewrite(new(isolate_->zone()) Slot(var, Slot::PARAMETER, i));
+          var->set_rewrite(
+              new(isolate_->zone()) Slot(isolate_, var, Slot::PARAMETER, i));
         }
       }
     }
   }
 }
 
 
 void Scope::AllocateNonParameterLocal(Variable* var) {
   ASSERT(var->scope() == this);
   ASSERT(var->rewrite() == NULL ||
@@ skipping 67 matching lines @@
   if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS &&
       !must_have_local_context) {
     num_heap_slots_ = 0;
   }
 
   // Allocation done.
   ASSERT(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }
 
 } }  // namespace v8::internal