From bfc495f0cb202db449c1f310249a447be50a952c Mon Sep 17 00:00:00 2001 From: Robert Fancsik Date: Tue, 3 Dec 2019 15:39:11 +0100 Subject: [PATCH] Implement Array.from routine (#3402) The patch also revealed a minor issue about Map[Symbol.iterator] which have been fixed as well. Co-authored-by: Daniella Barsony bella@inf.u-szeged.hu JerryScript-DCO-1.0-Signed-off-by: Robert Fancsik frobert@inf.u-szeged.hu --- .../ecma/builtin-objects/ecma-builtin-array.c | 332 ++++++++++++++++- .../builtin-objects/ecma-builtin-array.inc.h | 3 + .../ecma-builtin-map-prototype.inc.h | 2 +- jerry-core/lit/lit-magic-strings.inc.h | 2 - tests/jerry/es2015/array-from.js | 344 ++++++++++++++++++ tests/jerry/es2015/map-iterators.js | 40 +- 6 files changed, 699 insertions(+), 24 deletions(-) create mode 100644 tests/jerry/es2015/array-from.js diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-array.c b/jerry-core/ecma/builtin-objects/ecma-builtin-array.c index 487358759..b6638b596 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-array.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-array.c @@ -15,14 +15,16 @@ #include "ecma-alloc.h" #include "ecma-builtins.h" +#include "ecma-builtin-helpers.h" #include "ecma-conversion.h" #include "ecma-exceptions.h" +#include "ecma-function-object.h" #include "ecma-gc.h" #include "ecma-globals.h" #include "ecma-helpers.h" +#include "ecma-iterator-object.h" #include "ecma-objects.h" #include "ecma-array-object.h" -#include "ecma-try-catch-macro.h" #include "jrt.h" #if ENABLED (JERRY_BUILTIN_ARRAY) @@ -62,6 +64,334 @@ ecma_builtin_array_object_is_array (ecma_value_t this_arg, /**< 'this' argument return ecma_make_boolean_value (ecma_is_value_array (arg)); } /* ecma_builtin_array_object_is_array */ +#if ENABLED (JERRY_ES2015) +/** + * The Array object's 'from' routine + * + * See also: + * ECMA-262 v6, 22.1.2.1 + * + * @return ecma value + * Returned value must be freed with ecma_free_value. + */ +static ecma_value_t +ecma_builtin_array_object_from (ecma_value_t this_arg, /**< 'this' argument */ + const ecma_value_t *arguments_list_p, /**< arguments list */ + ecma_length_t arguments_list_len) /**< number of arguments */ +{ + /* 1. */ + ecma_value_t constructor = this_arg; + ecma_value_t call_this_arg = ECMA_VALUE_UNDEFINED; + ecma_value_t items = arguments_list_p[0]; + ecma_value_t mapfn = (arguments_list_len > 1) ? arguments_list_p[1] : ECMA_VALUE_UNDEFINED; + + /* 2. */ + ecma_object_t *mapfn_obj_p = NULL; + + /* 3. */ + if (!ecma_is_value_undefined (mapfn)) + { + /* 3.a */ + if (!ecma_op_is_callable (mapfn)) + { + return ecma_raise_type_error (ECMA_ERR_MSG ("Callback function is not callable.")); + } + + /* 3.b */ + if (arguments_list_len > 2) + { + call_this_arg = arguments_list_p[2]; + } + + /* 3.c */ + mapfn_obj_p = ecma_get_object_from_value (mapfn); + } + + /* 4. */ + ecma_value_t using_iterator = ecma_op_get_method_by_symbol_id (items, LIT_MAGIC_STRING_ITERATOR); + + /* 5. */ + if (ECMA_IS_VALUE_ERROR (using_iterator)) + { + return using_iterator; + } + + ecma_value_t ret_value = ECMA_VALUE_ERROR; + + /* 6. */ + if (!ecma_is_value_undefined (using_iterator)) + { + ecma_value_t array; + + /* 6.a */ + if (ecma_is_constructor (constructor)) + { + ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor); + + array = ecma_op_function_construct (constructor_obj_p, ECMA_VALUE_UNDEFINED, NULL, 0); + + if (ecma_is_value_undefined (array) || ecma_is_value_null (array)) + { + ecma_free_value (using_iterator); + return ecma_raise_type_error (ECMA_ERR_MSG ("Cannot convert undefined or null to object")); + } + } + else + { + /* 6.b */ + array = ecma_op_create_array_object (NULL, 0, false); + } + + /* 6.c */ + if (ECMA_IS_VALUE_ERROR (array)) + { + ecma_free_value (using_iterator); + return array; + } + + ecma_object_t *array_obj_p = ecma_get_object_from_value (array); + + /* 6.d */ + ecma_value_t iterator = ecma_op_get_iterator (items, using_iterator); + ecma_free_value (using_iterator); + + /* 6.e */ + if (ECMA_IS_VALUE_ERROR (iterator)) + { + ecma_free_value (array); + return iterator; + } + + /* 6.f */ + uint32_t k = 0; + + /* 6.g */ + while (true) + { + /* 6.g.ii */ + ecma_value_t next = ecma_op_iterator_step (iterator); + + /* 6.g.iii */ + if (ECMA_IS_VALUE_ERROR (next)) + { + goto iterator_cleanup; + } + + /* 6.g.iii */ + if (ecma_is_value_false (next)) + { + /* 6.g.iv.1 */ + ecma_value_t len_value = ecma_make_uint32_value (k); + ecma_value_t set_status = ecma_op_object_put (array_obj_p, + ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH), + len_value, + true); + ecma_free_value (len_value); + + /* 6.g.iv.2 */ + if (ECMA_IS_VALUE_ERROR (set_status)) + { + goto iterator_cleanup; + } + + ecma_free_value (iterator); + /* 6.g.iv.3 */ + return array; + } + + /* 6.g.v */ + ecma_value_t next_value = ecma_op_iterator_value (next); + + ecma_free_value (next); + + /* 6.g.vi */ + if (ECMA_IS_VALUE_ERROR (next_value)) + { + goto iterator_cleanup; + } + + ecma_value_t mapped_value; + /* 6.g.vii */ + if (mapfn_obj_p != NULL) + { + /* 6.g.vii.1 */ + ecma_value_t args_p[2] = { next_value, ecma_make_uint32_value (k) }; + /* 6.g.vii.3 */ + mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2); + ecma_free_value (args_p[1]); + ecma_free_value (next_value); + + /* 6.g.vii.2 */ + if (ECMA_IS_VALUE_ERROR (mapped_value)) + { + ecma_op_iterator_close (iterator); + goto iterator_cleanup; + } + } + else + { + /* 6.g.viii */ + mapped_value = next_value; + } + + /* 6.g.ix */ + const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | ECMA_IS_THROW; + ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags); + + ecma_free_value (mapped_value); + + /* 6.g.x */ + if (ECMA_IS_VALUE_ERROR (set_status)) + { + ecma_op_iterator_close (iterator); + goto iterator_cleanup; + } + + /* 6.g.xi */ + k++; + } + +iterator_cleanup: + ecma_free_value (iterator); + ecma_free_value (array); + + return ret_value; + } + + /* 8. */ + ecma_value_t array_like = ecma_op_to_object (items); + + /* 9. */ + if (ECMA_IS_VALUE_ERROR (array_like)) + { + return array_like; + } + + ecma_object_t *array_like_obj_p = ecma_get_object_from_value (array_like); + + /* 10. */ + uint32_t len; + ecma_value_t len_value = ecma_op_object_get_length (array_like_obj_p, &len); + + /* 11. */ + if (ECMA_IS_VALUE_ERROR (len_value)) + { + goto cleanup; + } + + len_value = ecma_make_uint32_value (len); + + /* 12. */ + ecma_value_t array; + + /* 12.a */ + if (ecma_is_constructor (constructor)) + { + ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor); + + array = ecma_op_function_construct (constructor_obj_p, ECMA_VALUE_UNDEFINED, &len_value, 1); + + if (ecma_is_value_undefined (array) || ecma_is_value_null (array)) + { + ecma_free_value (len_value); + ecma_raise_type_error (ECMA_ERR_MSG ("Cannot convert undefined or null to object")); + goto cleanup; + } + } + else + { + /* 13.a */ + array = ecma_op_create_array_object (&len_value, 1, true); + } + + ecma_free_value (len_value); + + /* 14. */ + if (ECMA_IS_VALUE_ERROR (array)) + { + goto cleanup; + } + + ecma_object_t *array_obj_p = ecma_get_object_from_value (array); + + /* 15. */ + uint32_t k = 0; + + /* 16. */ + while (k < len) + { + /* 16.b */ + ecma_string_t *pk = ecma_new_ecma_string_from_uint32 (k); + ecma_value_t k_value = ecma_op_object_get (array_like_obj_p, pk); + ecma_deref_ecma_string (pk); + + /* 16.c */ + if (ECMA_IS_VALUE_ERROR (k_value)) + { + goto cleanup; + } + + ecma_value_t mapped_value; + /* 16.d */ + if (mapfn_obj_p != NULL) + { + /* 16.d.i */ + ecma_value_t args_p[2] = { k_value, ecma_make_uint32_value (k) }; + mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2); + ecma_free_value (args_p[1]); + ecma_free_value (k_value); + + /* 16.d.ii */ + if (ECMA_IS_VALUE_ERROR (mapped_value)) + { + goto cleanup; + } + } + else + { + /* 16.e */ + mapped_value = k_value; + } + + /* 16.f */ + const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | ECMA_IS_THROW; + ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags); + + ecma_free_value (mapped_value); + + /* 16.g */ + if (ECMA_IS_VALUE_ERROR (set_status)) + { + goto cleanup; + } + + /* 16.h */ + k++; + } + + /* 17. */ + len_value = ecma_make_uint32_value (k); + ecma_value_t set_status = ecma_op_object_put (array_obj_p, + ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH), + len_value, + true); + ecma_free_value (len_value); + + /* 18. */ + if (ECMA_IS_VALUE_ERROR (set_status)) + { + goto cleanup; + } + + /* 19. */ + ret_value = ecma_make_object_value (array_obj_p); + +cleanup: + ecma_deref_object (array_like_obj_p); + return ret_value; +} /* ecma_builtin_array_object_from */ +#endif /* ENABLED (JERRY_ES2015) */ + /** * Handle calling [[Call]] of built-in Array object * diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h b/jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h index ccea4a5e6..bd980fbbf 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h @@ -40,6 +40,9 @@ NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, /* Routine properties: * (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */ ROUTINE (LIT_MAGIC_STRING_IS_ARRAY_UL, ecma_builtin_array_object_is_array, 1, 1) +#if ENABLED (JERRY_ES2015) +ROUTINE (LIT_MAGIC_STRING_FROM, ecma_builtin_array_object_from, NON_FIXED, 1) +#endif /* ENABLED (JERRY_ES2015) */ #endif /* !(ENABLED (JERRY_BUILTIN_ARRAY)) */ diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.inc.h b/jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.inc.h index a98468a14..68e56e6b5 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.inc.h +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.inc.h @@ -48,7 +48,7 @@ ROUTINE (LIT_MAGIC_STRING_SET, ecma_builtin_map_prototype_object_set, 2, 2) ROUTINE (LIT_MAGIC_STRING_ENTRIES, ecma_builtin_map_prototype_object_entries, 0, 0) ROUTINE (LIT_MAGIC_STRING_VALUES, ecma_builtin_map_prototype_object_values, 0, 0) ROUTINE (LIT_MAGIC_STRING_KEYS, ecma_builtin_map_prototype_object_keys, 0, 0) -ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_map_prototype_object_values, 0, 0) +ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_map_prototype_object_entries, 0, 0) #endif /* ENABLED (JERRY_ES2015) */ /* ECMA-262 v6, 23.1.3.10 */ diff --git a/jerry-core/lit/lit-magic-strings.inc.h b/jerry-core/lit/lit-magic-strings.inc.h index 4e18cfb2e..898444070 100644 --- a/jerry-core/lit/lit-magic-strings.inc.h +++ b/jerry-core/lit/lit-magic-strings.inc.h @@ -139,8 +139,6 @@ LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EXEC, "exec") || ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FILL, "fill") LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FIND, "find") -#endif -#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FROM, "from") #endif #if ENABLED (JERRY_BUILTIN_ARRAY) \ diff --git a/tests/jerry/es2015/array-from.js b/tests/jerry/es2015/array-from.js new file mode 100644 index 000000000..5e144790a --- /dev/null +++ b/tests/jerry/es2015/array-from.js @@ -0,0 +1,344 @@ +// Copyright JS Foundation and other contributors, http://js.foundation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// 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. + +// Some methods are taken from v8/test/mjsunit/mjsunit.js + +function classOf(object) { + // Argument must not be null or undefined. + var string = Object.prototype.toString.call(object); + // String has format [object ]. + return string.substring(8, string.length - 1); +} + +/** + * Compares two objects for key/value equality. + * Returns true if they are equal, false otherwise. + */ +function deepObjectEquals(a, b) { + var aProps = Object.keys(a); + aProps.sort(); + var bProps = Object.keys(b); + bProps.sort(); + if (!deepEquals(aProps, bProps)) { + return false; + } + for (var i = 0; i < aProps.length; i++) { + if (!deepEquals(a[aProps[i]], b[aProps[i]])) { + return false; + } + } + return true; +} + +var assertInstanceof = function assertInstanceof(obj, type) { + if (!(obj instanceof type)) { + var actualTypeName = null; + var actualConstructor = Object.getPrototypeOf(obj).constructor; + if (typeof actualConstructor == "function") { + actualTypeName = actualConstructor.name || String(actualConstructor); + } print("Object <" + obj + "> is not an instance of <" + (type.name || type) + ">" + (actualTypeName ? " but of < " + actualTypeName + ">" : "")); + } +}; + +function deepEquals(a, b) { + if (a === b) { + if (a === 0) return (1 / a) === (1 / b); + return true; + } + if (typeof a != typeof b) return false; + if (typeof a == "number") return isNaN(a) && isNaN(b); + if (typeof a !== "object" && typeof a !== "function") return false; + var objectClass = classOf(a); + if (objectClass !== classOf(b)) return false; + if (objectClass === "RegExp") { + return (a.toString() === b.toString()); + } + if (objectClass === "Function") return false; + if (objectClass === "Array") { + var elementCount = 0; + if (a.length != b.length) { + return false; + } + for (var i = 0; i < a.length; i++) { + if (!deepEquals(a[i], b[i])) + return false; + } + return true; + } + if (objectClass == "String" || objectClass == "Number" || objectClass == "Boolean" || objectClass == "Date") { + if (a.valueOf() !== b.valueOf()) return false; + } + return deepObjectEquals(a, b); +} + +var assertEquals = function assertEquals(expected, found, name_opt) { + if (!deepEquals(found, expected)) { + assert(false); + } +}; + +function assertArrayLikeEquals(value, expected, type) { + assertInstanceof(value, type); + assert(expected.length === value.length); + for (var i=0; i { throw 5 }); + assert(false); + } catch (e) { + assert(e === 5); + } + + return closed; +} +assert(close1()); + +function close2() { + var closed = false; + var iter = __createIterableObject([1, 2, 3], { + 'return': function() { closed = true; throw 6 } + }); + + try { + Array.from(iter, x => { throw 5 }); + assert(false); + } catch (e) { + assert(e === 5); + } + + return closed; +} +assert(close2()); + diff --git a/tests/jerry/es2015/map-iterators.js b/tests/jerry/es2015/map-iterators.js index 64122e3b6..fc327f098 100644 --- a/tests/jerry/es2015/map-iterators.js +++ b/tests/jerry/es2015/map-iterators.js @@ -62,62 +62,62 @@ methods.forEach(function (method) { } }); -var valueIterators = [m.values(), m[Symbol.iterator]()]; +var entryIterators = [m.entries(), m[Symbol.iterator]()]; var keyIterator = m.keys(); -var entryIterator = m.entries(); +var valueIterator = m.values(); var elementCount = m.size; for (var i = 0; i < elementCount; i++) { - valueIterators.forEach(function(element) { + entryIterators.forEach(function(element) { var next = element.next(); assert(next.done === false); - assert(next.value === i); + assert(next.value[0] === '' + i); + assert(next.value[1] === i); }); var next = keyIterator.next(); assert(next.done === false); assert(next.value === '' + i); - var next = entryIterator.next(); + var next = valueIterator.next(); assert(next.done === false); - assert(next.value[0] === '' + i); - assert(next.value[1] === i); + assert(next.value === i); } -valueIterators.forEach(function(element) { - var next = element.next(); - assert(next.done === true); - assert(next.value === undefined); - }); +entryIterators.forEach(function(element) { + var next = element.next(); + assert(next.done === true); + assert(next.value === undefined); +}); var next = keyIterator.next(); assert(next.done === true); assert(next.value === undefined); -next = entryIterator.next(); +next = valueIterator.next(); assert(next.done === true); assert(next.value === undefined); -var valueIterators = [m.values(), m[Symbol.iterator]()]; +var entryIterators = [m.entries(), m[Symbol.iterator]()]; var keyIterator = m.keys(); -var entryIterator = m.entries(); +var valueIterator = m.values(); var elementCount = m.size; for (var i = 0; i < elementCount; i++) { - valueIterators.forEach(function(element) { + entryIterators.forEach(function(element) { var next = element.next(); assert(next.done === false); - assert(next.value === i); + assert(next.value[0] === '' + i); + assert(next.value[1] === i); }); var next = keyIterator.next(); assert(next.done === false); assert(next.value === '' + i); - var next = entryIterator.next(); + var next = valueIterator.next(); assert(next.done === false); - assert(next.value[0] === '' + i); - assert(next.value[1] === i); + assert(next.value === i); m.delete('' + i); }