[es6] Partially implement Reflect.getPrototypeOf.

Proxies are not properly supported yet.

R=rossberg
BUG=v8:3931
LOG=n

Review URL: https://codereview.chromium.org/1416433003

Cr-Commit-Position: refs/heads/master@{#31447}

src/bootstrapper.cc

@@ -2194,6 +2194,8 @@ void Genesis::InitializeGlobal_harmony_reflect() {
                         Builtins::kReflectDeleteProperty, 2, true);
   SimpleInstallFunction(reflect, "get",
                         Builtins::kReflectGet, 3, false);
+  SimpleInstallFunction(reflect, "getPrototypeOf",
+                        Builtins::kReflectGetPrototypeOf, 1, true);
   SimpleInstallFunction(reflect, "has",
                         Builtins::kReflectHas, 2, true);
   SimpleInstallFunction(reflect, "isExtensible",

src/builtins.cc

@@ -1499,6 +1499,23 @@ BUILTIN(ReflectGet) {
 }
 
 
+// ES6 section 26.1.8 Reflect.getPrototypeOf
+BUILTIN(ReflectGetPrototypeOf) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(2, args.length());
+  Handle<Object> target = args.at<Object>(1);
+
+  if (!target->IsJSReceiver()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
+                              isolate->factory()->NewStringFromAsciiChecked(
+                                  "Reflect.getPrototypeOf")));
+  }
+
+  return *Object::GetPrototype(isolate, target);
+}
+
+
 // ES6 section 26.1.9 Reflect.has
 BUILTIN(ReflectHas) {
   HandleScope scope(isolate);

src/builtins.h

@@ -61,6 +61,7 @@ enum BuiltinExtraArguments {
                                                              \
   V(ReflectDeleteProperty, NO_EXTRA_ARGUMENTS)               \
   V(ReflectGet, NO_EXTRA_ARGUMENTS)                          \
+  V(ReflectGetPrototypeOf, NO_EXTRA_ARGUMENTS)               \
   V(ReflectHas, NO_EXTRA_ARGUMENTS)                          \
   V(ReflectIsExtensible, NO_EXTRA_ARGUMENTS)                 \
   V(ReflectPreventExtensions, NO_EXTRA_ARGUMENTS)            \

test/mjsunit/harmony/reflect-get-prototype-of.js

+// Copyright 2010-2015 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
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Tests the Reflect.getPrototypeOf - ES6 26.1.8.
+// This is adapted from mjsunit/get-prototype-of.js.
+
+// Flags: --harmony-reflect
+
+
+
+function assertPrototypeOf(func, expected) {
+  assertEquals(expected, Reflect.getPrototypeOf(func));
+}
+
+
+assertThrows(function() {
+  Reflect.getPrototypeOf(undefined);
+}, TypeError);
+
+
+assertThrows(function() {
+  Reflect.getPrototypeOf(null);
+}, TypeError);
+
+
+function F(){};
+var y = new F();
+
+assertPrototypeOf(y, F.prototype);
+assertPrototypeOf(F, Function.prototype);
+
+assertPrototypeOf({x: 5}, Object.prototype);
+assertPrototypeOf({x: 5, __proto__: null}, null);
+
+assertPrototypeOf([1, 2], Array.prototype);
+
+
+assertThrows(function () {
+  Reflect.getPrototypeOf(1);
+}, TypeError);
+assertThrows(function () {
+  Reflect.getPrototypeOf(true);
+}, TypeError);
+assertThrows(function () {
+  Reflect.getPrototypeOf(false);
+}, TypeError);
+assertThrows(function () {
+  Reflect.getPrototypeOf('str');
+}, TypeError);
+assertThrows(function () {
+  Reflect.getPrototypeOf(Symbol());
+}, TypeError);
+
+assertPrototypeOf(Object(1), Number.prototype);
+assertPrototypeOf(Object(true), Boolean.prototype);
+assertPrototypeOf(Object(false), Boolean.prototype);
+assertPrototypeOf(Object('str'), String.prototype);
+assertPrototypeOf(Object(Symbol()), Symbol.prototype);
+
+
+var errorFunctions = [
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError,
+];
+
+for (var f of errorFunctions) {
+  assertPrototypeOf(f, Error);
+  assertPrototypeOf(new f(), f.prototype);
+}
+
+
+// Builtin constructors.
+var functions = [
+  Array,
+  ArrayBuffer,
+  Boolean,
+  // DataView,
+  Date,
+  Error,
+  Float32Array,
+  Float64Array,
+  Function,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Map,
+  Number,
+  Object,
+  // Promise,
+  RegExp,
+  Set,
+  String,
+  // Symbol, not constructible
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  WeakMap,
+  WeakSet,
+];
+
+for (var f of functions) {
+  assertPrototypeOf(f, Function.prototype);
+  assertPrototypeOf(new f(), f.prototype);
+}
+
+var p = new Promise(function() {});
+assertPrototypeOf(p, Promise.prototype);
+
+var dv = new DataView(new ArrayBuffer());
+assertPrototypeOf(dv, DataView.prototype);

test/mjsunit/harmony/reflect.js

@@ -230,6 +230,26 @@ function prepare(tgt) {
 
 
 
+////////////////////////////////////////////////////////////////////////////////
+// Reflect.getPrototypeOf
+
+
+(function testReflectGetPrototypeOfArity() {
+  assertEquals(1, Reflect.getPrototypeOf.length);
+})();
+
+
+(function testReflectDeletePropertyOnNonObject() {
+  assertThrows(function() { Reflect.getPrototypeOf(); }, TypeError);
+  assertThrows(function() { Reflect.getPrototypeOf(42); }, TypeError);
+  assertThrows(function() { Reflect.getPrototypeOf(null); }, TypeError);
+})();
+
+
+// See reflect-get-prototype-of.js for further tests.
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.isExtensible