Not sure what happened, but my revert did not get everything out. Fixing the...

src/variables.h

 // Copyright 2006-2008 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 95 matching lines @@
 // The AST refers to variables via VariableProxies - placeholders for the actual
 // variables. Variables themselves are never directly referred to from the AST,
 // they are maintained by scopes, and referred to from VariableProxies and Slots
 // after binding and variable allocation.
 
 class Variable: public ZoneObject {
  public:
   enum Mode {
     // User declared variables:
     VAR,       // declared via 'var', and 'function' declarations
+
     CONST,     // declared via 'const' declarations
 
     // Variables introduced by the compiler:
-    DYNAMIC,   // always require dynamic lookup (we don't know the declaration)
-    INTERNAL,  // like VAR, but not user-visible (may or may not be in a
-               // context)
-    TEMPORARY  // temporary variables (not user-visible), never in a context
+    DYNAMIC,         // always require dynamic lookup (we don't know
+                     // the declaration)
+
+    DYNAMIC_GLOBAL,  // requires dynamic lookup, but we know that the
+                     // variable is global unless it has been shadowed
+                     // by an eval-introduced variable
+
+    DYNAMIC_LOCAL,   // requires dynamic lookup, but we know that the
+                     // variable is local and where it is unless it
+                     // has been shadowed by an eval-introduced
+                     // variable
+
+    INTERNAL,        // like VAR, but not user-visible (may or may not
+                     // be in a context)
+
+    TEMPORARY        // temporary variables (not user-visible), never
+                     // in a context
   };
 
   // Printing support
   static const char* Mode2String(Mode mode);
 
   // Type testing & conversion
   Property* AsProperty();
   Variable* AsVariable();
   bool IsValidLeftHandSide() { return is_valid_LHS_; }
 
@@ skipping 10 matching lines @@
   bool is_accessed_from_inner_scope() const  {
     return is_accessed_from_inner_scope_;
   }
   UseCount* var_uses()  { return &var_uses_; }
   UseCount* obj_uses()  { return &obj_uses_; }
 
   bool IsVariable(Handle<String> n) {
     return !is_this() && name().is_identical_to(n);
   }
 
+  bool is_dynamic() const {
+    return (mode_ == DYNAMIC ||
+            mode_ == DYNAMIC_GLOBAL ||
+            mode_ == DYNAMIC_LOCAL);
+  }
+
   bool is_global() const;
   bool is_this() const { return is_this_; }
 
+  Variable* local_if_not_shadowed() const {
+    ASSERT(mode_ == DYNAMIC_LOCAL && local_if_not_shadowed_ != NULL);
+    return local_if_not_shadowed_;
+  }
+
+  void set_local_if_not_shadowed(Variable* local) {
+    local_if_not_shadowed_ = local;
+  }
+
   Expression* rewrite() const  { return rewrite_; }
   Slot* slot() const;
 
   StaticType* type() { return &type_; }
 
  private:
   Variable(Scope* scope, Handle<String> name, Mode mode, bool is_valid_LHS,
       bool is_this);
 
   Scope* scope_;
   Handle<String> name_;
   Mode mode_;
   bool is_valid_LHS_;
   bool is_this_;
 
+  Variable* local_if_not_shadowed_;
+
   // Usage info.
   bool is_accessed_from_inner_scope_;  // set by variable resolver
   UseCount var_uses_;  // uses of the variable value
   UseCount obj_uses_;  // uses of the object the variable points to
 
   // Static type information
   StaticType type_;
 
   // Code generation.
   // rewrite_ is usually a Slot or a Property, but maybe any expression.
   Expression* rewrite_;
 
   friend class VariableProxy;
   friend class Scope;
   friend class LocalsMap;
   friend class AstBuildingParser;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VARIABLES_H_