fix: finish Temporal.Instant.prototype.toString impl

aapoalas · aapoalas · commit 93a45c05c03b · 2025-11-27T12:04:40.000+02:00
diff --git a/nova_vm/src/ecmascript/builtins/temporal.rs b/nova_vm/src/ecmascript/builtins/temporal.rs
@@ -8,7 +8,10 @@ pub mod instant;
 pub mod options;
 pub mod plain_time;
 
-use temporal_rs::options::{DifferenceSettings, RoundingIncrement, RoundingMode, Unit, UnitGroup};
+use temporal_rs::{
+    options::{DifferenceSettings, RoundingIncrement, RoundingMode, Unit, UnitGroup},
+    parsers::Precision,
+};
 
 use crate::{
     ecmascript::{
@@ -41,7 +44,7 @@ impl Temporal {
         let plain_time_constructor = intrinsics.temporal_plain_time();
 
         OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
-            .with_property_capacity(3)
+            .with_property_capacity(4)
             .with_prototype(object_prototype)
             // 1.2.1 Temporal.Instant ( . . . )
             .with_property(|builder| {
@@ -93,6 +96,7 @@ trivially_bindable!(UnitGroup);
 trivially_bindable!(Unit);
 trivially_bindable!(RoundingMode);
 trivially_bindable!(RoundingIncrement);
+trivially_bindable!(Precision);
 
 /// [13.15 GetTemporalFractionalSecondDigitsOption ( options )](https://tc39.es/proposal-temporal/#sec-temporal-gettemporalfractionalseconddigitsoption)
 /// The abstract operation GetTemporalFractionalSecondDigitsOption takes argument
@@ -104,10 +108,10 @@ pub(crate) fn get_temporal_fractional_second_digits_option<'gc>(
     agent: &mut Agent,
     options: Object<'gc>,
     mut gc: GcScope<'gc, '_>,
-) -> JsResult<'gc, Value<'gc>> {
+) -> JsResult<'gc, temporal_rs::parsers::Precision> {
     let options = options.bind(gc.nogc());
     // 1. Let digitsValue be ? Get(options, "fractionalSecondDigits").
-    let digits_value = get(
+    let mut digits_value = get(
         agent,
         options.unbind(),
         BUILTIN_STRING_MEMORY
@@ -118,26 +122,35 @@ pub(crate) fn get_temporal_fractional_second_digits_option<'gc>(
     .unbind()?
     .bind(gc.nogc());
     // 2. If digitsValue is undefined, return auto.
-    if digits_value.unbind().is_undefined().bind(gc.nogc()) {
-        return Ok(BUILTIN_STRING_MEMORY.auto.into_value());
+    if digits_value.is_undefined() {
+        return Ok(temporal_rs::parsers::Precision::Auto);
+    }
+    if let Value::Integer(digits_value) = digits_value
+        && (0..=9).contains(&digits_value.into_i64())
+    {
+        return Ok(temporal_rs::parsers::Precision::Digit(
+            digits_value.into_i64() as u8,
+        ));
     }
-    let digits_value = digits_value.unbind();
     // 3. If digitsValue is not a Number, then
     if !digits_value.is_number() {
+        let scoped_digits_value = digits_value.scope(agent, gc.nogc());
         // a. If ? ToString(digitsValue) is not "auto", throw a RangeError exception.
         if digits_value
+            .unbind()
             .to_string(agent, gc.reborrow())
             .unbind()?
             .as_bytes(agent)
             != b"auto"
         {
             // b. Return auto.
-            return Ok(BUILTIN_STRING_MEMORY.auto.into_value());
+            return Ok(temporal_rs::parsers::Precision::Auto);
         }
+        // SAFETY: not shared.
+        digits_value = unsafe { scoped_digits_value.take(agent) }.bind(gc.nogc());
     }
-    let digits_value = digits_value.bind(gc.nogc());
     // 4. If digitsValue is NaN, +∞𝔽, or -∞𝔽, throw a RangeError exception.
-    if digits_value.unbind().is_nan(agent)
+    if digits_value.is_nan(agent)
         || digits_value.is_pos_infinity(agent)
         || digits_value.is_neg_infinity(agent)
     {
@@ -153,17 +166,17 @@ pub(crate) fn get_temporal_fractional_second_digits_option<'gc>(
         .to_number(agent, gc.reborrow())
         .unbind()?
         .bind(gc.nogc());
-    let digit_count = digit_count.into_f64(agent).floor() as i32;
+    let digit_count = digit_count.into_f64(agent).floor();
     // 6. If digitCount < 0 or digitCount > 9, throw a RangeError exception.
-    if digit_count < 0 || digit_count > 9 {
+    if digit_count < 0.0 || digit_count > 9.0 {
         return Err(agent.throw_exception_with_static_message(
             ExceptionType::RangeError,
             "fractionalSecondDigits must be between 0 and 9",
             gc.into_nogc(),
         ));
     }
     // 7. Return digitCount.
-    Ok(Number::from_i64(agent, digit_count.into(), gc.into_nogc()).into_value())
+    Ok(temporal_rs::parsers::Precision::Digit(digit_count as u8))
 }
 
 /// [13.42 GetDifferenceSettings ( operation, options, unitGroup, disallowedUnits, fallbackSmallestUnit, smallestLargestDefaultUnit )](https://tc39.es/proposal-temporal/#sec-temporal-getdifferencesettings)
diff --git a/nova_vm/src/ecmascript/builtins/temporal/duration/duration_constructor.rs b/nova_vm/src/ecmascript/builtins/temporal/duration/duration_constructor.rs
@@ -1,9 +1,7 @@
 use crate::{
     ecmascript::{
         builders::builtin_function_builder::BuiltinFunctionBuilder,
-        builtins::{
-            ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor
-        },
+        builtins::{ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor},
         execution::{Agent, JsResult, Realm},
         types::{BUILTIN_STRING_MEMORY, IntoObject, Object, String, Value},
     },
@@ -40,7 +38,7 @@ impl TemporalDurationConstructor {
         BuiltinFunctionBuilder::new_intrinsic_constructor::<TemporalDurationConstructor>(
             agent, realm,
         )
-        .with_property_capacity(5)
+        .with_property_capacity(1)
         .with_prototype_property(duration_prototype.into_object())
         .build();
     }
diff --git a/nova_vm/src/ecmascript/builtins/temporal/duration/duration_prototype.rs b/nova_vm/src/ecmascript/builtins/temporal/duration/duration_prototype.rs
@@ -12,12 +12,12 @@ pub(crate) struct TemporalDurationPrototype;
 impl TemporalDurationPrototype {
     pub fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>, _: NoGcScope) {
         let intrinsics = agent.get_realm_record_by_id(realm).intrinsics();
-        let this = intrinsics.temporal_instant_prototype();
+        let this = intrinsics.temporal_duration_prototype();
         let object_prototype = intrinsics.object_prototype();
         let duration_constructor = intrinsics.temporal_duration();
 
         OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
-            .with_property_capacity(15)
+            .with_property_capacity(2)
             .with_prototype(object_prototype)
             .with_constructor_property(duration_constructor)
             .with_property(|builder| {
diff --git a/nova_vm/src/ecmascript/builtins/temporal/instant/instant_prototype.rs b/nova_vm/src/ecmascript/builtins/temporal/instant/instant_prototype.rs
@@ -1,4 +1,7 @@
-use temporal_rs::options::{RoundingMode, RoundingOptions, Unit};
+use temporal_rs::{
+    TimeZone,
+    options::{RoundingMode, RoundingOptions, ToStringRoundingOptions, Unit},
+};
 
 use crate::{
     ecmascript::{
@@ -33,7 +36,7 @@ use crate::{
         context::{Bindable, GcScope, NoGcScope},
         rootable::Scopable,
     },
-    heap::WellKnownSymbolIndexes,
+    heap::{CreateHeapData, WellKnownSymbolIndexes},
 };
 
 pub(crate) struct TemporalInstantPrototype;
@@ -419,24 +422,27 @@ impl TemporalInstantPrototype {
         let options = args.get(0).bind(gc.nogc());
         let instant = this_value.bind(gc.nogc());
         // 2. Perform ? RequireInternalSlot(instant, [[InitializedTemporalInstant]]).
-        let _instant = require_internal_slot_temporal_instant(agent, instant.unbind(), gc.nogc())
+        let instant = require_internal_slot_temporal_instant(agent, instant.unbind(), gc.nogc())
             .unbind()?
-            .bind(gc.nogc());
+            .scope(agent, gc.nogc());
         // 3. Let resolvedOptions be ? GetOptionsObject(options).
         let resolved_options = get_options_object(agent, options.unbind(), gc.nogc())
             .unbind()?
             .scope(agent, gc.nogc());
-        // 4. NOTE: The following steps read options and perform independent validation in alphabetical order (GetTemporalFractionalSecondDigitsOption reads "fractionalSecondDigits" and GetRoundingModeOption reads "roundingMode").
+        // 4. NOTE: The following steps read options and perform independent
+        //    validation in alphabetical order
+        //    (GetTemporalFractionalSecondDigitsOption reads
+        //    "fractionalSecondDigits" and GetRoundingModeOption reads
+        //    "roundingMode").
         // 5. Let digits be ? GetTemporalFractionalSecondDigitsOption(resolvedOptions).
-        let _digits = get_temporal_fractional_second_digits_option(
+        let digits = get_temporal_fractional_second_digits_option(
             agent,
             resolved_options.get(agent),
             gc.reborrow(),
         )
-        .unbind()?
-        .bind(gc.nogc());
+        .unbind()?;
         // 6. Let roundingMode be ? GetRoundingModeOption(resolvedOptions, trunc).
-        let _rounding_mode = get_rounding_mode_option(
+        let rounding_mode = get_rounding_mode_option(
             agent,
             resolved_options.get(agent),
             RoundingMode::Trunc,
@@ -463,24 +469,50 @@ impl TemporalInstantPrototype {
         .unbind()?
         .bind(gc.nogc());
         // 9. Perform ? ValidateTemporalUnitValue(smallestUnit, time).
+        if !smallest_unit.is_none_or(|su| su.is_time_unit()) {
+            return Err(agent.throw_exception_with_static_message(
+                ExceptionType::RangeError,
+                "smallestUnit is not a valid time unit",
+                gc.into_nogc(),
+            ));
+        }
         // 10. If smallestUnit is hour, throw a RangeError exception.
-        if smallest_unit.unwrap() == Unit::Hour {
+        if smallest_unit == Some(Unit::Hour) {
             return Err(agent.throw_exception_with_static_message(
                 ExceptionType::RangeError,
                 "smallestUnit is hour",
                 gc.into_nogc(),
             ));
         }
         // 11. If timeZone is not undefined, then
-        let _tz = if !tz.is_undefined() {
+        let time_zone = if !tz.is_undefined() {
             // a. Set timeZone to ? ToTemporalTimeZoneIdentifier(timeZone).
-            todo!()
+            Some(TimeZone::utc())
+        } else {
+            None
         };
+        let instant = unsafe { instant.take(agent) }.bind(gc.nogc());
         // 12. Let precision be ToSecondsStringPrecisionRecord(smallestUnit, digits).
-        // 13. Let roundedNs be RoundTemporalInstant(instant.[[EpochNanoseconds]], precision.[[Increment]], precision.[[Unit]], roundingMode).
+        // 13. Let roundedNs be RoundTemporalInstant(
+        //       instant.[[EpochNanoseconds]],
+        //       precision.[[Increment]],
+        //       precision.[[Unit]],
+        //       roundingMode
+        //     ).
         // 14. Let roundedInstant be ! CreateTemporalInstant(roundedNs).
         // 15. Return TemporalInstantToString(roundedInstant, timeZone, precision.[[Precision]]).
-        unimplemented!()
+        let options = ToStringRoundingOptions {
+            precision: digits,
+            smallest_unit,
+            rounding_mode: Some(rounding_mode),
+        };
+        match instant
+            .inner_instant(agent)
+            .to_ixdtf_string(time_zone, options)
+        {
+            Ok(string) => Ok(Value::from_string(agent, string, gc.into_nogc())),
+            Err(err) => Err(temporal_err_to_js_err(agent, err, gc.into_nogc())),
+        }
     }
 
     /// ### [8.3.12 Temporal.Instant.prototype.toLocaleString ( [ locales [ , options ] ] )](https://tc39.es/proposal-temporal/#sec-temporal.instant.prototype.tolocalestring)
