feat(intl): implement Date.prototype.toLocaleString, toLocaleDateString, and toLocaleTimeString

Author: alienx5499

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

@@ -8,7 +8,7 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
 
 use crate::{
-    Context, JsArgs, JsData, JsError, JsResult, JsString,
+    Context, JsArgs, JsData, JsResult, JsString,
     builtins::{
         BuiltInBuilder, BuiltInConstructor, BuiltInObject, IntrinsicObject,
         date::utils::{
@@ -1608,6 +1608,15 @@ impl Date {
         func.call(this, &[], context)
     }
 
+    /// Returns the `[[DateValue]]` internal slot (RequireInternalSlot(dateObject, `[[DateValue]]`)).
+    fn this_date_value(this: &JsValue) -> JsResult<f64> {
+        this.as_object()
+            .and_then(|obj| obj.downcast_ref::<Date>().as_deref().copied())
+            .ok_or_else(|| JsNativeError::typ().with_message("'this' is not a Date"))
+            .map(|d| d.0)
+            .map_err(Into::into)
+    }
+
     /// [`Date.prototype.toLocaleDateString()`][spec].
     ///
     /// The `toLocaleDateString()` method returns the date portion of the given Date instance according
@@ -1616,16 +1625,47 @@ impl Date {
     /// More information:
     ///  - [MDN documentation][mdn]
     ///
-    /// [spec]: https://tc39.es/ecma262/#sec-date.prototype.tolocaledatestring
+    /// [spec]: https://tc39.es/ecma402/#sup-date.prototype.tolocaledatestring
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
+    #[allow(
+        unused_variables,
+        reason = "`args` and `context` are used when the `intl` feature is enabled"
+    )]
     pub(crate) fn to_locale_date_string(
-        _this: &JsValue,
-        _args: &[JsValue],
-        _context: &mut Context,
+        this: &JsValue,
+        args: &[JsValue],
+        context: &mut Context,
     ) -> JsResult<JsValue> {
-        Err(JsError::from_opaque(JsValue::new(js_string!(
-            "Function Unimplemented"
-        ))))
+        // Let dateObject be the this value.
+        // Perform ? RequireInternalSlot(dateObject, [[DateValue]]).
+        // Let x be dateObject.[[DateValue]].
+        let t = Self::this_date_value(this)?;
+        // If x is NaN, return "Invalid Date".
+        if t.is_nan() {
+            return Ok(JsValue::new(js_string!("Invalid Date")));
+        }
+        // Let dateFormat be ? CreateDateTimeFormat(%Intl.DateTimeFormat%, locales, options, date, date).
+        // Return ! FormatDateTime(dateFormat, x).
+        #[cfg(feature = "intl")]
+        {
+            use crate::builtins::intl::date_time_format::{
+                FormatDefaults, FormatType, format_date_time_locale,
+            };
+            let locales = args.get_or_undefined(0);
+            let options = args.get_or_undefined(1);
+            format_date_time_locale(
+                locales,
+                options,
+                FormatType::Date,
+                FormatDefaults::Date,
+                t,
+                context,
+            )
+        }
+        #[cfg(not(feature = "intl"))]
+        {
+            Self::to_string(this, &[], context)
+        }
     }
 
     /// [`Date.prototype.toLocaleString()`][spec].
@@ -1635,16 +1675,47 @@ impl Date {
     /// More information:
     ///  - [MDN documentation][mdn]
     ///
-    /// [spec]: https://tc39.es/ecma262/#sec-date.prototype.tolocalestring
+    /// [spec]: https://tc39.es/ecma402/#sup-date.prototype.tolocalestring
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+    #[allow(
+        unused_variables,
+        reason = "`args` and `context` are used when the `intl` feature is enabled"
+    )]
     pub(crate) fn to_locale_string(
-        _this: &JsValue,
-        _: &[JsValue],
-        _context: &mut Context,
+        this: &JsValue,
+        args: &[JsValue],
+        context: &mut Context,
     ) -> JsResult<JsValue> {
-        Err(JsError::from_opaque(JsValue::new(js_string!(
-            "Function Unimplemented]"
-        ))))
+        // Let dateObject be the this value.
+        // Perform ? RequireInternalSlot(dateObject, [[DateValue]]).
+        // Let x be dateObject.[[DateValue]].
+        let t = Self::this_date_value(this)?;
+        // If x is NaN, return "Invalid Date".
+        if t.is_nan() {
+            return Ok(JsValue::new(js_string!("Invalid Date")));
+        }
+        // Let dateFormat be ? CreateDateTimeFormat(%Intl.DateTimeFormat%, locales, options, any, all).
+        // Return ! FormatDateTime(dateFormat, x).
+        #[cfg(feature = "intl")]
+        {
+            use crate::builtins::intl::date_time_format::{
+                FormatDefaults, FormatType, format_date_time_locale,
+            };
+            let locales = args.get_or_undefined(0);
+            let options = args.get_or_undefined(1);
+            format_date_time_locale(
+                locales,
+                options,
+                FormatType::Any,
+                FormatDefaults::All,
+                t,
+                context,
+            )
+        }
+        #[cfg(not(feature = "intl"))]
+        {
+            Self::to_string(this, &[], context)
+        }
     }
 
     /// [`Date.prototype.toLocaleTimeString()`][spec].
@@ -1655,16 +1726,47 @@ impl Date {
     /// More information:
     ///  - [MDN documentation][mdn]
     ///
-    /// [spec]: https://tc39.es/ecma262/#sec-date.prototype.tolocaletimestring
+    /// [spec]: https://tc39.es/ecma402/#sup-date.prototype.tolocaletimestring
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+    #[allow(
+        unused_variables,
+        reason = "`args` and `context` are used when the `intl` feature is enabled"
+    )]
     pub(crate) fn to_locale_time_string(
-        _this: &JsValue,
-        _args: &[JsValue],
-        _context: &mut Context,
+        this: &JsValue,
+        args: &[JsValue],
+        context: &mut Context,
     ) -> JsResult<JsValue> {
-        Err(JsError::from_opaque(JsValue::new(js_string!(
-            "Function Unimplemented]"
-        ))))
+        // Let dateObject be the this value.
+        // Perform ? RequireInternalSlot(dateObject, [[DateValue]]).
+        // Let x be dateObject.[[DateValue]].
+        let t = Self::this_date_value(this)?;
+        // If x is NaN, return "Invalid Date".
+        if t.is_nan() {
+            return Ok(JsValue::new(js_string!("Invalid Date")));
+        }
+        // Let timeFormat be ? CreateDateTimeFormat(%Intl.DateTimeFormat%, locales, options, time, time).
+        // Return ! FormatDateTime(timeFormat, x).
+        #[cfg(feature = "intl")]
+        {
+            use crate::builtins::intl::date_time_format::{
+                FormatDefaults, FormatType, format_date_time_locale,
+            };
+            let locales = args.get_or_undefined(0);
+            let options = args.get_or_undefined(1);
+            format_date_time_locale(
+                locales,
+                options,
+                FormatType::Time,
+                FormatDefaults::Time,
+                t,
+                context,
+            )
+        }
+        #[cfg(not(feature = "intl"))]
+        {
+            Self::to_string(this, &[], context)
+        }
     }
 
     /// [`Date.prototype.toString()`][spec].

