Fixing the detection of aliased eval so that it is exact....

src/parser.cc

 // 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 309 matching lines @@
   virtual Scope* NewScope(Scope* parent, Scope::Type type, bool inside_with);
 
   virtual Handle<String> LookupSymbol(const char* string, int length) {
     return Handle<String>();
   }
 
   virtual Handle<String> EmptySymbol() {
     return Handle<String>();
   }
 
+
+
   virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
     if (obj == VariableProxySentinel::this_proxy()) {
       return Property::this_property();
     } else {
       return ValidLeftHandSideSentinel::instance();
     }
   }
 
   virtual Expression* NewCall(Expression* expression,
                               ZoneList<Expression*>* arguments,
-                              bool is_eval, int pos) {
+                              Call::EvalType eval_type, int pos) {
     return Call::sentinel();
   }
 
   virtual Statement* EmptyStatement() {
     return NULL;
   }
 
   template <typename T> ZoneListWrapper<T> NewList(int size) {
     return is_pre_parsing_ ? ZoneListWrapper<T>() : ZoneListWrapper<T>(size);
   }
@@ skipping 29 matching lines @@
   virtual Handle<String> EmptySymbol() {
     return Factory::empty_symbol();
   }
 
   virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
     return new Property(obj, key, pos);
   }
 
   virtual Expression* NewCall(Expression* expression,
                               ZoneList<Expression*>* arguments,
-                              bool is_eval, int pos) {
-    return new Call(expression, arguments, is_eval, pos);
+                              Call::EvalType eval_type, int pos) {
+    return new Call(expression, arguments, eval_type, pos);
   }
 
   virtual Statement* EmptyStatement() {
     // Use a statically allocated empty statement singleton to avoid
     // allocating lots and lots of empty statements.
     static v8::internal::EmptyStatement empty;
     return &empty;
   }
 };
 
@@ skipping 1885 matching lines @@
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
         int pos = scanner().location().beg_pos;
         ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
 
         // Keep track of eval() calls since they disable all local variable
-        // optimizations. We can ignore locally declared variables with
-        // name 'eval' since they override the global 'eval' function. We
-        // only need to look at unresolved variables (VariableProxies).
+        // optimizations.
+        // The calls that need special treatment are the
+        // direct (i.e. not aliased) eval calls. These calls are all of the
+        // form eval(...) with no explicit receiver object where eval is not
+        // declared in the current scope chain. These calls are marked as
+        // potentially direct eval calls. Whether they are actually direct calls
+        // to eval is determined at run time.
 
+        Call::EvalType eval_type = Call::ALIASED;
         if (!is_pre_parsing_) {
-          // We assume that only a function called 'eval' can be used
-          // to invoke the global eval() implementation. This permits
-          // for massive optimizations.
           VariableProxy* callee = result->AsVariableProxy();
           if (callee != NULL && callee->IsVariable(Factory::eval_symbol())) {
-            // We do not allow direct calls to 'eval' in our internal
-            // JS files. Use builtin functions instead.
-            ASSERT(!Bootstrapper::IsActive());
-            top_scope_->RecordEvalCall();
-          } else {
-            // This is rather convoluted code to check if we're calling
-            // a function named 'eval' through a property access. If so,
-            // we mark it as a possible eval call (we don't know if the
-            // receiver will resolve to the global object or not), but
-            // we do not treat the call as an eval() call - we let the
-            // call get through to the JavaScript eval code defined in
-            // v8natives.js.
-            Property* property = result->AsProperty();
-            if (property != NULL) {
-              Literal* key = property->key()->AsLiteral();
-              if (key != NULL &&
-                  key->handle().is_identical_to(Factory::eval_symbol())) {
-                // We do not allow direct calls to 'eval' in our
-                // internal JS files. Use builtin functions instead.
-                ASSERT(!Bootstrapper::IsActive());
-                top_scope_->RecordEvalCall();
-              }
+            Handle<String> name = callee->name();
+            Variable* var = NULL;
+            for (Scope* scope = top_scope_;
+                 scope != NULL;
+                 scope = scope->outer_scope()) {
+              var = scope->Lookup(callee->name());
+              if (var != NULL) break;
+            }
+            if (var == NULL) {
+              // We do not allow direct calls to 'eval' in our internal
+              // JS files. Use builtin functions instead.
+              ASSERT(!Bootstrapper::IsActive());
+              top_scope_->RecordEvalCall();
+              eval_type = Call::POTENTIALLY_DIRECT;
             }
           }
         }
 
         // Optimize the eval() case w/o arguments so we
         // don't need to handle it every time at runtime.
         //
         // Note: For now we don't do static eval analysis
         // as it appears that we need to be able to call
         // eval() via alias names. We leave the code as
         // is, in case we want to enable this again in the
         // future.
         const bool is_eval = false;
         if (is_eval && args->length() == 0) {
           result = NEW(Literal(Factory::undefined_value()));
         } else {
-          result = factory()->NewCall(result, args, is_eval, pos);
+          result = factory()->NewCall(result, args, eval_type, pos);
         }
         break;
       }
 
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         int pos = scanner().location().beg_pos;
         Handle<String> name = ParseIdentifier(CHECK_OK);
         result = factory()->NewProperty(result, NEW(Literal(name)), pos);
         break;
@@ skipping 900 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal