Collect AstNode type information

src/scopes.cc

-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2012 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
 //       with the distribution.
@@ skipping 255 matching lines @@
   Scope* scope = info->function()->scope();
   Scope* top = scope;
 
   // Traverse the scope tree up to the first unresolved scope or the global
   // scope and start scope resolution and variable allocation from that scope.
   while (!top->is_global_scope() &&
          !top->outer_scope()->already_resolved()) {
     top = top->outer_scope();
   }
 
-  // Allocated the variables.
-  top->AllocateVariables(info->global_scope());
+  // Allocate the variables.
+  {
+    AstNodeFactory ast_node_factory(info->isolate());
+    top->AllocateVariables(info->global_scope(), &ast_node_factory);
+  }
 
 #ifdef DEBUG
   if (info->isolate()->bootstrapper()->IsActive()
           ? FLAG_print_builtin_scopes
           : FLAG_print_scopes) {
     scope->Print();
   }
 #endif
 
   if (FLAG_harmony_scoping) {
@@ skipping 121 matching lines @@
                          name,
                          mode,
                          true,
                          Variable::NORMAL,
                          init_flag);
   var->AllocateTo(Variable::CONTEXT, index);
   return var;
 }
 
 
-Variable* Scope::LookupFunctionVar(Handle<String> name) {
+Variable* Scope::LookupFunctionVar(Handle<String> name,
+                                   AstNodeFactory* factory) {
   if (function_ != NULL && function_->name().is_identical_to(name)) {
     return function_->var();
   } else if (!scope_info_.is_null()) {
     // If we are backed by a scope info, try to lookup the variable there.
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*name, &mode);
     if (index < 0) return NULL;
-    Variable* var = DeclareFunctionVar(name, mode);
+    Variable* var = DeclareFunctionVar(name, mode, factory);
     var->AllocateTo(Variable::CONTEXT, index);
     return var;
   } else {
     return NULL;
   }
 }
 
 
 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;
   }
   return NULL;
 }
 
 
