Revert eval changes since there is a crash that I don't have the time...

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)
-
-    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
+    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
   };
 
   // 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_