Merge r7110 from bleeding_edge to the 3.1 branch.

src/scopes.h

 // Copyright 2010 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 86 matching lines @@
 
   Scope(Scope* outer_scope, Type type);
 
   virtual ~Scope() { }
 
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
   // doesn't re-allocate variables repeatedly.
   static bool Analyze(CompilationInfo* info);
 
+  static Scope* DeserializeScopeChain(CompilationInfo* info,
+                                      Scope* innermost_scope);
+
   // The scope name is only used for printing/debugging.
   void SetScopeName(Handle<String> scope_name) { scope_name_ = scope_name; }
 
   virtual void Initialize(bool inside_with);
 
   // Called just before leaving a scope.
   virtual void Leave() {
     // No cleanup or fixup necessary.
   }
 
@@ skipping 189 matching lines @@
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  protected:
   friend class ParserFactory;
 
   explicit Scope(Type type);
 
-  void InsertAfterScope(Scope* scope) {
-    inner_scopes_.Add(scope);
-    outer_scope_ = scope->outer_scope_;
-    outer_scope_->inner_scopes_.RemoveElement(scope);
-    outer_scope_->inner_scopes_.Add(this);
-    scope->outer_scope_ = this;
-  }
-
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
 
   // The scope type.
   Type type_;
 
   // Debugging support.
   Handle<String> scope_name_;
 
@@ skipping 72 matching lines @@
   void AllocateStackSlot(Variable* var);
   void AllocateHeapSlot(Variable* var);
   void AllocateParameterLocals();
   void AllocateNonParameterLocal(Variable* var);
   void AllocateNonParameterLocals();
   void AllocateVariablesRecursively();
 
  private:
   Scope(Scope* inner_scope, SerializedScopeInfo* scope_info);
 
+  void AddInnerScope(Scope* inner_scope) {
+    if (inner_scope != NULL) {
+      inner_scopes_.Add(inner_scope);
+      inner_scope->outer_scope_ = this;
+    }
+  }
+
   void SetDefaults(Type type,
                    Scope* outer_scope,
                    SerializedScopeInfo* scope_info) {
     outer_scope_ = outer_scope;
     type_ = type;
     scope_name_ = Factory::empty_symbol();
     dynamics_ = NULL;
     receiver_ = NULL;
     function_ = NULL;
     arguments_ = NULL;
@@ skipping 59 matching lines @@
   int nesting_level_;
   // Nesting level of outermost scope that is contained in a with statement,
   // or kNotInsideWith if there are no with's around the current scope.
   int inside_with_level_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_