From c87abd11176609fbbc16e6bbecad2ffe2893c813 Mon Sep 17 00:00:00 2001 From: "mstarzinger@chromium.org" Date: Fri, 2 Aug 2013 10:57:48 +0000 Subject: [PATCH] Add new Harmony methods to Array.prototype object. Array.prototype.find Array.prototype.findIndex http://people.mozilla.org/~jorendorff/es6-draft.html BUG=v8:2776,v8:2777 TEST=mjsunit/harmony/array-find,mjsunit/harmony/array-findindex R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/21079003 Patch from Ioseb Dzmanashvili . git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16025 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/bootstrapper.cc | 5 + src/flag-definitions.h | 2 + src/harmony-array.js | 124 ++++++++++++++ test/mjsunit/harmony/array-find.js | 280 ++++++++++++++++++++++++++++++++ test/mjsunit/harmony/array-findindex.js | 280 ++++++++++++++++++++++++++++++++ tools/gyp/v8.gyp | 3 +- 6 files changed, 693 insertions(+), 1 deletion(-) create mode 100644 src/harmony-array.js create mode 100644 test/mjsunit/harmony/array-find.js create mode 100644 test/mjsunit/harmony/array-findindex.js diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc index c2cc6ef..2a385aa 100644 --- a/src/bootstrapper.cc +++ b/src/bootstrapper.cc @@ -2085,6 +2085,11 @@ bool Genesis::InstallExperimentalNatives() { "native harmony-string.js") == 0) { if (!CompileExperimentalBuiltin(isolate(), i)) return false; } + if (FLAG_harmony_arrays && + strcmp(ExperimentalNatives::GetScriptName(i).start(), + "native harmony-array.js") == 0) { + if (!CompileExperimentalBuiltin(isolate(), i)) return false; + } } InstallExperimentalNativeFunctions(); diff --git a/src/flag-definitions.h b/src/flag-definitions.h index 5fc5d88..bac9c46 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -174,6 +174,7 @@ DEFINE_bool(harmony_iteration, false, "enable harmony iteration (for-of)") DEFINE_bool(harmony_numeric_literals, false, "enable harmony numeric literals (0o77, 0b11)") DEFINE_bool(harmony_strings, false, "enable harmony string") +DEFINE_bool(harmony_arrays, false, "enable harmony arrays") DEFINE_bool(harmony, false, "enable all harmony features (except typeof)") DEFINE_implication(harmony, harmony_scoping) DEFINE_implication(harmony, harmony_modules) @@ -185,6 +186,7 @@ DEFINE_implication(harmony, harmony_generators) DEFINE_implication(harmony, harmony_iteration) DEFINE_implication(harmony, harmony_numeric_literals) DEFINE_implication(harmony, harmony_strings) +DEFINE_implication(harmony, harmony_arrays) DEFINE_implication(harmony_modules, harmony_scoping) DEFINE_implication(harmony_observation, harmony_collections) // TODO[dslomov] add harmony => harmony_typed_arrays diff --git a/src/harmony-array.js b/src/harmony-array.js new file mode 100644 index 0000000..e440299 --- /dev/null +++ b/src/harmony-array.js @@ -0,0 +1,124 @@ +// Copyright 2013 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. + +'use strict'; + +// This file relies on the fact that the following declaration has been made +// in runtime.js: +// var $Array = global.Array; + +// ------------------------------------------------------------------- + +// ES6 draft 07-15-13, section 15.4.3.23 +function ArrayFind(predicate /* thisArg */) { // length == 1 + if (IS_NULL_OR_UNDEFINED(this) && !IS_UNDETECTABLE(this)) { + throw MakeTypeError("called_on_null_or_undefined", + ["Array.prototype.find"]); + } + + var array = ToObject(this); + var length = ToInteger(array.length); + + if (!IS_SPEC_FUNCTION(predicate)) { + throw MakeTypeError('called_non_callable', [predicate]); + } + + var thisArg; + if (%_ArgumentsLength() > 1) { + thisArg = %_Arguments(1); + } + + if (IS_NULL_OR_UNDEFINED(thisArg)) { + thisArg = %GetDefaultReceiver(predicate) || thisArg; + } else if (!IS_SPEC_OBJECT(thisArg) && %IsClassicModeFunction(predicate)) { + thisArg = ToObject(thisArg); + } + + for (var i = 0; i < length; i++) { + if (i in array) { + var element = array[i]; + if (%_CallFunction(thisArg, element, i, array, predicate)) { + return element; + } + } + } + + return; +} + + +// ES6 draft 07-15-13, section 15.4.3.24 +function ArrayFindIndex(predicate /* thisArg */) { // length == 1 + if (IS_NULL_OR_UNDEFINED(this) && !IS_UNDETECTABLE(this)) { + throw MakeTypeError("called_on_null_or_undefined", + ["Array.prototype.findIndex"]); + } + + var array = ToObject(this); + var length = ToInteger(array.length); + + if (!IS_SPEC_FUNCTION(predicate)) { + throw MakeTypeError('called_non_callable', [predicate]); + } + + var thisArg; + if (%_ArgumentsLength() > 1) { + thisArg = %_Arguments(1); + } + + if (IS_NULL_OR_UNDEFINED(thisArg)) { + thisArg = %GetDefaultReceiver(predicate) || thisArg; + } else if (!IS_SPEC_OBJECT(thisArg) && %IsClassicModeFunction(predicate)) { + thisArg = ToObject(thisArg); + } + + for (var i = 0; i < length; i++) { + if (i in array) { + var element = array[i]; + if (%_CallFunction(thisArg, element, i, array, predicate)) { + return i; + } + } + } + + return -1; +} + + +// ------------------------------------------------------------------- + +function HarmonyArrayExtendArrayPrototype() { + %CheckIsBootstrapping(); + + // Set up the non-enumerable functions on the Array prototype object. + InstallFunctions($Array.prototype, DONT_ENUM, $Array( + "find", ArrayFind, + "findIndex", ArrayFindIndex + )); +} + +HarmonyArrayExtendArrayPrototype(); \ No newline at end of file diff --git a/test/mjsunit/harmony/array-find.js b/test/mjsunit/harmony/array-find.js new file mode 100644 index 0000000..906c9cd --- /dev/null +++ b/test/mjsunit/harmony/array-find.js @@ -0,0 +1,280 @@ +// Copyright 2013 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. + +// Flags: --harmony-arrays + +assertEquals(1, Array.prototype.find.length); + +var a = [21, 22, 23, 24]; +assertEquals(undefined, a.find(function() { return false; })); +assertEquals(21, a.find(function() { return true; })); +assertEquals(undefined, a.find(function(val) { return 121 === val; })); +assertEquals(24, a.find(function(val) { return 24 === val; })); +assertEquals(23, a.find(function(val) { return 23 === val; }), null); +assertEquals(22, a.find(function(val) { return 22 === val; }), undefined); + + +// +// Test predicate is not called when array is empty +// +(function() { + var a = []; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + + a.find(function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertEquals(-1, l); + assertEquals(-1, o); + assertEquals(-1, v); + assertEquals(-1, k); +})(); + + +// +// Test predicate is called with correct argumetns +// +(function() { + var a = ["b"]; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + + var found = a.find(function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertArrayEquals(a, o); + assertEquals(a.length, l); + assertEquals("b", v); + assertEquals(0, k); + assertEquals(undefined, found); +})(); + + +// +// Test predicate is called array.length times +// +(function() { + var a = [1, 2, 3, 4, 5]; + var l = 0; + var found = a.find(function() { + l++; + return false; + }); + + assertEquals(a.length, l); + assertEquals(undefined, found); +})(); + + +// +// Test Array.prototype.find works with String +// +(function() { + var a = "abcd"; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + var found = Array.prototype.find.call(a, function(val, key, obj) { + o = obj.toString(); + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertEquals(a, o); + assertEquals(a.length, l); + assertEquals("d", v); + assertEquals(3, k); + assertEquals(undefined, found); + + found = Array.prototype.find.apply(a, [function(val, key, obj) { + o = obj.toString(); + l = obj.length; + v = val; + k = key; + + return true; + }]); + + assertEquals(a, o); + assertEquals(a.length, l); + assertEquals("a", v); + assertEquals(0, k); + assertEquals("a", found); +})(); + + +// +// Test Array.prototype.find works with exotic object +// +(function() { + var l = -1; + var o = -1; + var v = -1; + var k = -1; + var a = { + prop1: "val1", + prop2: "val2", + isValid: function() { + return this.prop1 === "val1" && this.prop2 === "val2"; + } + }; + + Array.prototype.push.apply(a, [30, 31, 32]); + var found = Array.prototype.find.call(a, function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return !obj.isValid(); + }); + + assertArrayEquals(a, o); + assertEquals(3, l); + assertEquals(32, v); + assertEquals(2, k); + assertEquals(undefined, found); +})(); + + +// +// Test array modifications +// +(function() { + var a = [1, 2, 3]; + var found = a.find(function(val) { a.push(val); return false; }); + assertArrayEquals([1, 2, 3, 1, 2, 3], a); + assertEquals(6, a.length); + assertEquals(undefined, found); + + a = [1, 2, 3]; + found = a.find(function(val, key) { a[key] = ++val; return false; }); + assertArrayEquals([2, 3, 4], a); + assertEquals(3, a.length); + assertEquals(undefined, found); +})(); + + +// +// Test predicate is only called for existing elements +// +(function() { + var a = new Array(30); + a[11] = 21; + a[7] = 10; + a[29] = 31; + + var count = 0; + a.find(function() { count++; return false; }); + assertEquals(3, count); +})(); + + +// +// Test thisArg +// +(function() { + // Test String as a thisArg + var found = [1, 2, 3].find(function(val, key) { + return this.charAt(Number(key)) === String(val); + }, "321"); + assertEquals(2, found); + + // Test object as a thisArg + var thisArg = { + elementAt: function(key) { + return this[key]; + } + }; + Array.prototype.push.apply(thisArg, ["c", "b", "a"]); + + found = ["a", "b", "c"].find(function(val, key) { + return this.elementAt(key) === val; + }, thisArg); + assertEquals("b", found); +})(); + +// Test exceptions +assertThrows('Array.prototype.find.call(null, function() { })', + TypeError); +assertThrows('Array.prototype.find.call(undefined, function() { })', + TypeError); +assertThrows('Array.prototype.find.apply(null, function() { }, [])', + TypeError); +assertThrows('Array.prototype.find.apply(undefined, function() { }, [])', + TypeError); + +assertThrows('[].find(null)', TypeError); +assertThrows('[].find(undefined)', TypeError); +assertThrows('[].find(0)', TypeError); +assertThrows('[].find(true)', TypeError); +assertThrows('[].find(false)', TypeError); +assertThrows('[].find("")', TypeError); +assertThrows('[].find({})', TypeError); +assertThrows('[].find([])', TypeError); +assertThrows('[].find(/\d+/)', TypeError); + +assertThrows('Array.prototype.find.call({}, null)', TypeError); +assertThrows('Array.prototype.find.call({}, undefined)', TypeError); +assertThrows('Array.prototype.find.call({}, 0)', TypeError); +assertThrows('Array.prototype.find.call({}, true)', TypeError); +assertThrows('Array.prototype.find.call({}, false)', TypeError); +assertThrows('Array.prototype.find.call({}, "")', TypeError); +assertThrows('Array.prototype.find.call({}, {})', TypeError); +assertThrows('Array.prototype.find.call({}, [])', TypeError); +assertThrows('Array.prototype.find.call({}, /\d+/)', TypeError); + +assertThrows('Array.prototype.find.apply({}, null, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, undefined, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, 0, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, true, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, false, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, "", [])', TypeError); +assertThrows('Array.prototype.find.apply({}, {}, [])', TypeError); +assertThrows('Array.prototype.find.apply({}, [], [])', TypeError); +assertThrows('Array.prototype.find.apply({}, /\d+/, [])', TypeError); \ No newline at end of file diff --git a/test/mjsunit/harmony/array-findindex.js b/test/mjsunit/harmony/array-findindex.js new file mode 100644 index 0000000..928cad7 --- /dev/null +++ b/test/mjsunit/harmony/array-findindex.js @@ -0,0 +1,280 @@ +// Copyright 2013 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. + +// Flags: --harmony-arrays + +assertEquals(1, Array.prototype.findIndex.length); + +var a = [21, 22, 23, 24]; +assertEquals(-1, a.findIndex(function() { return false; })); +assertEquals(-1, a.findIndex(function(val) { return 121 === val; })); +assertEquals(0, a.findIndex(function() { return true; })); +assertEquals(1, a.findIndex(function(val) { return 22 === val; }), undefined); +assertEquals(2, a.findIndex(function(val) { return 23 === val; }), null); +assertEquals(3, a.findIndex(function(val) { return 24 === val; })); + + +// +// Test predicate is not called when array is empty +// +(function() { + var a = []; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + + a.findIndex(function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertEquals(-1, l); + assertEquals(-1, o); + assertEquals(-1, v); + assertEquals(-1, k); +})(); + + +// +// Test predicate is called with correct argumetns +// +(function() { + var a = ["b"]; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + + var index = a.findIndex(function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertArrayEquals(a, o); + assertEquals(a.length, l); + assertEquals("b", v); + assertEquals(0, k); + assertEquals(-1, index); +})(); + + +// +// Test predicate is called array.length times +// +(function() { + var a = [1, 2, 3, 4, 5]; + var l = 0; + + a.findIndex(function() { + l++; + return false; + }); + + assertEquals(a.length, l); +})(); + + +// +// Test Array.prototype.findIndex works with String +// +(function() { + var a = "abcd"; + var l = -1; + var o = -1; + var v = -1; + var k = -1; + + var index = Array.prototype.findIndex.call(a, function(val, key, obj) { + o = obj.toString(); + l = obj.length; + v = val; + k = key; + + return false; + }); + + assertEquals(a, o); + assertEquals(a.length, l); + assertEquals("d", v); + assertEquals(3, k); + assertEquals(-1, index); + + index = Array.prototype.findIndex.apply(a, [function(val, key, obj) { + o = obj.toString(); + l = obj.length; + v = val; + k = key; + + return true; + }]); + + assertEquals(a, o); + assertEquals(a.length, l); + assertEquals("a", v); + assertEquals(0, k); + assertEquals(0, index); +})(); + + +// +// Test Array.prototype.findIndex works with exotic object +// +(function() { + var l = -1; + var o = -1; + var v = -1; + var k = -1; + var a = { + prop1: "val1", + prop2: "val2", + isValid: function() { + return this.prop1 === "val1" && this.prop2 === "val2"; + } + }; + + Array.prototype.push.apply(a, [30, 31, 32]); + + var index = Array.prototype.findIndex.call(a, function(val, key, obj) { + o = obj; + l = obj.length; + v = val; + k = key; + + return !obj.isValid(); + }); + + assertArrayEquals(a, o); + assertEquals(3, l); + assertEquals(32, v); + assertEquals(2, k); + assertEquals(-1, index); +})(); + + +// +// Test array modifications +// +(function() { + var a = [1, 2, 3]; + a.findIndex(function(val) { a.push(val); return false; }); + assertArrayEquals([1, 2, 3, 1, 2, 3], a); + assertEquals(6, a.length); + + a = [1, 2, 3]; + a.findIndex(function(val, key) { a[key] = ++val; return false; }); + assertArrayEquals([2, 3, 4], a); + assertEquals(3, a.length); +})(); + + +// +// Test predicate is only called for existing elements +// +(function() { + var a = new Array(30); + a[11] = 21; + a[7] = 10; + a[29] = 31; + + var count = 0; + a.findIndex(function() { count++; return false; }); + assertEquals(3, count); +})(); + + +// +// Test thisArg +// +(function() { + // Test String as a thisArg + var index = [1, 2, 3].findIndex(function(val, key) { + return this.charAt(Number(key)) === String(val); + }, "321"); + assertEquals(1, index); + + // Test object as a thisArg + var thisArg = { + elementAt: function(key) { + return this[key]; + } + }; + Array.prototype.push.apply(thisArg, ["c", "b", "a"]); + + index = ["a", "b", "c"].findIndex(function(val, key) { + return this.elementAt(key) === val; + }, thisArg); + assertEquals(1, index); +})(); + +// Test exceptions +assertThrows('Array.prototype.findIndex.call(null, function() { })', + TypeError); +assertThrows('Array.prototype.findIndex.call(undefined, function() { })', + TypeError); +assertThrows('Array.prototype.findIndex.apply(null, function() { }, [])', + TypeError); +assertThrows('Array.prototype.findIndex.apply(undefined, function() { }, [])', + TypeError); + +assertThrows('[].findIndex(null)', TypeError); +assertThrows('[].findIndex(undefined)', TypeError); +assertThrows('[].findIndex(0)', TypeError); +assertThrows('[].findIndex(true)', TypeError); +assertThrows('[].findIndex(false)', TypeError); +assertThrows('[].findIndex("")', TypeError); +assertThrows('[].findIndex({})', TypeError); +assertThrows('[].findIndex([])', TypeError); +assertThrows('[].findIndex(/\d+/)', TypeError); + +assertThrows('Array.prototype.findIndex.call({}, null)', TypeError); +assertThrows('Array.prototype.findIndex.call({}, undefined)', TypeError); +assertThrows('Array.prototype.findIndex.call({}, 0)', TypeError); +assertThrows('Array.prototype.findIndex.call({}, true)', TypeError); +assertThrows('Array.prototype.findIndex.call({}, false)', TypeError); +assertThrows('Array.prototype.findIndex.call({}, "")', TypeError); +assertThrows('Array.prototype.findIndex.call({}, {})', TypeError); +assertThrows('Array.prototype.findIndex.call({}, [])', TypeError); +assertThrows('Array.prototype.findIndex.call({}, /\d+/)', TypeError); + +assertThrows('Array.prototype.findIndex.apply({}, null, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, undefined, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, 0, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, true, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, false, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, "", [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, {}, [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, [], [])', TypeError); +assertThrows('Array.prototype.findIndex.apply({}, /\d+/, [])', TypeError); \ No newline at end of file diff --git a/tools/gyp/v8.gyp b/tools/gyp/v8.gyp index c9abdf5..582681c 100644 --- a/tools/gyp/v8.gyp +++ b/tools/gyp/v8.gyp @@ -905,7 +905,8 @@ '../../src/typedarray.js', '../../src/generator.js', '../../src/array-iterator.js', - '../../src/harmony-string.js' + '../../src/harmony-string.js', + '../../src/harmony-array.js', ], 'i18n_library_files': [ '../../src/extensions/i18n/header.js', -- 2.7.4