core/engine/src/builtins/date/tests.rs

@@ -943,3 +943,52 @@ fn date_parse_hour24_validation() {
         TestAction::assert("isNaN(Date.parse('2024-01-01T24:00:00.001Z'))"),
     ]);
 }
+
+#[test]
+#[cfg(feature = "intl")]
+fn date_proto_to_locale_string_intl() {
+    run_test_actions([
+        // Invalid receiver: spec requires TypeError
+        TestAction::assert_native_error(
+            "Date.prototype.toLocaleString.call({})",
+            JsNativeErrorKind::Type,
+            "'this' is not a Date",
+        ),
+        TestAction::assert_native_error(
+            "Date.prototype.toLocaleDateString.call({})",
+            JsNativeErrorKind::Type,
+            "'this' is not a Date",
+        ),
+        TestAction::assert_native_error(
+            "Date.prototype.toLocaleTimeString.call({})",
+            JsNativeErrorKind::Type,
+            "'this' is not a Date",
+        ),
+        TestAction::assert_eq("new Date(NaN).toLocaleString()", js_str!("Invalid Date")),
+        TestAction::assert("typeof new Date(2020, 6, 8).toLocaleString() === 'string'"),
+        TestAction::assert("typeof new Date(2020, 6, 8).toLocaleDateString() === 'string'"),
+        TestAction::assert("typeof new Date(2020, 6, 8).toLocaleTimeString() === 'string'"),
+        TestAction::assert("typeof new Date(0).toLocaleString('en-US') === 'string'"),
+        TestAction::assert("typeof new Date(0).toLocaleDateString('en-US') === 'string'"),
+        TestAction::assert("typeof new Date(0).toLocaleDateString('de-DE') === 'string'"),
+        TestAction::assert("typeof new Date(0).toLocaleTimeString('en-US') === 'string'"),
+        // Prove locale pipeline: different locales produce different output
+        TestAction::assert(
+            "new Date(0).toLocaleDateString('en-US') !== new Date(0).toLocaleDateString('de-DE')",
+        ),
+        TestAction::assert(
+            "new Date(0).toLocaleString('en-US') !== new Date(0).toLocaleString('de-DE')",
+        ),
+        TestAction::assert(
+            "new Date(0).toLocaleTimeString('en-US') !== new Date(0).toLocaleTimeString('de-DE')",
+        ),
+        // Prove ToDateTimeOptions pipeline: options affect output
+        TestAction::assert(
+            "typeof new Date(0).toLocaleDateString('en-US', { dateStyle: 'short' }) === 'string'",
+        ),
+        // Prove output is a string and not empty
+        TestAction::assert(
+            "new Date(0).toLocaleDateString('en-US', { dateStyle: 'short' }).length > 0",
+        ),
+    ]);
+}