-Variable* Scope::DeclareFunctionVar(Handle<String> name, VariableMode mode) {
+Variable* Scope::DeclareFunctionVar(Handle<String> name,
+                                    VariableMode mode,
+                                    AstNodeFactory* factory) {
   ASSERT(is_function_scope() && function_ == NULL);
   Variable* function_var = new Variable(
       this, name, mode, true, Variable::NORMAL, kCreatedInitialized);
-  function_ = new(isolate_->zone()) VariableProxy(isolate_, function_var);
+  function_ = factory->NewVariableProxy(function_var);
   return function_var;
 }
 
 
 void Scope::DeclareParameter(Handle<String> name, VariableMode mode) {
   ASSERT(!already_resolved());
   ASSERT(is_function_scope());
   Variable* var = variables_.Declare(
       this, name, mode, true, Variable::NORMAL, kCreatedInitialized);
   params_.Add(var);
@@ skipping 21 matching lines @@
   ASSERT(is_global_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
                             true,
                             Variable::NORMAL,
                             kCreatedInitialized);
 }
 
 
-VariableProxy* Scope::NewUnresolved(Handle<String> name, int position) {
+VariableProxy* Scope::NewUnresolved(AstNodeFactory* factory,
+                                    Handle<String> name,
+                                    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(
-      isolate_, name, false, position);
+  VariableProxy* proxy = factory->NewVariableProxy(name, false, 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 107 matching lines @@
       if (var->IsStackLocal()) {
         stack_locals->Add(var);
       } else if (var->IsContextSlot()) {
         context_locals->Add(var);
       }
     }
   }
 }
 
 
-void Scope::AllocateVariables(Scope* global_scope) {
+void Scope::AllocateVariables(Scope* global_scope, AstNodeFactory* factory) {
   // 1) Propagate scope information.
   bool outer_scope_calls_non_strict_eval = false;
   if (outer_scope_ != NULL) {
     outer_scope_calls_non_strict_eval =
         outer_scope_->outer_scope_calls_non_strict_eval() |
         outer_scope_->calls_non_strict_eval();
   }
   PropagateScopeInfo(outer_scope_calls_non_strict_eval);
 
   // 2) Resolve variables.
-  ResolveVariablesRecursively(global_scope);
+  ResolveVariablesRecursively(global_scope, factory);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively();
 }
 
 
 bool Scope::AllowsLazyCompilation() const {
   return !force_eager_compilation_ && HasTrivialOuterContext();
 }
 
@@ skipping 242 matching lines @@
                        Variable::NORMAL,
                        init_flag);
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(Variable::LOOKUP, -1);
   }
   return var;
 }
 
 
 Variable* Scope::LookupRecursive(Handle<String> name,
-                                 BindingKind* binding_kind) {
+                                 BindingKind* binding_kind,
+                                 AstNodeFactory* factory) {
   ASSERT(binding_kind != NULL);
   // Try to find the variable in this scope.
   Variable* var = LocalLookup(name);
 
   // We found a variable and we are done. (Even if there is an 'eval' in
   // this scope which introduces the same variable again, the resulting
   // variable remains the same.)
   if (var != NULL) {
     *binding_kind = BOUND;
     return var;
   }
 
   // We did not find a variable locally. Check against the function variable,
   // if any. We can do this for all scopes, since the function variable is
   // only present - if at all - for function scopes.
   *binding_kind = UNBOUND;
-  var = LookupFunctionVar(name);
+  var = LookupFunctionVar(name, factory);
   if (var != NULL) {
     *binding_kind = BOUND;
   } else if (outer_scope_ != NULL) {
-    var = outer_scope_->LookupRecursive(name, binding_kind);
+    var = outer_scope_->LookupRecursive(name, binding_kind, factory);
     if (*binding_kind == BOUND && (is_function_scope() || is_with_scope())) {
       var->ForceContextAllocation();
     }
   } else {
     ASSERT(is_global_scope());
   }
 
   if (is_with_scope()) {
     // The current scope is a with scope, so the variable binding can not be
     // statically resolved. However, note that it was necessary to do a lookup
@@ skipping 12 matching lines @@
       *binding_kind = BOUND_EVAL_SHADOWED;
     } else if (*binding_kind == UNBOUND) {
       *binding_kind = UNBOUND_EVAL_SHADOWED;
     }
   }
   return var;
 }
 
 
 void Scope::ResolveVariable(Scope* global_scope,
-                            VariableProxy* proxy) {
+                            VariableProxy* proxy,
+                            AstNodeFactory* factory) {
   ASSERT(global_scope == NULL || global_scope->is_global_scope());
 
   // If the proxy is already resolved there's nothing to do
   // (functions and consts may be resolved by the parser).
   if (proxy->var() != NULL) return;
 
   // Otherwise, try to resolve the variable.
   BindingKind binding_kind;
-  Variable* var = LookupRecursive(proxy->name(), &binding_kind);
+  Variable* var = LookupRecursive(proxy->name(), &binding_kind, factory);
   switch (binding_kind) {
     case BOUND:
       // We found a variable binding.
       break;
 
     case BOUND_EVAL_SHADOWED:
       // We found a variable variable binding that might be shadowed
       // by 'eval' introduced variable bindings.
       if (var->is_global()) {
         var = NonLocal(proxy->name(), DYNAMIC_GLOBAL);
@@ skipping 20 matching lines @@
       // The variable could not be resolved statically.
       var = NonLocal(proxy->name(), DYNAMIC);
       break;
   }
 
   ASSERT(var != NULL);
   proxy->BindTo(var);
 }
 
 
-void Scope::ResolveVariablesRecursively(Scope* global_scope) {
+void Scope::ResolveVariablesRecursively(Scope* global_scope,
+                                        AstNodeFactory* factory) {
   ASSERT(global_scope == NULL || global_scope->is_global_scope());
 
   // Resolve unresolved variables for this scope.
   for (int i = 0; i < unresolved_.length(); i++) {
-    ResolveVariable(global_scope, unresolved_[i]);
+    ResolveVariable(global_scope, unresolved_[i], factory);
   }
 
   // Resolve unresolved variables for inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
-    inner_scopes_[i]->ResolveVariablesRecursively(global_scope);
+    inner_scopes_[i]->ResolveVariablesRecursively(global_scope, factory);
   }
 }
 
 
 bool Scope::PropagateScopeInfo(bool outer_scope_calls_non_strict_eval ) {
   if (outer_scope_calls_non_strict_eval) {
     outer_scope_calls_non_strict_eval_ = true;
   }
 
   bool calls_non_strict_eval =
@@ skipping 203 matching lines @@
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->var()->IsContextSlot() ? 1 : 0);
 }
 
 } }  // namespace v8::internal