typedarray: preserve observable toLocaleString semantics while keeping shared NumberFormat optimization

Signed-off-by: mrhapile <allinonegaming3456@gmail.com>

Author: mrhapile

core/engine/src/builtins/number/mod.rs

@@ -48,6 +48,19 @@ pub(crate) struct Number;
 
 impl IntrinsicObject for Number {
     fn init(realm: &Realm) {
+        let to_locale_string_function = BuiltInBuilder::callable_with_object(
+            realm,
+            realm
+                .intrinsics()
+                .objects()
+                .number_prototype_to_locale_string()
+                .into(),
+            Self::to_locale_string,
+        )
+        .name(js_string!("toLocaleString"))
+        .length(0)
+        .build();
+
         let attribute = Attribute::READONLY | Attribute::NON_ENUMERABLE | Attribute::PERMANENT;
 
         BuiltInBuilder::from_standard_constructor::<Self>(realm)
@@ -87,7 +100,11 @@ impl IntrinsicObject for Number {
             .static_method(Self::number_is_integer, js_string!("isInteger"), 1)
             .method(Self::to_exponential, js_string!("toExponential"), 1)
             .method(Self::to_fixed, js_string!("toFixed"), 1)
-            .method(Self::to_locale_string, js_string!("toLocaleString"), 0)
+            .property(
+                js_string!("toLocaleString"),
+                to_locale_string_function,
+                Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
+            )
             .method(Self::to_precision, js_string!("toPrecision"), 1)
             .method(Self::to_string, js_string!("toString"), 1)
             .method(Self::value_of, js_string!("valueOf"), 0)

core/engine/src/builtins/typed_array/builtin.rs

@@ -2523,6 +2523,22 @@ impl BuiltinTypedArray {
 
         let call_args = [locales, options];
 
+        #[cfg(feature = "intl")]
+        let is_unmodified = {
+            let number_proto = context.intrinsics().constructors().number().prototype();
+
+            let current_tls = number_proto.get(js_string!("toLocaleString"), context)?;
+
+            let builtin_tls = context
+                .intrinsics()
+                .objects()
+                .number_prototype_to_locale_string();
+
+            current_tls
+                .as_object()
+                .is_some_and(|o| JsObject::equals(&o, &builtin_tls.into()))
+        };
+
         // 5. Let k be 0.
         // 6. Repeat, while k < len,
         for k in 0..len {
@@ -2537,21 +2553,35 @@ impl BuiltinTypedArray {
             }
 
             #[cfg(feature = "intl")]
-            if is_bigint {
-                let s = next_element
-                    .invoke(js_string!("toLocaleString"), &call_args, context)?
-                    .to_string(context)?;
-                r.push(s);
-            } else {
-                use crate::builtins::intl::number_format::to_intl_mathematical_value;
-                let mut x = to_intl_mathematical_value(&next_element, context)?;
-                r.push(js_string!(
-                    number_format
-                        .as_ref()
-                        .expect("number_format should be initialized for numeric typed arrays")
-                        .format(&mut x)
-                        .to_string()
-                ));
+            {
+                use crate::{
+                    builtins::intl::number_format::to_intl_mathematical_value, value::JsVariant,
+                };
+
+                // Fast path: finite primitive numbers only
+                let use_fast_path = is_unmodified
+                    && match next_element.variant() {
+                        JsVariant::Integer32(_) => !is_bigint,
+                        JsVariant::Float64(f) => !is_bigint && f.is_finite(),
+                        _ => false,
+                    };
+
+                if use_fast_path {
+                    let mut x = to_intl_mathematical_value(&next_element, context)?;
+                    r.push(js_string!(
+                        number_format
+                            .as_ref()
+                            .expect("number_format is Some for numeric typed arrays")
+                            .format(&mut x)
+                            .to_string()
+                    ));
+                } else {
+                    // Slow path: delegate to element.toLocaleString()
+                    let s = next_element
+                        .invoke(js_string!("toLocaleString"), &call_args, context)?
+                        .to_string(context)?;
+                    r.push(s);
+                }
             }
 
             #[cfg(not(feature = "intl"))]
@@ -2566,7 +2596,7 @@ impl BuiltinTypedArray {
         // 7. Return R.
         let separator = js_string!(", ");
         let mut result = Vec::with_capacity(
-            r.iter().map(boa_string::JsString::len).sum::<usize>()
+            r.iter().map(JsString::len).sum::<usize>()
                 + separator.len() * (len.saturating_sub(1) as usize),
         );
         for (i, s) in r.into_iter().enumerate() {

core/engine/src/context/intrinsics.rs

@@ -1086,6 +1086,9 @@ pub struct IntrinsicObjects {
     /// [`%Array.prototype.toString%`](https://tc39.es/ecma262/#sec-array.prototype.tostring)
     array_prototype_to_string: JsFunction,
 
+    /// [`%Number.prototype.toLocaleString%`](https://tc39.es/ecma262/#sec-number.prototype.tolocalestring)
+    number_prototype_to_locale_string: JsFunction,
+
     /// Cached iterator prototypes.
     iterator_prototypes: IteratorPrototypes,
 
@@ -1158,6 +1161,7 @@ impl IntrinsicObjects {
             throw_type_error: JsFunction::empty_intrinsic_function(false),
             array_prototype_values: JsFunction::empty_intrinsic_function(false),
             array_prototype_to_string: JsFunction::empty_intrinsic_function(false),
+            number_prototype_to_locale_string: JsFunction::empty_intrinsic_function(false),
             iterator_prototypes: IteratorPrototypes::default(),
             generator: JsObject::with_null_proto(),
             async_generator: JsObject::with_null_proto(),
@@ -1210,6 +1214,15 @@ impl IntrinsicObjects {
         self.array_prototype_to_string.clone()
     }
 
+    /// Gets the [`%Number.prototype.toLocaleString%`][spec] intrinsic function.
+    ///
+    /// [spec]: https://tc39.es/ecma262/#sec-number.prototype.tolocalestring
+    #[inline]
+    #[must_use]
+    pub fn number_prototype_to_locale_string(&self) -> JsFunction {
+        self.number_prototype_to_locale_string.clone()
+    }
+
     /// Gets the cached iterator prototypes.
     #[inline]
     #[must_use]