fix: clear the TLS and GC-spill release blockers; resolve DateTimeFormat locale options (#8759)

Lands #8754 and #8757.

#8754 clears the `_js_tls_client_preflight` undefined-symbol compile
failures in the gap and GC-stress suites, including
`test_gap_gc_http2_pending_event_callback_rooting`. The stdlib TLS
server/preflight provider is retained when `net`, `http`, `https` or
`http2` routes to the optimized external wrappers, and the bundled and
external `js_tls_connect` adapters are split so the external path no
longer reintroduces duplicate net symbols.

It also roots all four external TLS connect inputs across user-replaced
`createSecureContext` and preflight callbacks -- both of which can run
arbitrary user JS -- via `root_scope.root_nanbox(..)`, with a dedicated
gap fixture and expected output
(`test_issue_8754_tls_connect_args_gc_rooting`).

The mixed-frame cargo integration test now matches the enriched
root-spill diagnostic. That is a tightening rather than a relaxation: the
asserted substring moves from "GC roots in a shadow frame" to the more
specific "in a shadow frame instead of statepoints", and it still
requires the spill to have happened.

#8757 fixes `Intl.DateTimeFormat` locale option resolution, covered by
`test_gap_intl_datetimeformat_locale_resolution_5899`.

A changelog fragment was added for #8757; it had neither one nor a
skip-changelog label. No version bump.

Co-authored-by: Ralph Küpper <ralph@skelpo.com>

Author: proggeramlug

changelog.d/8754-external-http-tls-preflight.md

@@ -0,0 +1,7 @@
+Fixed optimized `node:net`, `node:http`, `node:https`, and `node:http2` builds
+after the TLS parity split. These external wrappers now retain Perry's shared
+TLS server and SNI/ALPN preflight provider without also linking the bundled
+network implementation, eliminating the `js_tls_client_preflight` undefined
+symbol that blocked HTTP gap and GC-stress fixtures at compile time. External
+`tls.connect` overload arguments also remain rooted when a user-replaced
+`createSecureContext` callback triggers a moving collection.

changelog.d/8757-datetimeformat-locale-options.md

@@ -0,0 +1 @@
+Fixed `Intl.DateTimeFormat` locale option resolution so requested options are reflected in the resolved locale rather than dropped. Covered by `test_gap_intl_datetimeformat_locale_resolution_5899`.

crates/perry-ext-net/src/tls.rs

@@ -649,6 +649,17 @@ pub(crate) fn record_tls_handshake(
 /// ABI — see `NA_F64` lowering in perry-codegen.
 #[no_mangle]
 pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f64) -> i64 {
+    // `js_tls_prepare_connect` may invoke a user-replaced createSecureContext
+    // before overload resolution. Keep every incoming value in the runtime's
+    // moving-GC root stack, and re-read the selected options/callback values
+    // after every later callback-capable runtime call.
+    let root_scope = perry_ffi::TransientRootScope::enter();
+    let rooted_args = [
+        root_scope.root_nanbox(arg1),
+        root_scope.root_nanbox(arg2),
+        root_scope.root_nanbox(arg3),
+        root_scope.root_nanbox(arg4),
+    ];
     extern "C" {
         fn js_tls_prepare_connect();
     }
@@ -685,87 +696,89 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
         (j.is_bool() && !j.to_bool()) || (j.is_number() && j.to_number() == 0.0)
     };
 
-    let (host, port, servername, verify, cb_f64, metadata_options);
-    if let Some(h) = as_string(arg1) {
+    let (host, port, servername, verify, callback_arg, metadata_options_arg);
+    if let Some(h) = as_string(rooted_args[0].get()) {
         // Legacy Perry positional: (host, port, servername?, verify?).
-        let p = JsValue::from_bits(arg2.to_bits());
+        let p = JsValue::from_bits(rooted_args[1].get().to_bits());
         if !p.is_number() && !p.is_int32() {
             return 0;
         }
         port = p.to_number() as u16;
-        servername = as_string(arg3).unwrap_or_else(|| h.clone());
+        servername = as_string(rooted_args[2].get()).unwrap_or_else(|| h.clone());
         host = h;
-        verify = !explicitly_off(arg4);
-        cb_f64 = None;
-        metadata_options = f64::from_bits(0x7FFC_0000_0000_0001);
-    } else if JsValue::from_bits(arg1.to_bits()).is_number()
-        || JsValue::from_bits(arg1.to_bits()).is_int32()
+        verify = !explicitly_off(rooted_args[3].get());
+        callback_arg = None;
+        metadata_options_arg = None;
+    } else if JsValue::from_bits(rooted_args[0].get().to_bits()).is_number()
+        || JsValue::from_bits(rooted_args[0].get().to_bits()).is_int32()
     {
         // Node positional form: tls.connect(port[, host][, options][, cb]).
-        js_net_validate_connect_port(arg1);
-        port = JsValue::from_bits(arg1.to_bits()).to_number() as u16;
+        js_net_validate_connect_port(rooted_args[0].get());
+        port = JsValue::from_bits(rooted_args[0].get().to_bits()).to_number() as u16;
         let mut opt_host: Option<String> = None;
-        let mut opts: Option<f64> = None;
-        let mut cb: Option<f64> = None;
-        for v in [arg2, arg3, arg4] {
+        let mut opts_arg: Option<usize> = None;
+        let mut cb_arg: Option<usize> = None;
+        for index in [1, 2, 3] {
+            let v = rooted_args[index].get();
             if opt_host.is_none() {
                 if let Some(h) = as_string(v) {
                     opt_host = Some(h);
                     continue;
                 }
             }
             if is_closure(v) {
-                cb = cb.or(Some(v));
+                cb_arg = cb_arg.or(Some(index));
             } else if is_nanboxed_pointer(v) {
-                opts = opts.or(Some(v));
+                opts_arg = opts_arg.or(Some(index));
             }
         }
-        if let Some(options) = opts {
+        if let Some(index) = opts_arg {
             extern "C" {
                 fn js_tls_validate_positional_connect_options(options: f64);
             }
-            js_tls_validate_positional_connect_options(options);
+            js_tls_validate_positional_connect_options(rooted_args[index].get());
         }
         host = opt_host
             .or_else(|| {
-                opts.and_then(|o| {
-                    get_object_string_field(o, "host")
-                        .or_else(|| get_object_string_field(o, "hostname"))
+                opts_arg.and_then(|index| {
+                    let options = rooted_args[index].get();
+                    get_object_string_field(options, "host")
+                        .or_else(|| get_object_string_field(rooted_args[index].get(), "hostname"))
                 })
             })
             .filter(|h| !h.is_empty())
             .unwrap_or_else(|| "localhost".to_string());
-        servername = opts
-            .and_then(|o| get_object_string_field(o, "servername"))
+        servername = opts_arg
+            .and_then(|index| get_object_string_field(rooted_args[index].get(), "servername"))
             .unwrap_or_else(|| host.clone());
-        verify = opts
-            .and_then(|o| get_object_bool_field(o, "rejectUnauthorized"))
+        verify = opts_arg
+            .and_then(|index| get_object_bool_field(rooted_args[index].get(), "rejectUnauthorized"))
             .unwrap_or(true);
-        cb_f64 = cb;
-        metadata_options = opts.unwrap_or_else(|| f64::from_bits(0x7FFC_0000_0000_0001));
-    } else if is_nanboxed_pointer(arg1) && !is_closure(arg1) {
+        callback_arg = cb_arg;
+        metadata_options_arg = opts_arg;
+    } else if is_nanboxed_pointer(rooted_args[0].get()) && !is_closure(rooted_args[0].get()) {
         // Node options form: tls.connect(options[, callback]).
         extern "C" {
             fn js_tls_validate_connect_options(options: f64);
         }
-        js_tls_validate_connect_options(arg1);
-        if let Some(socket_value) = crate::get_object_value_field(arg1, "socket") {
+        js_tls_validate_connect_options(rooted_args[0].get());
+        if let Some(socket_value) = crate::get_object_value_field(rooted_args[0].get(), "socket") {
             let socket_js = JsValue::from_bits(socket_value.to_bits());
             let handle = if socket_js.is_pointer() {
                 crate::unbox_pointer(socket_value) as i64
             } else {
                 0
             };
             if handle != 0 {
-                host = get_object_string_field(arg1, "host")
-                    .or_else(|| get_object_string_field(arg1, "hostname"))
+                host = get_object_string_field(rooted_args[0].get(), "host")
+                    .or_else(|| get_object_string_field(rooted_args[0].get(), "hostname"))
                     .unwrap_or_else(|| "localhost".to_string());
-                servername =
-                    get_object_string_field(arg1, "servername").unwrap_or_else(|| host.clone());
-                verify = get_object_bool_field(arg1, "rejectUnauthorized").unwrap_or(true);
-                cb_f64 = is_closure(arg2).then_some(arg2);
-                metadata_options = arg1;
-                let config = tls_client_config_data(metadata_options);
+                servername = get_object_string_field(rooted_args[0].get(), "servername")
+                    .unwrap_or_else(|| host.clone());
+                verify = get_object_bool_field(rooted_args[0].get(), "rejectUnauthorized")
+                    .unwrap_or(true);
+                callback_arg = is_closure(rooted_args[1].get()).then_some(1);
+                let config = tls_client_config_data(rooted_args[0].get());
                 extern "C" {
                     fn js_tls_client_record_start(
                         handle: i64,
@@ -776,12 +789,12 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
                 }
                 js_tls_client_record_start(
                     handle,
-                    metadata_options,
+                    rooted_args[0].get(),
                     servername.as_ptr(),
                     servername.len(),
                 );
-                if let Some(cb) = cb_f64 {
-                    let cb_ptr = unbox_pointer(cb) as i64;
+                if let Some(index) = callback_arg {
+                    let cb_ptr = unbox_pointer(rooted_args[index].get()) as i64;
                     if cb_ptr != 0 {
                         statics::listeners()
                             .lock()
@@ -793,7 +806,7 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
                             .push(cb_ptr);
                     }
                 }
-                let preflight = tls_preflight(0, &servername, metadata_options);
+                let preflight = tls_preflight(0, &servername, rooted_args[0].get());
                 if preflight != 0 {
                     crate::push_event(crate::PendingNetEvent::Error(
                         handle,
@@ -807,29 +820,35 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
                 return handle;
             }
         }
-        port = match get_object_number_field(arg1, "port") {
+        port = match get_object_number_field(rooted_args[0].get(), "port") {
             Some(p) => {
                 js_net_validate_connect_port(p);
                 p as u16
             }
             None => return 0,
         };
-        host = match get_object_string_field(arg1, "host")
-            .or_else(|| get_object_string_field(arg1, "hostname"))
+        host = match get_object_string_field(rooted_args[0].get(), "host")
+            .or_else(|| get_object_string_field(rooted_args[0].get(), "hostname"))
         {
             Some(h) if !h.is_empty() => h,
             _ => "localhost".to_string(),
         };
-        servername = get_object_string_field(arg1, "servername").unwrap_or_else(|| host.clone());
-        verify = get_object_bool_field(arg1, "rejectUnauthorized").unwrap_or(true);
-        cb_f64 = is_closure(arg2).then_some(arg2);
-        metadata_options = arg1;
+        servername = get_object_string_field(rooted_args[0].get(), "servername")
+            .unwrap_or_else(|| host.clone());
+        verify = get_object_bool_field(rooted_args[0].get(), "rejectUnauthorized").unwrap_or(true);
+        callback_arg = is_closure(rooted_args[1].get()).then_some(1);
+        metadata_options_arg = Some(0);
     } else {
         return 0;
     }
 
-    let config = tls_client_config_data(metadata_options);
-    if signal_is_pre_aborted(metadata_options) {
+    let metadata_options = || {
+        metadata_options_arg
+            .map(|index| rooted_args[index].get())
+            .unwrap_or_else(|| f64::from_bits(0x7FFC_0000_0000_0001))
+    };
+    let config = tls_client_config_data(metadata_options());
+    if signal_is_pre_aborted(metadata_options()) {
         let handle = crate::js_net_socket_alloc();
         extern "C" {
             fn js_tls_client_record_start(
@@ -841,14 +860,14 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
         }
         js_tls_client_record_start(
             handle,
-            metadata_options,
+            metadata_options(),
             servername.as_ptr(),
             servername.len(),
         );
         schedule_tls_abort(handle);
         return handle;
     }
-    let preflight = tls_preflight(port, &servername, metadata_options);
+    let preflight = tls_preflight(port, &servername, metadata_options());
     if preflight != 0 {
         let handle = crate::js_net_socket_alloc();
         extern "C" {
@@ -861,7 +880,7 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
         }
         js_tls_client_record_start(
             handle,
-            metadata_options,
+            metadata_options(),
             servername.as_ptr(),
             servername.len(),
         );
@@ -885,14 +904,14 @@ pub unsafe extern "C" fn js_tls_connect(arg1: f64, arg2: f64, arg3: f64, arg4: f
             }
             js_tls_client_record_start(
                 handle,
-                metadata_options,
+                metadata_options(),
                 metadata_servername.as_ptr(),
                 metadata_servername.len(),
             );
         });
-    if let Some(cb) = cb_f64 {
+    if let Some(index) = callback_arg {
         if handle != 0 {
-            let cb_ptr = unbox_pointer(cb) as i64;
+            let cb_ptr = unbox_pointer(rooted_args[index].get()) as i64;
             if cb_ptr != 0 {
                 statics::listeners()
                     .lock()

crates/perry-runtime/src/intl.rs

@@ -33,6 +33,8 @@ mod locale;
 mod locales;
 use locales::{get_canonical_locales_thunk, supported_values_of_thunk};
 mod date_collator;
+mod date_time_locale;
+use date_time_locale::resolve_date_time_locale;
 mod date_names;
 #[cfg(feature = "intl-datetime")]
 pub(crate) mod icu_dtf;
@@ -1089,20 +1091,16 @@ fn make_instance(closure: *const ClosureHeader, kind: &str, locales: f64, option
                 &["lookup", "best fit"],
                 "best fit",
             );
-            // `calendar` must match the Unicode locale `type` nonterminal; store
-            // the canonicalized ID so `resolvedOptions().calendar` reflects it.
-            if let Some(calendar) = get_locale_extension_option(current_options(), "calendar") {
-                match canonicalize_calendar_id(&calendar) {
-                    Some(canonical) => set_internal_field_from_raw_handle(
-                        &obj_handle,
-                        KEY_CALENDAR,
-                        string_value(&canonical),
-                    ),
-                    None => throw_range_error(&format!(
-                        "Value {calendar} out of range for Intl options property calendar"
-                    )),
-                }
-            }
+            // `calendar` must match the Unicode locale `type` nonterminal.
+            // Unsupported well-formed values fall through ResolveLocale.
+            let calendar_option =
+                get_locale_extension_option(current_options(), "calendar").map(|calendar| {
+                    canonicalize_calendar_id(&calendar).unwrap_or_else(|| {
+                        throw_range_error(&format!(
+                            "Value {calendar} out of range for Intl options property calendar"
+                        ))
+                    })
+                });
             // `numberingSystem` must be a well-formed `type` nonterminal. Read
             // it here (preserving the GetOption order options-order.js asserts),
             // then run ResolveLocale for `nu` — reconciling the option with the
@@ -1117,25 +1115,43 @@ fn make_instance(closure: *const ClosureHeader, kind: &str, locales: f64, option
                     }
                     ns.to_ascii_lowercase()
                 });
-            let (dtf_locale, dtf_numbering) =
-                resolve_numbering_system(&locale, dtf_opt_ns.as_deref());
-            set_internal_field_from_raw_handle(&obj_handle, KEY_LOCALE, string_value(&dtf_locale));
-            set_internal_field_from_raw_handle(
-                &obj_handle,
-                KEY_NUMBERING_SYSTEM,
-                string_value(&dtf_numbering),
-            );
             // hour12 (boolean) then hourCycle (enum) — both only surface in
             // `resolvedOptions` when the resolved pattern has an hour field.
-            if let Some(h12) = get_bool_option(current_options(), "hour12") {
-                set_internal_field_from_raw_handle(&obj_handle, KEY_HOUR12, bool_value(h12));
-            }
-            if let Some(hc) = get_option_string(current_options(), "hourCycle") {
+            let hour12 = get_bool_option(current_options(), "hour12");
+            let hour_cycle_option = get_option_string(current_options(), "hourCycle");
+            if let Some(ref hc) = hour_cycle_option {
                 if !["h11", "h12", "h23", "h24"].contains(&hc.as_str()) {
                     throw_range_error(&format!(
                         "Value {hc} out of range for Intl options property hourCycle"
                     ));
                 }
+            }
+            let resolved = resolve_date_time_locale(
+                &locale,
+                calendar_option.as_deref(),
+                dtf_opt_ns.as_deref(),
+                hour12,
+                hour_cycle_option.as_deref(),
+            );
+            set_internal_field_from_raw_handle(
+                &obj_handle,
+                KEY_LOCALE,
+                string_value(&resolved.locale),
+            );
+            set_internal_field_from_raw_handle(
+                &obj_handle,
+                KEY_CALENDAR,
+                string_value(&resolved.calendar),
+            );
+            set_internal_field_from_raw_handle(
+                &obj_handle,
+                KEY_NUMBERING_SYSTEM,
+                string_value(&resolved.numbering_system),
+            );
+            if let Some(h12) = hour12 {
+                set_internal_field_from_raw_handle(&obj_handle, KEY_HOUR12, bool_value(h12));
+            }
+            if let Some(hc) = resolved.hour_cycle {
                 set_internal_field_from_raw_handle(&obj_handle, KEY_HOUR_CYCLE, string_value(&hc));
             }
             // ECMA-402 DefaultTimeZone(): when no `timeZone` option is given, use