From 9ec88da27f1d81ce94720b49f2d60774abd8330a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 21 Apr 2024 22:38:28 +0200 Subject: [PATCH 1/6] feat: enable Float16Array support --- cli/main.rs | 2 +- cli/tsc/dts/lib.deno.unstable.d.ts | 503 +++++++++++++++++++++++++++++ tests/unit/esnext_test.ts | 9 + 3 files changed, 513 insertions(+), 1 deletion(-) diff --git a/cli/main.rs b/cli/main.rs index a4e93ca3156c4c..6efad7cd49679b 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -385,7 +385,7 @@ fn resolve_flags_and_init( // Using same default as VSCode: // https://github.com/microsoft/vscode/blob/48d4ba271686e8072fc6674137415bc80d936bc7/extensions/typescript-language-features/src/configuration/configuration.ts#L213-L214 DenoSubcommand::Lsp => vec!["--max-old-space-size=3072".to_string()], - _ => vec![], + _ => vec!["--js-float16array".to_string()], }; init_v8_flags(&default_v8_flags, &flags.v8_flags, get_v8_flags_from_env()); diff --git a/cli/tsc/dts/lib.deno.unstable.d.ts b/cli/tsc/dts/lib.deno.unstable.d.ts index ae3f60d2833b6f..76656108b51714 100644 --- a/cli/tsc/dts/lib.deno.unstable.d.ts +++ b/cli/tsc/dts/lib.deno.unstable.d.ts @@ -4348,3 +4348,506 @@ declare namespace Intl { timeStyle?: "full" | "long" | "medium" | "short"; } } + +/** + * A typed array of 16-bit float values. The contents are initialized to 0. If the requested number + * of bytes could not be allocated an exception is raised. + */ +interface Float16Array { + /** + * The size in bytes of each element in the array. + */ + readonly BYTES_PER_ELEMENT: number; + + /** + * The ArrayBuffer instance referenced by the array. + */ + readonly buffer: ArrayBufferLike; + + /** + * The length in bytes of the array. + */ + readonly byteLength: number; + + /** + * The offset in bytes of the array. + */ + readonly byteOffset: number; + + /** + * Returns the this object after copying a section of the array identified by start and end + * to the same array starting at position target + * @param target If target is negative, it is treated as length+target where length is the + * length of the array. + * @param start If start is negative, it is treated as length+start. If end is negative, it + * is treated as length+end. + * @param end If not specified, length of the this object is used as its default value. + */ + copyWithin(target: number, start: number, end?: number): this; + + /** + * Determines whether all the members of an array satisfy the specified test. + * @param predicate A function that accepts up to three arguments. The every method calls + * the predicate function for each element in the array until the predicate returns a value + * which is coercible to the Boolean value false, or until the end of the array. + * @param thisArg An object to which the this keyword can refer in the predicate function. + * If thisArg is omitted, undefined is used as the this value. + */ + every( + predicate: (value: number, index: number, array: Float16Array) => unknown, + thisArg?: any, + ): boolean; + + /** + * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array + * @param value value to fill array section with + * @param start index to start filling the array at. If start is negative, it is treated as + * length+start where length is the length of the array. + * @param end index to stop filling the array at. If end is negative, it is treated as + * length+end. + */ + fill(value: number, start?: number, end?: number): this; + + /** + * Returns the elements of an array that meet the condition specified in a callback function. + * @param predicate A function that accepts up to three arguments. The filter method calls + * the predicate function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the predicate function. + * If thisArg is omitted, undefined is used as the this value. + */ + filter( + predicate: (value: number, index: number, array: Float16Array) => any, + thisArg?: any, + ): Float16Array; + + /** + * Returns the value of the first element in the array where predicate is true, and undefined + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, find + * immediately returns that element value. Otherwise, find returns undefined. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + find( + predicate: (value: number, index: number, obj: Float16Array) => boolean, + thisArg?: any, + ): number | undefined; + + /** + * Returns the index of the first element in the array where predicate is true, and -1 + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, + * findIndex immediately returns that element index. Otherwise, findIndex returns -1. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findIndex( + predicate: (value: number, index: number, obj: Float16Array) => boolean, + thisArg?: any, + ): number; + + /** + * Performs the specified action for each element in an array. + * @param callbackfn A function that accepts up to three arguments. forEach calls the + * callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. + * If thisArg is omitted, undefined is used as the this value. + */ + forEach( + callbackfn: (value: number, index: number, array: Float16Array) => void, + thisArg?: any, + ): void; + + /** + * Returns the index of the first occurrence of a value in an array. + * @param searchElement The value to locate in the array. + * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the + * search starts at index 0. + */ + indexOf(searchElement: number, fromIndex?: number): number; + + /** + * Adds all the elements of an array separated by the specified separator string. + * @param separator A string used to separate one element of an array from the next in the + * resulting String. If omitted, the array elements are separated with a comma. + */ + join(separator?: string): string; + + /** + * Returns the index of the last occurrence of a value in an array. + * @param searchElement The value to locate in the array. + * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the + * search starts at index 0. + */ + lastIndexOf(searchElement: number, fromIndex?: number): number; + + /** + * The length of the array. + */ + readonly length: number; + + /** + * Calls a defined callback function on each element of an array, and returns an array that + * contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the + * callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. + * If thisArg is omitted, undefined is used as the this value. + */ + map( + callbackfn: (value: number, index: number, array: Float16Array) => number, + thisArg?: any, + ): Float16Array; + + /** + * Calls the specified callback function for all the elements in an array. The return value of + * the callback function is the accumulated result, and is provided as an argument in the next + * call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduce method calls the + * callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start + * the accumulation. The first call to the callbackfn function provides this value as an argument + * instead of an array value. + */ + reduce( + callbackfn: ( + previousValue: number, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => number, + ): number; + reduce( + callbackfn: ( + previousValue: number, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => number, + initialValue: number, + ): number; + + /** + * Calls the specified callback function for all the elements in an array. The return value of + * the callback function is the accumulated result, and is provided as an argument in the next + * call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduce method calls the + * callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start + * the accumulation. The first call to the callbackfn function provides this value as an argument + * instead of an array value. + */ + reduce( + callbackfn: ( + previousValue: U, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => U, + initialValue: U, + ): U; + + /** + * Calls the specified callback function for all the elements in an array, in descending order. + * The return value of the callback function is the accumulated result, and is provided as an + * argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls + * the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start + * the accumulation. The first call to the callbackfn function provides this value as an + * argument instead of an array value. + */ + reduceRight( + callbackfn: ( + previousValue: number, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => number, + ): number; + reduceRight( + callbackfn: ( + previousValue: number, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => number, + initialValue: number, + ): number; + + /** + * Calls the specified callback function for all the elements in an array, in descending order. + * The return value of the callback function is the accumulated result, and is provided as an + * argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls + * the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start + * the accumulation. The first call to the callbackfn function provides this value as an argument + * instead of an array value. + */ + reduceRight( + callbackfn: ( + previousValue: U, + currentValue: number, + currentIndex: number, + array: Float16Array, + ) => U, + initialValue: U, + ): U; + + /** + * Reverses the elements in an Array. + */ + reverse(): Float16Array; + + /** + * Sets a value or an array of values. + * @param array A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: ArrayLike, offset?: number): void; + + /** + * Returns a section of an array. + * @param start The beginning of the specified portion of the array. + * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. + */ + slice(start?: number, end?: number): Float16Array; + + /** + * Determines whether the specified callback function returns true for any element of an array. + * @param predicate A function that accepts up to three arguments. The some method calls + * the predicate function for each element in the array until the predicate returns a value + * which is coercible to the Boolean value true, or until the end of the array. + * @param thisArg An object to which the this keyword can refer in the predicate function. + * If thisArg is omitted, undefined is used as the this value. + */ + some( + predicate: (value: number, index: number, array: Float16Array) => unknown, + thisArg?: any, + ): boolean; + + /** + * Sorts an array. + * @param compareFn Function used to determine the order of the elements. It is expected to return + * a negative value if first argument is less than second argument, zero if they're equal and a positive + * value otherwise. If omitted, the elements are sorted in ascending order. + * ```ts + * [11,2,22,1].sort((a, b) => a - b) + * ``` + */ + sort(compareFn?: (a: number, b: number) => number): this; + + /** + * Gets a new Float16Array view of the ArrayBuffer store for this array, referencing the elements + * at begin, inclusive, up to end, exclusive. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin?: number, end?: number): Float16Array; + + /** + * Converts a number to a string by using the current locale. + */ + toLocaleString(): string; + + /** + * Returns a string representation of an array. + */ + toString(): string; + + /** Returns the primitive value of the specified object. */ + valueOf(): Float16Array; + + [index: number]: number; +} + +interface Float16ArrayConstructor { + readonly prototype: Float16Array; + new (length: number): Float16Array; + new (array: ArrayLike | ArrayBufferLike): Float16Array; + new ( + buffer: ArrayBufferLike, + byteOffset?: number, + length?: number, + ): Float16Array; + + /** + * The size in bytes of each element in the array. + */ + readonly BYTES_PER_ELEMENT: number; + + /** + * Returns a new array from a set of elements. + * @param items A set of elements to include in the new array object. + */ + of(...items: number[]): Float16Array; + + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + */ + from(arrayLike: ArrayLike): Float16Array; + + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from( + arrayLike: ArrayLike, + mapfn: (v: T, k: number) => number, + thisArg?: any, + ): Float16Array; +} +declare var Float16Array: Float16ArrayConstructor; + +interface Float16 { + [Symbol.iterator](): IterableIterator; + /** + * Returns an array of key, value pairs for every entry in the array + */ + entries(): IterableIterator<[number, number]>; + /** + * Returns an list of keys in the array + */ + keys(): IterableIterator; + /** + * Returns an list of values in the array + */ + values(): IterableIterator; +} + +interface Float16Constructor { + new (elements: Iterable): Float16; + + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from( + arrayLike: Iterable, + mapfn?: (v: number, k: number) => number, + thisArg?: any, + ): Float16; +} + +interface Float16Array { + readonly [Symbol.toStringTag]: "Float16Array"; +} + +interface Float16Array { + /** + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ + includes(searchElement: number, fromIndex?: number): boolean; +} + +interface Float16ArrayConstructor { + new (): Float16Array; +} + +interface Float16Array { + /** + * Returns the item located at the specified index. + * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. + */ + at(index: number): number | undefined; +} + +interface Float16Array { + /** + * Returns the value of the last element in the array where predicate is true, and undefined + * otherwise. + * @param predicate findLast calls predicate once for each element of the array, in descending + * order, until it finds one where predicate returns true. If such an element is found, findLast + * immediately returns that element value. Otherwise, findLast returns undefined. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findLast( + predicate: ( + value: number, + index: number, + array: Float16Array, + ) => value is S, + thisArg?: any, + ): S | undefined; + findLast( + predicate: ( + value: number, + index: number, + array: Float16Array, + ) => unknown, + thisArg?: any, + ): number | undefined; + + /** + * Returns the index of the last element in the array where predicate is true, and -1 + * otherwise. + * @param predicate findLastIndex calls predicate once for each element of the array, in descending + * order, until it finds one where predicate returns true. If such an element is found, + * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findLastIndex( + predicate: ( + value: number, + index: number, + array: Float16Array, + ) => unknown, + thisArg?: any, + ): number; + + /** + * Copies the array and returns the copy with the elements in reverse order. + */ + toReversed(): Float16Array; + + /** + * Copies and sorts the array. + * @param compareFn Function used to determine the order of the elements. It is expected to return + * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive + * value otherwise. If omitted, the elements are sorted in ascending order. + * ```ts + * const myNums = Float16Array.from([11.25, 2, -22.5, 1]); + * myNums.toSorted((a, b) => a - b) // Float16Array(4) [-22.5, 1, 2, 11.5] + * ``` + */ + toSorted(compareFn?: (a: number, b: number) => number): Float16Array; + + /** + * Copies the array and inserts the given number at the provided index. + * @param index The index of the value to overwrite. If the index is + * negative, then it replaces from the end of the array. + * @param value The value to insert into the copied array. + * @returns A copy of the original array with the inserted value. + */ + with(index: number, value: number): Float16Array; +} + +interface DataView { + /** + * Gets the Float16 value at the specified byte offset from the start of the view. There is + * no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + * @param littleEndian If false or undefined, a big-endian value should be read. + */ + getFloat16(byteOffset: number, littleEndian?: boolean): number; + + /** + * Stores an Float16 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written. + */ + setFloat16(byteOffset: number, value: number, littleEndian?: boolean): void; +} diff --git a/tests/unit/esnext_test.ts b/tests/unit/esnext_test.ts index cb40cc241664ea..1d5759aafaf5a3 100644 --- a/tests/unit/esnext_test.ts +++ b/tests/unit/esnext_test.ts @@ -48,3 +48,12 @@ Deno.test(function setUnion() { const union = a.union(b); assertEquals(union, new Set([1, 2, 3, 4, 5])); }); + +Deno.test(function float16Array() { + const myNums = Float16Array.from([11.25, 2, -22.5, 1]); + const sorted = myNums.toSorted((a, b) => a - b); + assertEquals(sorted[0], -22.5); + assertEquals(sorted[1], 1); + assertEquals(sorted[2], 2); + assertEquals(sorted[3], 11.25); +}); From be30e04121f8cac8e94a1cd3bfb4ee293349778d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 22 Apr 2024 20:50:49 +0200 Subject: [PATCH 2/6] update tests --- tests/integration/lsp_tests.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/integration/lsp_tests.rs b/tests/integration/lsp_tests.rs index da8d9492566bf3..248b02faa71e0d 100644 --- a/tests/integration/lsp_tests.rs +++ b/tests/integration/lsp_tests.rs @@ -5144,7 +5144,7 @@ fn lsp_jsr_auto_import_completion() { json!({ "triggerKind": 1 }), ); assert!(!list.is_incomplete); - assert_eq!(list.items.len(), 263); + assert_eq!(list.items.len(), 264); let item = list.items.iter().find(|i| i.label == "add").unwrap(); assert_eq!(&item.label, "add"); assert_eq!( @@ -5224,7 +5224,7 @@ fn lsp_jsr_auto_import_completion_import_map() { json!({ "triggerKind": 1 }), ); assert!(!list.is_incomplete); - assert_eq!(list.items.len(), 263); + assert_eq!(list.items.len(), 264); let item = list.items.iter().find(|i| i.label == "add").unwrap(); assert_eq!(&item.label, "add"); assert_eq!(json!(&item.label_details), json!({ "description": "add" })); From fc8dce53fc29ffba3d2a9f4493d75f43391a8f46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 22 Apr 2024 23:43:15 +0200 Subject: [PATCH 3/6] update WPT --- tests/wpt/runner/expectation.json | 79 +++++++++++++++++++++---------- 1 file changed, 55 insertions(+), 24 deletions(-) diff --git a/tests/wpt/runner/expectation.json b/tests/wpt/runner/expectation.json index 46ee585927f12b..8e53a249d13d84 100644 --- a/tests/wpt/runner/expectation.json +++ b/tests/wpt/runner/expectation.json @@ -1,11 +1,7 @@ { "WebCryptoAPI": { - "getRandomValues.any.html": [ - "Float arrays" - ], - "getRandomValues.any.worker.html": [ - "Float arrays" - ], + "getRandomValues.any.html": true, + "getRandomValues.any.worker.html": true, "derive_bits_keys": { "ecdh_bits.https.any.html": [ "P-521 good parameters", @@ -6852,8 +6848,52 @@ "request-headers-case.any.worker.html": false, "request-headers-nonascii.any.html": true, "request-headers-nonascii.any.worker.html": true, - "request-headers.any.html": false, - "request-headers.any.worker.html": false, + "request-headers.any.html": [ + "Fetch with PUT without body", + "Fetch with PUT with body", + "Fetch with POST without body", + "Fetch with POST with text body", + "Fetch with POST with FormData body", + "Fetch with POST with URLSearchParams body", + "Fetch with POST with Blob body", + "Fetch with POST with ArrayBuffer body", + "Fetch with POST with Uint8Array body", + "Fetch with POST with Int8Array body", + "Fetch with POST with Float32Array body", + "Fetch with POST with Float64Array body", + "Fetch with POST with DataView body", + "Fetch with POST with Blob body with mime type", + "Fetch with Chicken", + "Fetch with Chicken with body", + "Fetch with POST and mode \"same-origin\" needs an Origin header", + "Fetch with POST and mode \"no-cors\" needs an Origin header", + "Fetch with PUT and mode \"same-origin\" needs an Origin header", + "Fetch with TacO and mode \"same-origin\" needs an Origin header", + "Fetch with TacO and mode \"cors\" needs an Origin header" + ], + "request-headers.any.worker.html": [ + "Fetch with PUT without body", + "Fetch with PUT with body", + "Fetch with POST without body", + "Fetch with POST with text body", + "Fetch with POST with FormData body", + "Fetch with POST with URLSearchParams body", + "Fetch with POST with Blob body", + "Fetch with POST with ArrayBuffer body", + "Fetch with POST with Uint8Array body", + "Fetch with POST with Int8Array body", + "Fetch with POST with Float32Array body", + "Fetch with POST with Float64Array body", + "Fetch with POST with DataView body", + "Fetch with POST with Blob body with mime type", + "Fetch with Chicken", + "Fetch with Chicken with body", + "Fetch with POST and mode \"same-origin\" needs an Origin header", + "Fetch with POST and mode \"no-cors\" needs an Origin header", + "Fetch with PUT and mode \"same-origin\" needs an Origin header", + "Fetch with TacO and mode \"same-origin\" needs an Origin header", + "Fetch with TacO and mode \"cors\" needs an Origin header" + ], "text-utf8.any.html": true, "text-utf8.any.worker.html": true, "accept-header.any.html": true, @@ -7122,12 +7162,8 @@ "response-from-stream.any.worker.html": true, "response-cancel-stream.any.html": true, "response-cancel-stream.any.worker.html": true, - "response-clone.any.html": [ - "Check response clone use structureClone for teed ReadableStreams (Float16Arraychunk)" - ], - "response-clone.any.worker.html": [ - "Check response clone use structureClone for teed ReadableStreams (Float16Arraychunk)" - ], + "response-clone.any.html": true, + "response-clone.any.worker.html": true, "response-consume-empty.any.html": [ "Consume empty FormData response body as text" ], @@ -8490,12 +8526,8 @@ "blob": { "Blob-array-buffer.any.html": true, "Blob-array-buffer.any.worker.html": true, - "Blob-constructor.any.html": [ - "Passing typed arrays as elements of the blobParts array should work." - ], - "Blob-constructor.any.worker.html": [ - "Passing typed arrays as elements of the blobParts array should work." - ], + "Blob-constructor.any.html": true, + "Blob-constructor.any.worker.html": true, "Blob-slice-overflow.any.html": true, "Blob-slice-overflow.any.worker.html": true, "Blob-slice.any.html": true, @@ -10110,8 +10142,7 @@ "The IDBKeyRange interface object should be exposed.", "The IDBCursor interface object should be exposed.", "The IDBCursorWithValue interface object should be exposed.", - "The IDBTransaction interface object should be exposed.", - "The Float16Array interface object should be exposed." + "The IDBTransaction interface object should be exposed." ], "002.worker.html": true }, @@ -10650,8 +10681,8 @@ "compression-with-detach.tentative.window.html": true, "decompression-bad-chunks.tentative.any.html": true, "decompression-bad-chunks.tentative.any.worker.html": true, - "decompression-buffersource.tentative.any.html": false, - "decompression-buffersource.tentative.any.worker.html": false, + "decompression-buffersource.tentative.any.html": true, + "decompression-buffersource.tentative.any.worker.html": true, "decompression-constructor-error.tentative.any.html": true, "decompression-constructor-error.tentative.any.worker.html": true, "decompression-correct-input.tentative.any.html": true, From a219e95ecc6b048bf206992e132924fcd0e7de03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 23 Apr 2024 00:00:22 +0200 Subject: [PATCH 4/6] encodeInto --- tests/wpt/runner/expectation.json | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/tests/wpt/runner/expectation.json b/tests/wpt/runner/expectation.json index 8e53a249d13d84..48c9d10c21d2e2 100644 --- a/tests/wpt/runner/expectation.json +++ b/tests/wpt/runner/expectation.json @@ -2887,14 +2887,8 @@ "api-replacement-encodings.any.worker.html": true, "api-surrogates-utf8.any.html": true, "api-surrogates-utf8.any.worker.html": true, - "encodeInto.any.html": [ - "Invalid encodeInto() destination: Float16Array, backed by: ArrayBuffer", - "Invalid encodeInto() destination: Float16Array, backed by: SharedArrayBuffer" - ], - "encodeInto.any.worker.html": [ - "Invalid encodeInto() destination: Float16Array, backed by: ArrayBuffer", - "Invalid encodeInto() destination: Float16Array, backed by: SharedArrayBuffer" - ], + "encodeInto.any.html": true, + "encodeInto.any.worker.html": true, "idlharness.any.html": true, "idlharness.any.worker.html": true, "iso-2022-jp-decoder.any.html": true, From 783ae027c2cecb6ce9a24d41a2dde9c6a40a9d1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 23 Apr 2024 04:54:15 +0200 Subject: [PATCH 5/6] support in structuredClone --- ext/web/02_structured_clone.js | 4 ++++ tests/wpt/runner/expectation.json | 2 ++ 2 files changed, 6 insertions(+) diff --git a/ext/web/02_structured_clone.js b/ext/web/02_structured_clone.js index 0b8df4ac29ad59..84829c3132282e 100644 --- a/ext/web/02_structured_clone.js +++ b/ext/web/02_structured_clone.js @@ -36,6 +36,7 @@ const { Uint16Array, Uint32Array, BigUint64Array, + Float16Array, Float32Array, Float64Array, } = primordials; @@ -115,6 +116,9 @@ function structuredClone(value) { case "BigUint64Array": Constructor = BigUint64Array; break; + case "Float16Array": + Constructor = Float16Array; + break; case "Float32Array": Constructor = Float32Array; break; diff --git a/tests/wpt/runner/expectation.json b/tests/wpt/runner/expectation.json index 48c9d10c21d2e2..f20cd78f110260 100644 --- a/tests/wpt/runner/expectation.json +++ b/tests/wpt/runner/expectation.json @@ -6853,6 +6853,7 @@ "Fetch with POST with ArrayBuffer body", "Fetch with POST with Uint8Array body", "Fetch with POST with Int8Array body", + "Fetch with POST with Float16Array body", "Fetch with POST with Float32Array body", "Fetch with POST with Float64Array body", "Fetch with POST with DataView body", @@ -6876,6 +6877,7 @@ "Fetch with POST with ArrayBuffer body", "Fetch with POST with Uint8Array body", "Fetch with POST with Int8Array body", + "Fetch with POST with Float16Array body", "Fetch with POST with Float32Array body", "Fetch with POST with Float64Array body", "Fetch with POST with DataView body", From 1372b83bb970acc0375ba881a684f940541a503b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 23 Apr 2024 15:07:56 +0200 Subject: [PATCH 6/6] update tests again --- tests/wpt/runner/expectation.json | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/wpt/runner/expectation.json b/tests/wpt/runner/expectation.json index f20cd78f110260..48f1db0f460bcc 100644 --- a/tests/wpt/runner/expectation.json +++ b/tests/wpt/runner/expectation.json @@ -7158,8 +7158,12 @@ "response-from-stream.any.worker.html": true, "response-cancel-stream.any.html": true, "response-cancel-stream.any.worker.html": true, - "response-clone.any.html": true, - "response-clone.any.worker.html": true, + "response-clone.any.html": [ + "Check response clone use structureClone for teed ReadableStreams (Float16Arraychunk)" + ], + "response-clone.any.worker.html": [ + "Check response clone use structureClone for teed ReadableStreams (Float16Arraychunk)" + ], "response-consume-empty.any.html": [ "Consume empty FormData response body as text" ],