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 145 matching lines @@
 (function TestStrictMode() {
   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;

[caitp, 2016/10/27 13:31:02]

I don't think we need to remove this line from the base function, the base class
is sloppy. Maybe something interesting would be to assign this value to a
property of `this`, so that you can assert what it is

-  } {};
+  var D = class extends function() {} {};
   assertThrows(function() {
     Object.getPrototypeOf(D).arguments;
   }, TypeError);
-  assertThrows(function() {
-    new D;

[caitp, 2016/10/27 13:31:02]

I don't think this should have ever thrown in the first place, since the
superclass' arguments object should have been sloppy arguments.

Lets change this assertion to be `assertEquals(D.prototype, (new
D()).__proto__)`, which I believe should be correct

[Henrique Ferreiro, 2016/10/28 09:56:05]

The commit message (d5d15253) says: "Classes: Expand test to cover strict
runtime behavior. This tests that the extends expression is treated as strict at
runtime and not just at parse time". This seems to match the standard: "Function
code is strict mode code if the associated FunctionDeclaration, [...] is
contained in strict mode code".

[caitp, 2016/10/28 13:00:02]

sure, but in this file, it occurs in sloppy mode. Otherwise the `with` statement
would be a SyntaxError.

This was apparently testimg that a class which extends a sloppy functionbwould
give that sloppy function a strict arguments object. this is incorrect.

-  }, TypeError);
 })();
 
 
 (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());
 
 })();