Remove the 'caller' property from the strict-mode arguments map

test/mjsunit/es6/classes.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --allow-natives-syntax --harmony-do-expressions
 
 (function TestBasics() {
   var C = class C {}
   assertEquals(typeof C, 'function');
   assertEquals(C.__proto__, Function.prototype);
@@ skipping 146 matching lines @@
   class C {}
 
   with ({a: 1}) {
     assertEquals(1, a);
   }
 
   assertThrows('class C extends function B() { with ({}); return B; }() {}',
                SyntaxError);
 
   var D = class extends function() {
-    arguments.caller;

[adamk, 2016/10/31 18:05:36]

Seems reasonable to change this to test arguments.callee, since that still
throws. Or if you want to actually test for the absence of .caller, you could
add an assertThrows() for '() => e.arguments.callee'.

+    this.arguments = arguments;
   } {};
   assertThrows(function() {
     Object.getPrototypeOf(D).arguments;
   }, TypeError);
-  assertThrows(function() {
-    new D;
-  }, TypeError);
+  var e = new D();
+  assertEquals(undefined, Object.getOwnPropertyDescriptor(e.arguments, "caller"));

[adamk, 2016/10/31 18:05:36]

Nit: wrap to 80 columns.

+  assertEquals(undefined, e.arguments.caller);
+  assertEquals(true, Reflect.set(e.arguments, "caller", 0));

[adamk, 2016/10/31 18:05:36]

I don't understand the need for this test. You're already asserting above that
there's no own "caller" property. I don't think this or the below are
interesting here.

[caitp, 2016/10/31 18:07:49]

I suggested adding this, because property access is complicated, and I'd like to
have many paths tested (even though this is still a small subset). Similar to
test262's tendency to do this.

[caitp, 2016/10/31 18:10:33]

specifically, this also checks that the property is also not installed on the
arguments object's prototype, and if it is, not in a configurable way. I suppose
`assertFalse('caller' in arguments)` would be okay too, though (but still fewer
paths taken)

[adamk, 2016/10/31 18:29:15]

I just don't think it makes sense to test property access semantics in a test
that's fundamentally about the absence of this property. I'm OK with
assertFalse('caller' in arguments), but anything more than that feels like we're
putting the test in the wrong place.

+  assertEquals(Object.getOwnPropertyDescriptor(e.arguments, "caller"), {
+    value: 0,
+    configurable: true,
+    enumerable: true,
+    writable: true
+  });
 })();
 
 
 (function TestToString() {
   class C {}
   assertEquals('class C {}', C.toString());
 
   class D { constructor() { 42; } }
   assertEquals('class D { constructor() { 42; } }', D.toString());
 
@@ skipping 854 matching lines @@
     function* foo() {
       class C extends (yield) {};
     }
     var g = foo();
     g.next();
     return g.return(42).value;
   }
   assertEquals(42, usingYieldInExtends());
 
 })();