fix(intl): complete issue #5896 Test262 worklist

changelog.d/8659-intl402-worklist.md

@@ -0,0 +1 @@
+Completed the #5896 Test262 Intl402 worklist. Locale canonicalization now applies ICU4X CLDR aliases and likely-subtag data, Intl constructors consistently handle proxy-backed locale and option objects, Collator/PluralRules/RelativeTimeFormat/Segmenter behavior matches the listed ECMA-402 cases, derived Intl classes preserve their native prototypes, and maximum-length arrays stay logically sparse. All 101 pinned worklist tests now pass.

crates/perry-runtime/Cargo.toml

@@ -179,16 +179,13 @@ global-webfetch = []
 # detection would make `process.send` undefined, so err toward enabling).
 proc-ipc = []
 # `Intl.getCanonicalLocales` / `*.supportedLocalesOf` BCP-47 (UTS #35) language-tag
-# canonicalization via `icu_locale_core` (the data-free structural parser — case
-# normalization, variant ordering, extension well-formedness, UTS35 rejection of
-# extlang/grandfathered/duplicate-singleton tags). No CLDR data is pulled (that
-# would need `icu_locale` + `icu_locale_data`), so deep alias replacement
-# (grandfathered→preferred, complex subtag replacement) is out of scope. Only
-# `intl.rs` uses it; a program that never canonicalizes a locale links none of
-# it (the compiler enables it on `Intl.getCanonicalLocales`/`supportedLocalesOf`
-# usage). Already pulled transitively by `temporal`, so default/shipped builds
-# carry no extra weight. A hand-rolled structural fallback covers the off case.
-intl-locale = ["dep:icu_locale_core"]
+# canonicalization via ICU4X's structural parser plus compiled CLDR aliases and
+# likely-subtag data. Only Intl locale operations use it; a program that never
+# canonicalizes or expands a locale links none of it. The same data is already
+# pulled transitively by `intl-datetime` in default builds, so the shipped full
+# runtime carries no duplicate tables. A hand-rolled fallback covers the off
+# case for size-optimized builds.
+intl-locale = ["dep:icu_locale", "dep:icu_locale_core"]
 # CLDR-accurate Intl.DateTimeFormat / toLocaleString date-time patterns.
 intl-datetime = ["dep:icu_datetime", "dep:icu_time", "dep:icu_calendar", "dep:icu_locale_core"]
 # `full` only opt-ins the small Node-API helpers (os.hostname / os.homedir).
@@ -302,9 +299,10 @@ unicode-normalization = { version = "0.1", optional = true }
 # Intl.Segmenter (the grapheme path is what string-width@7+/wrap-ansi@9+ use,
 # so it gates ink). Pure-Rust UAX #29 implementation, already in our lock graph.
 unicode-segmentation = { version = "1", optional = true }
-# #5298: BCP-47 (UTS #35) structural locale-tag canonicalization for
-# `Intl.getCanonicalLocales` / `*.supportedLocalesOf`. The data-free structural
-# parser only (no CLDR alias tables); already in our lock graph via temporal_rs.
+# #5298/#5896: BCP-47 (UTS #35) structural locale-tag canonicalization, CLDR
+# aliases, and likely-subtag expansion for the Intl locale APIs. Both crates and
+# their compiled data are already in the default lock graph via icu_datetime.
+icu_locale = { version = "2", optional = true }
 icu_locale_core = { version = "2", optional = true }
 # CLDR date/time formatting for Intl.DateTimeFormat / Date.prototype.toLocale*
 # (icu4x 2.x, matching the icu_calendar/icu_locale_core already in the graph).

crates/perry-runtime/src/array/push_pop.rs

@@ -974,7 +974,36 @@ pub extern "C" fn js_array_set_length(arr: *mut ArrayHeader, new_length: f64) {
             // index 0 cannot remain observable after its getter truncates the
             // array to zero. If a non-configurable index blocks deletion, keep
             // that index and restore length to index + 1 per §10.4.2.4.
-            for i in (n..cur).rev() {
+            //
+            // A large logical extension does not allocate its holes (see the
+            // growth branch below), so do not walk those holes when the length
+            // is restored. Far materialized indices live in the named-property
+            // table. Delete them first, in the same descending order required
+            // by ArraySetLength, then visit the allocated dense prefix.
+            let capacity = (*arr).capacity;
+            if cur > capacity {
+                let mut sparse_indices: Vec<u32> = array_named_property_names(arr, false)
+                    .into_iter()
+                    .filter_map(|name| {
+                        let index = name.parse::<u32>().ok()?;
+                        (index != u32::MAX
+                            && index >= n.max(capacity)
+                            && index < cur
+                            && index.to_string() == name)
+                            .then_some(index)
+                    })
+                    .collect();
+                sparse_indices.sort_unstable_by(|a, b| b.cmp(a));
+                sparse_indices.dedup();
+                for i in sparse_indices {
+                    if js_array_delete(arr, i) == 0 {
+                        (*arr).length = i + 1;
+                        refresh_array_numeric_layout(arr);
+                        return;
+                    }
+                }
+            }
+            for i in (n..cur.min(capacity)).rev() {
                 if js_array_delete(arr, i) == 0 {
                     (*arr).length = i + 1;
                     refresh_array_numeric_layout(arr);
@@ -984,6 +1013,15 @@ pub extern "C" fn js_array_set_length(arr: *mut ArrayHeader, new_length: f64) {
             (*arr).length = n;
             refresh_array_numeric_layout(arr);
         } else if n > cur {
+            // Growing `length` creates holes conceptually; it must not allocate
+            // a dense backing store proportional to the requested length.
+            // Test262's descriptor probe writes 2^32-1 here. Keep large sparse
+            // extensions logical and let later indexed writes choose storage.
+            if n > (*arr).capacity && n > 1_000_000 {
+                (*arr).length = n;
+                refresh_array_numeric_layout(arr);
+                return;
+            }
             // Extend: pad with TAG_HOLE. Past-capacity extensions go
             // through `js_array_grow` which installs a forwarding pointer at
             // the OLD location (issue #233 mechanism), so the caller's stale

crates/perry-runtime/src/array/tests.rs

@@ -1187,6 +1187,20 @@ fn test_numeric_array_layout_length_and_delete_transitions() {
     }
 }
 
+#[test]
+fn large_length_growth_stays_logically_sparse() {
+    let mut arr = js_array_alloc(1);
+    arr = js_array_push_f64(arr, 1.0);
+    js_array_set_length(arr, u32::MAX as f64);
+
+    assert_eq!(js_array_length(arr), u32::MAX);
+    assert!(unsafe { (*arr).capacity } <= 1_000_000);
+
+    js_array_set_length(arr, 1.0);
+    assert_eq!(js_array_length(arr), 1);
+    assert_eq!(array_spec_get(arr, 0), 1.0);
+}
+
 #[test]
 fn test_numeric_array_layout_immutable_helpers_preserve_or_downgrade() {
     let values = [10.0, 2.0, 30.0, 40.0];