[es6] Support optional "receiver" argument in Reflect.get.

test/mjsunit/harmony/reflect.js

 // Copyright 2015 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: --harmony-reflect
+// Flags: --harmony-reflect --harmony-sloppy-let
 
 // TODO(neis): Test with proxies.
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // (Auxiliaries)
 
 
-"use strict";

[rossberg, 2015/10/08 12:36:34]

Why drop this? The language mode shouldn't affect any Reflect-related test.

-
 var global = this;
 
 var sym = Symbol("gaga");
 
 var objects = [
   {},
   [],
   function() {},
   function() {
     return arguments;
@@ skipping 19 matching lines @@
   RegExp,
   global
 ];
 
 function prepare(tgt) {
   tgt["bla"] = true;
   tgt[4] = 42;
   tgt[sym] = "foo";
   tgt["noconf"] = 43;
   Object.defineProperty(tgt, "noconf", {configurable: false});
+  Object.defineProperty(tgt, "getter",
+    { get: function () {return this.bla}, configurable: true });
+  Object.defineProperty(tgt, "setter",
+    { set: function () {}, configurable: true });
 }
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.get
 
 
 (function testReflectGetArity() {
   assertEquals(3, Reflect.get.length);
@@ skipping 10 matching lines @@
 (function testReflectGetKeyConversion() {
   var tgt = {bla: 42};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertEquals(42, Reflect.get(tgt, a));
   assertThrows(function() { Reflect.get(tgt, b); }, "gaga");
 })();
 
 
 (function testReflectGetOnObject() {
+  var receiver = {bla: false};
   for (let tgt of objects) {
     prepare(tgt);
     assertEquals(true, Reflect.get(tgt, "bla"));
+    assertEquals(true, Reflect.get(tgt, "bla", tgt));
+    assertEquals(true, Reflect.get(tgt, "bla", receiver));
     assertEquals(42, Reflect.get(tgt, 4));
+    assertEquals(42, Reflect.get(tgt, 4, tgt));
+    assertEquals(42, Reflect.get(tgt, 4, receiver));
     assertEquals(42, Reflect.get(tgt, "4"));
+    assertEquals(42, Reflect.get(tgt, "4", tgt));
+    assertEquals(42, Reflect.get(tgt, "4", receiver));
     assertEquals("foo", Reflect.get(tgt, sym));
-    assertEquals(undefined, Reflect.get(tgt, "doesnotexist"));
+    assertEquals("foo", Reflect.get(tgt, sym, tgt));
+    assertEquals("foo", Reflect.get(tgt, sym, receiver));
+    assertEquals(43, Reflect.get(tgt, "noconf"));
+    assertEquals(43, Reflect.get(tgt, "noconf", tgt));
+    assertEquals(43, Reflect.get(tgt, "noconf", receiver));
+    assertEquals(true, Reflect.get(tgt, "getter"));
+    assertEquals(true, Reflect.get(tgt, "getter", tgt));
+    assertEquals(false, Reflect.get(tgt, "getter", receiver));
+    assertEquals(undefined, Reflect.get(tgt, "setter"));
+    assertEquals(undefined, Reflect.get(tgt, "setter", tgt));
+    assertEquals(undefined, Reflect.get(tgt, "setter", receiver));
+    assertEquals(undefined, Reflect.get(tgt, "foo"));
+    assertEquals(undefined, Reflect.get(tgt, "foo", tgt));
+    assertEquals(undefined, Reflect.get(tgt, "foo", receiver));
     assertEquals(undefined, Reflect.get(tgt, 666));
+    assertEquals(undefined, Reflect.get(tgt, 666, tgt));
+    assertEquals(undefined, Reflect.get(tgt, 666, receiver));
+
+    let proto = tgt.__proto__;
+    tgt.__proto__ = { get foo() {return this.bla} };
+    assertEquals(true, Reflect.get(tgt, "foo"));
+    assertEquals(true, Reflect.get(tgt, "foo", tgt));
+    assertEquals(false, Reflect.get(tgt, "foo", receiver));
+    tgt.__proto__ = proto;
   }
 })();
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.has
 
 
 (function testReflectHasArity() {
@@ skipping 17 matching lines @@
 })();
 
 
 (function testReflectHasOnObject() {
   for (let tgt of objects) {
     prepare(tgt);
     assertTrue(Reflect.has(tgt, "bla"));
     assertTrue(Reflect.has(tgt, 4));
     assertTrue(Reflect.has(tgt, "4"));
     assertTrue(Reflect.has(tgt, sym));
-    assertFalse(Reflect.has(tgt, "doesnotexist"));
+    assertTrue(Reflect.has(tgt, "noconf"));
+    assertTrue(Reflect.has(tgt, "getter"));
+    assertTrue(Reflect.has(tgt, "setter"));
+    assertFalse(Reflect.has(tgt, "foo"));
     assertFalse(Reflect.has(tgt, 666));
+
+    let proto = tgt.__proto__;
+    tgt.__proto__ = { get foo() {return this.bla} };
+    assertEquals(true, Reflect.has(tgt, "foo"));
+    tgt.__proto__ = proto;
   }
 })();
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.deleteProperty
 
 
 (function testReflectDeletePropertyArity() {
@@ skipping 23 matching lines @@
     assertTrue(Reflect.deleteProperty(tgt, "bla"));
     assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, "bla"));
     if (tgt instanceof Int32Array) {
       assertFalse(Reflect.deleteProperty(tgt, 4));
     } else {
       assertTrue(Reflect.deleteProperty(tgt, 4));
       assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, 4));
     }
     assertTrue(Reflect.deleteProperty(tgt, sym));
     assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, sym));
-    assertTrue(Reflect.deleteProperty(tgt, "doesnotexist"));
-    assertTrue(Reflect.deleteProperty(tgt, 666));
     assertFalse(Reflect.deleteProperty(tgt, "noconf"));
     assertEquals(43, tgt.noconf);
+    assertTrue(Reflect.deleteProperty(tgt, "getter"));
+    assertTrue(Reflect.deleteProperty(tgt, "setter"));
+    assertTrue(Reflect.deleteProperty(tgt, "foo"));
+    assertTrue(Reflect.deleteProperty(tgt, 666));
+
+    let proto = tgt.__proto__;
+    tgt.__proto__ = { get foo() {return this.bla} };
+    assertEquals(true, Reflect.deleteProperty(tgt, "foo"));
+    tgt.__proto__ = proto;
   }
 })();
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.isExtensible
 
 
 (function testReflectIsExtensibleArity() {
@@ skipping 11 matching lines @@
 (function testReflectIsExtensibleOnObject() {
   // This should be the last test as it modifies the objects irreversibly.
   for (let tgt of objects) {
     prepare(tgt);
     if (tgt instanceof Int32Array) continue;  // issue v8:4460
     assertTrue(Reflect.isExtensible(tgt));
     Object.preventExtensions(tgt);
     assertFalse(Reflect.isExtensible(tgt));
   }
 })();