core/engine/src/builtins/intl/date_time_format/mod.rs

@@ -551,7 +551,7 @@ impl ToLocalTime {
 
 // ==== Abstract Operations ====
 
-fn create_date_time_format(
+pub(crate) fn create_date_time_format(
     new_target: &JsValue,
     locales: &JsValue,
     options: &JsValue,
@@ -807,13 +807,13 @@ fn create_date_time_format(
         // 2. If value is not undefined, set needDefaults to false.
         let needs_defaults = format_options.check_dtf_type(date_time_format_type);
         // d. If needDefaults is true and defaults is either date or all, then
-        if needs_defaults && defaults != FormatDefaults::Time {
+        if needs_defaults && (defaults == FormatDefaults::All || defaults == FormatDefaults::Date) {
             // i. For each property name prop of « "year", "month", "day" », do
             // 1. Set formatOptions.[[<prop>]] to "numeric".
             format_options.set_date_defaults();
         }
         // e. If needDefaults is true and defaults is either time or all, then
-        if needs_defaults && defaults != FormatDefaults::Date {
+        if needs_defaults && (defaults == FormatDefaults::All || defaults == FormatDefaults::Time) {
             // i. For each property name prop of « "hour", "minute", "second" », do
             // 1. Set formatOptions.[[<prop>]] to "numeric".
             format_options.set_time_defaults();
@@ -911,10 +911,14 @@ pub(crate) enum FormatType {
     Any,
 }
 
+/// Indicates which default fields should be applied when `ToDateTimeOptions`
+/// determines defaults are needed. `All` applies both date and time defaults.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub(crate) enum FormatDefaults {
     Date,
     Time,
+    /// Apply both date and time defaults (e.g. for `toLocaleString`).
+    All,
 }
 
 /// Abstract operation [`UnwrapDateTimeFormat ( dtf )`][spec].
@@ -967,3 +971,57 @@ fn unwrap_date_time_format(
         .with_message("object was not an `Intl.DateTimeFormat` object")
         .into())
 }
+
+/// Shared helper used by Date.prototype.toLocaleString,
+/// Date.prototype.toLocaleDateString, and Date.prototype.toLocaleTimeString.
+/// Applies `ToDateTimeOptions` defaults, constructs `Intl.DateTimeFormat`,
+/// and formats the provided timestamp.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn format_date_time_locale(
+    locales: &JsValue,
+    options: &JsValue,
+    format_type: FormatType,
+    defaults: FormatDefaults,
+    timestamp: f64,
+    context: &mut Context,
+) -> JsResult<JsValue> {
+    let options = coerce_options_to_object(options, context)?;
+    if format_type != FormatType::Time
+        && get_option::<DateStyle>(&options, js_string!("dateStyle"), context)?.is_none()
+    {
+        options.create_data_property_or_throw(
+            js_string!("dateStyle"),
+            JsValue::from(js_string!("long")),
+            context,
+        )?;
+    }
+    if format_type != FormatType::Date
+        && get_option::<TimeStyle>(&options, js_string!("timeStyle"), context)?.is_none()
+    {
+        options.create_data_property_or_throw(
+            js_string!("timeStyle"),
+            JsValue::from(js_string!("long")),
+            context,
+        )?;
+    }
+    let new_target = context
+        .intrinsics()
+        .constructors()
+        .date_time_format()
+        .constructor()
+        .into();
+    let options_value = options.into();
+    let dtf = create_date_time_format(
+        &new_target,
+        locales,
+        &options_value,
+        format_type,
+        defaults,
+        context,
+    )?;
+    let format_val = dtf.get(js_string!("format"), context)?;
+    let format_fn = format_val
+        .as_callable()
+        .ok_or_else(|| JsNativeError::typ().with_message("format is not callable"))?;
+    format_fn.call(&dtf.into(), &[JsValue::from(timestamp)], context)
+}