Implement TypedArray.from and TypedArray.of

balajirrao · web-flow · commit 452e1051122c · 2025-08-04T18:50:53.000+02:00
diff --git a/rhino/src/main/java/org/mozilla/javascript/AbstractEcmaObjectOperations.java b/rhino/src/main/java/org/mozilla/javascript/AbstractEcmaObjectOperations.java
@@ -491,7 +491,7 @@ static boolean validateAndApplyPropertyDescriptor(
      * <p><a href="https://262.ecma-international.org/12.0/#sec-isconstructor">7.2.4 IsConstructor
      * (argument)</a>
      */
-    static boolean isConstructor(Context cx, Object argument) {
+    public static boolean isConstructor(Context cx, Object argument) {
         /*
            The abstract operation IsConstructor takes argument argument (an ECMAScript language value).
            It determines if argument is a function object with a [[Construct]] internal method.
diff --git a/rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeTypedArrayView.java b/rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeTypedArrayView.java
@@ -7,6 +7,7 @@
 package org.mozilla.javascript.typedarrays;
 
 import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
@@ -24,6 +25,7 @@
 import org.mozilla.javascript.Context;
 import org.mozilla.javascript.ExternalArrayData;
 import org.mozilla.javascript.Function;
+import org.mozilla.javascript.IteratorLikeIterable;
 import org.mozilla.javascript.LambdaConstructor;
 import org.mozilla.javascript.NativeArray;
 import org.mozilla.javascript.NativeArrayIterator;
@@ -246,6 +248,11 @@ static void init(
             defineMethod(ta, s, "with", 2, NativeTypedArrayView::js_with);
             defineMethod(ta, s, SymbolKey.ITERATOR, 0, NativeTypedArrayView::js_iterator);
 
+            ta.defineConstructorMethod(
+                    scope, "from", 1, NativeTypedArrayView::js_from, DONTENUM, DONTENUM | READONLY);
+            ta.defineConstructorMethod(
+                    scope, "of", 0, NativeTypedArrayView::js_of, DONTENUM, DONTENUM | READONLY);
+
             ta = (LambdaConstructor) s.associateValue(TYPED_ARRAY_TAG, ta);
         }
         constructor.setPrototype(ta);
@@ -1154,7 +1161,8 @@ private NativeTypedArrayView<?> typedArraySpeciesCreate(
                 }
             }
         } else {
-            throw ScriptRuntime.typeErrorById("msg.typed.array.ctor.incompatible", methodName);
+            throw ScriptRuntime.typeErrorById(
+                    "msg.typed.array.receiver.incompatible", "prototype." + methodName);
         }
 
         return (NativeTypedArrayView<?>) newArray;
@@ -1236,6 +1244,120 @@ private static Object js_with(Context cx, Scriptable scope, Scriptable thisObj,
         return result;
     }
 
+    private static Object js_from(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+        if (args.length < 1) {
+            throw ScriptRuntime.typeErrorById("msg.missing.argument");
+        }
+        final Scriptable items = ScriptRuntime.toObject(scope, args[0]);
+        if (!AbstractEcmaObjectOperations.isConstructor(cx, thisObj)) {
+            throw ScriptRuntime.typeErrorById("msg.constructor.expected");
+        }
+        Constructable constructable = (Constructable) thisObj;
+
+        Function mapFn = null;
+        Object mapArg = (args.length >= 2) ? args[1] : Undefined.instance;
+        Scriptable mapFnThisArg = Undefined.SCRIPTABLE_UNDEFINED;
+        if (!Undefined.isUndefined(mapArg)) {
+            if (!(mapArg instanceof Function)) {
+                throw ScriptRuntime.typeErrorById("msg.map.function.not");
+            }
+            mapFn = (Function) mapArg;
+            if (args.length >= 3) {
+                mapFnThisArg = ScriptableObject.ensureScriptable(args[2]);
+            }
+        }
+
+        List<Object> listFromIterator = null;
+        Object iteratorProp = ScriptableObject.getProperty(items, SymbolKey.ITERATOR);
+        // Optimization: When items is an instance of java.util.List and also have an iterator,
+        // we don't use the iterator to avoid copying the contents to determine the length.
+        // However, with this the test262 test
+        // built-ins/TypedArray/from/iterated-array-changed-by-tonumber.js
+        // doesn't pass.
+        if (!(iteratorProp == Scriptable.NOT_FOUND)
+                && !(items instanceof List) // NativeArray and NativeTypedArrayView
+                && !Undefined.isUndefined(iteratorProp)) {
+            final Object iterator = ScriptRuntime.callIterator(items, cx, scope);
+            if (!Undefined.isUndefined(iterator)) {
+                try (IteratorLikeIterable it = new IteratorLikeIterable(cx, scope, iterator)) {
+                    listFromIterator = new ArrayList<>();
+                    for (Object temp : it) {
+                        listFromIterator.add(temp);
+                    }
+                }
+            }
+        }
+
+        int size;
+        if (listFromIterator != null) {
+            size = listFromIterator.size();
+        } else {
+            long sizeLong = AbstractEcmaObjectOperations.lengthOfArrayLike(cx, items);
+            if (sizeLong > Integer.MAX_VALUE) {
+                throw ScriptRuntime.rangeErrorById("msg.arraylength.bad");
+            }
+
+            size = (int) AbstractEcmaObjectOperations.lengthOfArrayLike(cx, items);
+        }
+
+        Scriptable result = constructable.construct(cx, scope, new Object[] {size});
+        if (!(result instanceof NativeTypedArrayView)) {
+            throw ScriptRuntime.typeErrorById("msg.typed.array.receiver.incompatible", "from");
+        }
+
+        NativeTypedArrayView<?> typedArray = (NativeTypedArrayView<?>) result;
+        if (typedArray.length < size) {
+            throw ScriptRuntime.typeErrorById("msg.typed.array.length.too.small");
+        }
+
+        for (int k = 0; k < size; k++) {
+            Object temp;
+            if (listFromIterator != null) {
+                temp = listFromIterator.get(k);
+            } else if (items instanceof List<?>) {
+                try {
+                    temp = ((List<?>) items).get(k);
+                } catch (IndexOutOfBoundsException e) {
+                    temp = Undefined.instance;
+                }
+            } else {
+                temp = ScriptRuntime.getObjectIndex(items, k, cx, scope);
+            }
+
+            if (mapFn != null) {
+                temp = mapFn.call(cx, scope, mapFnThisArg, new Object[] {temp, k});
+            }
+
+            typedArray.setArrayElement(k, temp);
+        }
+
+        return result;
+    }
+
+    private static Object js_of(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+        if (!AbstractEcmaObjectOperations.isConstructor(cx, thisObj)) {
+            throw ScriptRuntime.typeErrorById("msg.constructor.expected");
+        }
+        Constructable constructable = (Constructable) thisObj;
+
+        Scriptable result = constructable.construct(cx, scope, new Object[] {args.length});
+
+        if (!(result instanceof NativeTypedArrayView)) {
+            throw ScriptRuntime.typeErrorById("msg.typed.array.receiver.incompatible", "of");
+        }
+
+        NativeTypedArrayView<?> typedArray = (NativeTypedArrayView<?>) result;
+        if (typedArray.length < args.length) {
+            throw ScriptRuntime.typeErrorById("msg.typed.array.length.too.small");
+        }
+
+        for (int k = 0; k < args.length; k++) {
+            typedArray.setArrayElement(k, args[k]);
+        }
+
+        return result;
+    }
+
     // External Array implementation
 
     @Override
diff --git a/rhino/src/main/resources/org/mozilla/javascript/resources/Messages.properties b/rhino/src/main/resources/org/mozilla/javascript/resources/Messages.properties
@@ -1021,8 +1021,8 @@ msg.promise.all.toobig =\
 msg.promise.any.toobig =\
   Too many inputs to Promise.any
 
-msg.typed.array.ctor.incompatible = \
-  Method %TypedArray%.prototype.{0} called on incompatible receiver
+msg.typed.array.receiver.incompatible = \
+  Method %TypedArray%.{0} called on incompatible receiver
 
 msg.typed.array.bad.offset = \
   offset {0} out of range
@@ -1048,6 +1048,9 @@ msg.typed.array.out.of.bounds =\
 msg.typed.array.type.mismatch =\
   Typed arrays content type does not match
 
+msg.typed.array.length.too.small =\
+    Derived TypedArray constructor created an array which was too small
+
 # Error
 msg.iterable.expected =\
   Expected the first argument to be iterable
diff --git a/tests/testsrc/test262.properties b/tests/testsrc/test262.properties
@@ -2171,28 +2171,11 @@ built-ins/ThrowTypeError 8/14 (57.14%)
     unique-per-realm-non-simple.js
     unique-per-realm-unmapped-args.js
 
-built-ins/TypedArray 273/1434 (19.04%)
-    from/arylk-get-length-error.js
-    from/arylk-to-length-error.js
-    from/from-array-mapper-detaches-result.js
+built-ins/TypedArray 256/1434 (17.85%)
     from/from-array-mapper-makes-result-out-of-bounds.js {unsupported: [resizable-arraybuffer]}
-    from/from-typedarray-into-itself-mapper-detaches-result.js
     from/from-typedarray-into-itself-mapper-makes-result-out-of-bounds.js {unsupported: [resizable-arraybuffer]}
-    from/from-typedarray-mapper-detaches-result.js
     from/from-typedarray-mapper-makes-result-out-of-bounds.js {unsupported: [resizable-arraybuffer]}
-    from/iter-access-error.js
-    from/iter-invoke-error.js
-    from/iter-next-error.js
-    from/iter-next-value-error.js
     from/iterated-array-changed-by-tonumber.js
-    from/length.js
-    from/name.js
-    from/not-a-constructor.js
-    from/prop-desc.js
-    of/length.js
-    of/name.js
-    of/not-a-constructor.js
-    of/prop-desc.js
     of/resized-with-out-of-bounds-and-in-bounds-indices.js {unsupported: [resizable-arraybuffer]}
     prototype/at/BigInt/return-abrupt-from-this-out-of-bounds.js {unsupported: [resizable-arraybuffer]}
     prototype/at/coerced-index-resize.js {unsupported: [resizable-arraybuffer]}
@@ -2443,7 +2426,7 @@ built-ins/TypedArray 273/1434 (19.04%)
     resizable-buffer-length-tracking-1.js {unsupported: [resizable-arraybuffer]}
     resizable-buffer-length-tracking-2.js {unsupported: [resizable-arraybuffer]}
 
-built-ins/TypedArrayConstructors 251/736 (34.1%)
+built-ins/TypedArrayConstructors 198/736 (26.9%)
     ctors-bigint/buffer-arg/bufferbyteoffset-throws-from-modulo-element-size-sab.js {unsupported: [SharedArrayBuffer]}
     ctors-bigint/buffer-arg/byteoffset-is-negative-throws-sab.js {unsupported: [SharedArrayBuffer]}
     ctors-bigint/buffer-arg/byteoffset-is-negative-zero-sab.js {unsupported: [SharedArrayBuffer]}
@@ -2566,49 +2549,10 @@ built-ins/TypedArrayConstructors 251/736 (34.1%)
     ctors/typedarray-arg/throw-type-error-before-custom-proto-access.js
     ctors/typedarray-arg/use-custom-proto-if-object.js
     ctors/no-species.js
-    from/BigInt/arylk-get-length-error.js
-    from/BigInt/arylk-to-length-error.js
-    from/BigInt/custom-ctor.js
-    from/BigInt/custom-ctor-returns-other-instance.js
-    from/BigInt/iter-access-error.js
-    from/BigInt/iter-invoke-error.js
-    from/BigInt/iter-next-error.js
-    from/BigInt/iter-next-value-error.js
-    from/BigInt/mapfn-abrupt-completion.js
-    from/BigInt/mapfn-arguments.js
-    from/BigInt/mapfn-this-with-thisarg.js
     from/BigInt/mapfn-this-without-thisarg-non-strict.js non-strict
-    from/BigInt/mapfn-this-without-thisarg-strict.js strict
-    from/BigInt/new-instance-empty.js
-    from/BigInt/new-instance-from-ordinary-object.js
-    from/BigInt/new-instance-using-custom-ctor.js
-    from/BigInt/new-instance-with-mapfn.js
-    from/BigInt/new-instance-without-mapfn.js
-    from/BigInt/property-abrupt-completion.js
-    from/BigInt/set-value-abrupt-completion.js
-    from/arylk-get-length-error.js
-    from/arylk-to-length-error.js
-    from/custom-ctor.js
-    from/custom-ctor-returns-other-instance.js
-    from/iter-access-error.js
-    from/iter-invoke-error.js
-    from/iter-next-error.js
-    from/iter-next-value-error.js
-    from/mapfn-abrupt-completion.js
-    from/mapfn-arguments.js
-    from/mapfn-this-with-thisarg.js
     from/mapfn-this-without-thisarg-non-strict.js non-strict
-    from/mapfn-this-without-thisarg-strict.js strict
     from/nan-conversion.js
-    from/new-instance-empty.js
-    from/new-instance-from-ordinary-object.js
     from/new-instance-from-sparse-array.js
-    from/new-instance-from-zero.js
-    from/new-instance-using-custom-ctor.js
-    from/new-instance-with-mapfn.js
-    from/new-instance-without-mapfn.js
-    from/property-abrupt-completion.js
-    from/set-value-abrupt-completion.js
     internals/DefineOwnProperty/BigInt/key-is-not-canonical-index.js
     internals/DefineOwnProperty/BigInt/key-is-numericindex.js
     internals/DefineOwnProperty/BigInt/key-is-numericindex-accessor-desc-throws.js
@@ -2681,20 +2625,6 @@ built-ins/TypedArrayConstructors 251/736 (34.1%)
     internals/Set/key-is-valid-index-reflect-set.js
     internals/Set/resized-out-of-bounds-to-in-bounds-index.js {unsupported: [resizable-arraybuffer]}
     internals/Set/tonumber-value-throws.js
-    of/BigInt/argument-number-value-throws.js
-    of/BigInt/custom-ctor.js
-    of/BigInt/custom-ctor-returns-other-instance.js
-    of/BigInt/new-instance.js
-    of/BigInt/new-instance-empty.js
-    of/BigInt/new-instance-using-custom-ctor.js
-    of/argument-number-value-throws.js
-    of/custom-ctor.js
-    of/custom-ctor-returns-other-instance.js
-    of/nan-conversion.js
-    of/new-instance.js
-    of/new-instance-empty.js
-    of/new-instance-from-zero.js
-    of/new-instance-using-custom-ctor.js
 
 built-ins/WeakMap 11/119 (9.24%)
     prototype/getOrInsert/adds-object-element.js
