Implement strict mode arguments caller/callee.

test/mjsunit/strict-mode.js

 // Copyright 2011 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 960 matching lines @@
     a = "c";
     b = "d";
     return [a, b, arguments[0], arguments[1]];
   }
 
   assertEquals(["c", "d", "a", "b"], strict("a", "b"));
   assertEquals(["c", "d", "c", "d"], nonstrict("a", "b"));
 })();
 
 
-(function TestStrictFunctionPills() {
-  function strict() {
-    "use strict";
-  }
-  assertThrows(function() { strict.caller; }, TypeError);
-  assertThrows(function() { strict.arguments; }, TypeError);
-
-  var another = new Function("'use strict'");
-  assertThrows(function() { another.caller; }, TypeError);
-  assertThrows(function() { another.arguments; }, TypeError);
-
-  var third = (function() { "use strict"; return function() {}; })();
-  assertThrows(function() { third.caller; }, TypeError);
-  assertThrows(function() { third.arguments; }, TypeError);
+function CheckPillDescriptor(func, name) {
 
   function CheckPill(pill) {
     assertEquals("function", typeof pill);
     assertInstanceof(pill, Function);
     assertThrows(function() { pill.property = "value"; }, TypeError);
     assertThrows(pill, TypeError);
     assertEquals(pill.prototype, (function(){}).prototype);
     var d = Object.getOwnPropertyDescriptor(pill, "prototype");
     assertFalse(d.writable);
     assertFalse(d.configurable);
     assertFalse(d.enumerable);
   }
 
-  function CheckPillDescriptor(func, name) {
-    var descriptor = Object.getOwnPropertyDescriptor(func, name);
-    CheckPill(descriptor.get)
-    CheckPill(descriptor.set);
-    assertFalse(descriptor.enumerable);
-    assertFalse(descriptor.configurable);
+  var descriptor = Object.getOwnPropertyDescriptor(func, name);
+  CheckPill(descriptor.get)
+  CheckPill(descriptor.set);
+  assertFalse(descriptor.enumerable);
+  assertFalse(descriptor.configurable);
+}
+
+
+(function TestStrictFunctionPills() {
+  function strict() {
+    "use strict";
   }
+  assertThrows(function() { strict.caller; }, TypeError);
+  assertThrows(function() { strict.arguments; }, TypeError);
+
+  var another = new Function("'use strict'");
+  assertThrows(function() { another.caller; }, TypeError);
+  assertThrows(function() { another.arguments; }, TypeError);
+
+  var third = (function() { "use strict"; return function() {}; })();
+  assertThrows(function() { third.caller; }, TypeError);
+  assertThrows(function() { third.arguments; }, TypeError);
 
   CheckPillDescriptor(strict, "caller");
   CheckPillDescriptor(strict, "arguments");
   CheckPillDescriptor(another, "caller");
   CheckPillDescriptor(another, "arguments");
   CheckPillDescriptor(third, "caller");
   CheckPillDescriptor(third, "arguments");
 })();
+
+
+(function TestStrictArgumentPills() {
+  function strict() {
+    "use strict";
+    return arguments;
+  }
+
+  var args = strict();
+  CheckPillDescriptor(args, "caller");
+  CheckPillDescriptor(args, "callee");
+
+  args = strict(17, "value", strict);
+  assertEquals(17, args[0])
+  assertEquals("value", args[1])
+  assertEquals(strict, args[2]);
+  CheckPillDescriptor(args, "caller");
+  CheckPillDescriptor(args, "callee");
+
+  function outer() {
+    "use strict";
+    function inner() {
+      return arguments;
+    }
+    return inner;
+  }
+
+  var args = outer()();
+  CheckPillDescriptor(args, "caller");
+  CheckPillDescriptor(args, "callee");
+
+  args = outer()(17, "value", strict);
+  assertEquals(17, args[0])
+  assertEquals("value", args[1])
+  assertEquals(strict, args[2]);
+  CheckPillDescriptor(args, "caller");
+  CheckPillDescriptor(args, "callee");

[Lasse Reichstein, 2011/03/15 09:58:40]

How about a strict function calling a non-strict function that returns
arguments? This should still poison caller (but not callee according to 10.6,
[[Get]], step 3.b).
I think that might not be implemented yet, correct?

[Martin Maly, 2011/03/16 01:21:24]

Correct. That part is not yet implemented.

+})();