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

test/cctest/test-api.cc

 // Copyright 2007-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 4000 matching lines @@
     "    if (str.indexOf('#<a Fun>') == -1) return 3;"
     "    return 0;"
     "  }"
     "  return 4;"
     "}"
     "test();");
   CHECK_EQ(0, value->Int32Value());
 }
 
 
 THREADED_TEST(Eval) {

[Mads Ager (chromium), 2008/11/21 12:41:23]

Could you rewrite as many as these tests as possible as mjsunit tests?  They are
easier to read and it seems to me that all of these tests except for one could
be mjsunit tests.

   v8::HandleScope scope;
   LocalContext current;
 
-  // Test that un-aliased eval uses local context.
+  // Test that un-aliased eval reads from local context.
   Local<Script> script =
       Script::Compile(v8_str("foo = 0;"
                              "(function() {"
                              "  var foo = 2;"
                              "  return eval('foo');"
                              "})();"));
   Local<Value> result = script->Run();
   CHECK_EQ(2, result->Int32Value());
 
+  // Test that un-aliased eval writes to local context.
+  script =
+      Script::Compile(v8_str("foo = 0;"
+                             "(function() {"
+                             "  var foo = 1;"
+                             "  eval('foo = 2;');"
+                             "  return foo;"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(0, current->Global()->Get(v8_str("foo"))->Int32Value());
+  CHECK(result->IsInt32());
+  CHECK_EQ(2, result->Int32Value());
+
   // Test that un-aliased eval has right this.
   script =
       Script::Compile(v8_str("function MyObject() { this.self = eval('this'); }"
                              "var o = new MyObject();"
                              "o === o.self"));
   result = script->Run();
   CHECK(result->IsTrue());
+
+  // Test that aliased eval reads from global context.
+  script =
+      Script::Compile(v8_str("var e = eval;"
+                             "foo = 0;"
+                             "(function() {"
+                             "  var foo = 2;"
+                             "  return e('foo');"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(0, result->Int32Value());
+
+  // Test that aliased eval writes to global context.
+  script =
+      Script::Compile(v8_str("var e = eval;"
+                             "foo = 0;"
+                             "(function() {"
+                             "  e('var foo = 2;');"
+                             "})();"
+                             "foo"));
+  result = script->Run();
+  CHECK_EQ(2, result->Int32Value());
+
+  // Test that aliased eval has right this.
+  script =
+      Script::Compile(v8_str("var e = eval;"
+                             "function MyObject() { this.self = e('this'); }"
+                             "var o = new MyObject();"
+                             "this === o.self"));
+  result = script->Run();
+  CHECK(result->IsTrue());
+
+  // Try to cheat the 'aliased eval' detection.
+  script =
+      Script::Compile(v8_str("var x = this;"
+                             "foo = 0;"
+                             "(function() {"
+                             "  var foo = 2;"
+                             "  return x.eval('foo');"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(0, result->Int32Value());
+
+  script =
+      Script::Compile(v8_str("var e = eval;"
+                             "foo = 0;"
+                             "(function() {"
+                             "  var eval = function(x) { return x; };"
+                             "  var foo = eval(2);"
+                             "  return e('foo');"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(0, result->Int32Value());
+
+  script =
+      Script::Compile(v8_str("(function() {"
+                             "  var eval = function(x) { return 2 * x; };"
+                             "  return (function() { return eval(2); })();"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(4, result->Int32Value());
+
+  script =
+      Script::Compile(v8_str("eval = function(x) { return 2 * x; };"
+                             "(function() {"
+                             "  return (function() { return eval(2); })();"
+                             "})();"));
+  result = script->Run();
+  CHECK_EQ(4, result->Int32Value());
+}
+
+
+THREADED_TEST(EvalAliasedDynamic) {
+  v8::HandleScope scope;
+  LocalContext current;
+
+  // This sets 'global' to the real global object (as opposed to the
+  // proxy). It is highly implementation dependent, so take care.
+  current->Global()->Set(v8_str("global"), current->Global()->GetPrototype());
+
+  // Tests where aliased eval can only be resolved dynamically.
+  Local<Script> script =
+      Script::Compile(v8_str("function f(x) { "
+                             "  var foo = 2;"
+                             "  with (x) { return eval('foo'); }"
+                             "}"
+                             "foo = 0;"
+                             "var result = f(new Object()) == 2;"
+                             "result = result && (f(global) == 0);"
+                             "var x = new Object();"
+                             "x.eval = function(x) { return 1; };"
+                             "result = result && (f(x) == 1);"
+                             "result"));
+  Local<Value> result = script->Run();
+  CHECK(result->IsTrue());
+
+  v8::TryCatch try_catch;
+  script =
+    Script::Compile(v8_str("function f(x) { "
+                           "  var bar = 2;"
+                           "  with (x) { return eval('bar'); }"
+                           "}"
+                           "f(global)"));
+  result = script->Run();
+  CHECK(try_catch.HasCaught());
+  try_catch.Reset();
+
+  script =
+    Script::Compile(v8_str("this.eval = function (x) { return x + x; };"
+                           "foo = 2;"
+                           "eval('foo')"));
+  result = script->Run();
+  CHECK(result->IsString());
+  CHECK_EQ(v8_str("foofoo"), result);
 }
 
 
 THREADED_TEST(CrossEval) {
   v8::HandleScope scope;
   LocalContext other;
   LocalContext current;
 
   Local<String> token = v8_str("<security token>");
   other->SetSecurityToken(token);
@@ skipping 1286 matching lines @@
     CompileRun("for (var j = 0; j < 10; j++) new RegExp('');");
   }
   // Test CallIC.
   for (int i = 0; i < 2; i++) {
     LocalContext context;
     context->Global()->Set(v8_str("tmp"), v8::True());
     context->Global()->Delete(v8_str("tmp"));
     CompileRun("for (var j = 0; j < 10; j++) RegExp('')");
   }
 }