Change implementation of eval to make an exact distinction between direct eva...

src/scopes.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 70 matching lines @@
   // The scope name is only used for printing/debugging.
   void SetScopeName(Handle<String> scope_name)  { scope_name_ = scope_name; }
 
   void Initialize(bool inside_with);
 
 
   // ---------------------------------------------------------------------------
   // Declarations
 
   // Lookup a variable in this scope. Returns the variable or NULL if not found.
+  virtual Variable* LookupLocal(Handle<String> name);
+
+  // Lookup a variable in this scope or outer scopes.
+  // Returns the variable or NULL if not found.
   virtual Variable* Lookup(Handle<String> name);
 
   // Declare the function variable for a function literal. This variable
   // is in an intermediate scope between this function scope and the the
   // outer scope. Only possible for function scopes; at most one variable.
   Variable* DeclareFunctionVar(Handle<String> name);
 
   // Declare a variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
   virtual Variable* Declare(Handle<String> name, Variable::Mode mode);
@@ skipping 30 matching lines @@
   // Illegal redeclaration support.
 
   // Set an expression node that will be executed when the scope is
   // entered. We only keep track of one illegal redeclaration node per
   // scope - the first one - so if you try to set it multiple times
   // the additional requests will be silently ignored.
   void SetIllegalRedeclaration(Expression* expression);
 
   // Visit the illegal redeclaration expression. Do not call if the
   // scope doesn't have an illegal redeclaration node.
-  void VisitIllegalRedeclaration(Visitor* visitor);
+  void VisitIllegalRedeclaration(AstVisitor* visitor);
 
   // Check if the scope has (at least) one illegal redeclaration.
   bool HasIllegalRedeclaration() const { return illegal_redecl_ != NULL; }
 
 
   // ---------------------------------------------------------------------------
   // Scope-specific info.
 
   // Inform the scope that the corresponding code contains a with statement.
   void RecordWithStatement()  { scope_contains_with_ = true; }
@@ skipping 185 matching lines @@
   virtual VariableProxy* NewUnresolved(Handle<String> name, bool inside_with) {
     return NULL;
   }
   virtual VariableProxy* NewTemporary(Handle<String> name)  { return NULL; }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_