[es6] do not add caller/arguments to ES6 function definitions

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 992 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 CheckPillDescriptor(func, name) {
+function CheckFunctionPillDescriptor(func, name) {
 
   function CheckPill(pill) {
     assertEquals("function", typeof pill);
+    assertInstanceof(pill, Function);
+    pill.property = "value";
+    assertEquals(pill.value, undefined);
+    assertThrows(function() { 'use strict'; 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);
+  }
+
+  // Poisoned accessors are no longer own properties
+  func = Object.getPrototypeOf(func);
+  var descriptor = Object.getOwnPropertyDescriptor(func, name);
+  CheckPill(descriptor.get)
+  CheckPill(descriptor.set);
+  assertFalse(descriptor.enumerable);
+  // In ES6, restricted function properties are configurable
+  assertTrue(descriptor.configurable);
+}
+
+
+function CheckArgumentsPillDescriptor(func, name) {
+
+  function CheckPill(pill) {
+    assertEquals("function", typeof pill);
     assertInstanceof(pill, Function);
     pill.property = "value";
     assertEquals(pill.value, undefined);
     assertThrows(function() { 'use strict'; pill.property = "value"; },
                  TypeError);
     assertThrows(pill, TypeError);
     assertEquals(pill.prototype, (function(){}).prototype);
     var d = Object.getOwnPropertyDescriptor(pill, "prototype");
     assertFalse(d.writable);
     assertFalse(d.configurable);
@@ skipping 22 matching lines @@
   assertThrows(function() { another.arguments; }, TypeError);
   assertThrows(function() { another.caller = 42; }, TypeError);
   assertThrows(function() { another.arguments = 42; }, TypeError);
 
   var third = (function() { "use strict"; return function() {}; })();
   assertThrows(function() { third.caller; }, TypeError);
   assertThrows(function() { third.arguments; }, TypeError);
   assertThrows(function() { third.caller = 42; }, TypeError);
   assertThrows(function() { third.arguments = 42; }, TypeError);
 
-  CheckPillDescriptor(strict, "caller");
-  CheckPillDescriptor(strict, "arguments");
-  CheckPillDescriptor(another, "caller");
-  CheckPillDescriptor(another, "arguments");
-  CheckPillDescriptor(third, "caller");
-  CheckPillDescriptor(third, "arguments");
+  CheckFunctionPillDescriptor(strict, "caller");
+  CheckFunctionPillDescriptor(strict, "arguments");
+  CheckFunctionPillDescriptor(another, "caller");
+  CheckFunctionPillDescriptor(another, "arguments");
+  CheckFunctionPillDescriptor(third, "caller");
+  CheckFunctionPillDescriptor(third, "arguments");
 })();
 
 
 (function TestStrictFunctionWritablePrototype() {
   "use strict";
   function TheClass() {
   }
   assertThrows(function() { TheClass.caller; }, TypeError);
   assertThrows(function() { TheClass.arguments; }, TypeError);
 
@@ skipping 11 matching lines @@
 })();
 
 
 (function TestStrictArgumentPills() {
   function strict() {
     "use strict";
     return arguments;
   }
 
   var args = strict();
-  CheckPillDescriptor(args, "caller");
-  CheckPillDescriptor(args, "callee");
+  CheckArgumentsPillDescriptor(args, "caller");
+  CheckArgumentsPillDescriptor(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");
+  CheckArgumentsPillDescriptor(args, "caller");
+  CheckArgumentsPillDescriptor(args, "callee");
 
   function outer() {
     "use strict";
     function inner() {
       return arguments;
     }
     return inner;
   }
 
   var args = outer()();
-  CheckPillDescriptor(args, "caller");
-  CheckPillDescriptor(args, "callee");
+  CheckArgumentsPillDescriptor(args, "caller");
+  CheckArgumentsPillDescriptor(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");
+  CheckArgumentsPillDescriptor(args, "caller");
+  CheckArgumentsPillDescriptor(args, "callee");
 })();
 
 
 (function TestNonStrictFunctionCallerPillSimple() {
   function return_my_caller() {
     return return_my_caller.caller;
   }
 
   function strict() {
     "use strict";
@@ skipping 64 matching lines @@
     assertSame(null, test(i));
   }
 })();
 
 
 (function TestStrictModeEval() {
   "use strict";
   eval("var eval_local = 10;");
   assertThrows(function() { return eval_local; }, ReferenceError);
 })();