merge temporal_intrinsic into duration-and-durationproto

Author: sebastianjacmatt

nova_vm/src/builtin_strings

@@ -39,6 +39,7 @@ any
 apply
 arguments
 Array
+#[cfg(feature="temporal")]auto
 Array Iterator
 #[cfg(feature = "array-buffer")]ArrayBuffer
 #[cfg(feature = "math")]asin
@@ -138,6 +139,7 @@ find
 findIndex
 findLast
 findLastIndex
+#[cfg(feature = "temporal")]fractionalSecondDigits
 #[cfg(feature = "annex-b-string")]fixed
 #[cfg(feature = "regexp")]flags
 flat
@@ -452,6 +454,7 @@ SyntaxError
 #[cfg(feature = "regexp")]test
 then
 throw
+#[cfg(feature = "temporal")]timeZone
 toArray
 #[cfg(feature = "date")]toDateString
 toExponential

nova_vm/src/ecmascript/builtins/temporal.rs

@@ -12,13 +12,14 @@ use temporal_rs::options::{DifferenceSettings, RoundingIncrement, RoundingMode,
 
 use crate::{
     ecmascript::{
+        abstract_operations::operations_on_objects::get,
         builders::ordinary_object_builder::OrdinaryObjectBuilder,
         builtins::temporal::{
             instant::instant_prototype::get_temporal_unit_valued_option,
             options::{get_rounding_increment_option, get_rounding_mode_option},
         },
-        execution::{Agent, JsResult, Realm},
-        types::{BUILTIN_STRING_MEMORY, IntoValue, Object},
+        execution::{Agent, JsResult, Realm, agent::ExceptionType},
+        types::{BUILTIN_STRING_MEMORY, IntoValue, Number, Object, Value},
     },
     engine::{
         context::{Bindable, GcScope, NoGcScope, trivially_bindable},
@@ -93,6 +94,78 @@ trivially_bindable!(Unit);
 trivially_bindable!(RoundingMode);
 trivially_bindable!(RoundingIncrement);
 
+/// [13.15 GetTemporalFractionalSecondDigitsOption ( options )](https://tc39.es/proposal-temporal/#sec-temporal-gettemporalfractionalseconddigitsoption)
+/// The abstract operation GetTemporalFractionalSecondDigitsOption takes argument
+/// options (an Object) and returns either a normal completion containing
+/// either auto or an integer in the inclusive interval from 0 to 9,
+/// or a throw completion. It fetches and validates the "fractionalSecondDigits"
+/// property from options, returning a default if absent.
+pub(crate) fn get_temporal_fractional_second_digits_option<'gc>(
+    agent: &mut Agent,
+    options: Object<'gc>,
+    mut gc: GcScope<'gc, '_>,
+) -> JsResult<'gc, Value<'gc>> {
+    let options = options.bind(gc.nogc());
+    // 1. Let digitsValue be ? Get(options, "fractionalSecondDigits").
+    let digits_value = get(
+        agent,
+        options.unbind(),
+        BUILTIN_STRING_MEMORY
+            .fractionalSecondDigits
+            .to_property_key(),
+        gc.reborrow(),
+    )
+    .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());
+    }
+    let digits_value = digits_value.unbind();
+    // 3. If digitsValue is not a Number, then
+    if !digits_value.is_number() {
+        // a. If ? ToString(digitsValue) is not "auto", throw a RangeError exception.
+        if digits_value
+            .to_string(agent, gc.reborrow())
+            .unbind()?
+            .as_bytes(agent)
+            != b"auto"
+        {
+            // b. Return auto.
+            return Ok(BUILTIN_STRING_MEMORY.auto.into_value());
+        }
+    }
+    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)
+        || digits_value.is_pos_infinity(agent)
+        || digits_value.is_neg_infinity(agent)
+    {
+        return Err(agent.throw_exception_with_static_message(
+            ExceptionType::RangeError,
+            "fractionalSecondDigits must be a finite number or \"auto\"",
+            gc.into_nogc(),
+        ));
+    }
+    // 5. Let digitCount be floor(ℝ(digitsValue)).
+    let digit_count = digits_value
+        .unbind()
+        .to_number(agent, gc.reborrow())
+        .unbind()?
+        .bind(gc.nogc());
+    let digit_count = digit_count.into_f64(agent).floor() as i32;
+    // 6. If digitCount < 0 or digitCount > 9, throw a RangeError exception.
+    if digit_count < 0 || digit_count > 9 {
+        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())
+}
+
 /// [13.42 GetDifferenceSettings ( operation, options, unitGroup, disallowedUnits, fallbackSmallestUnit, smallestLargestDefaultUnit )](https://tc39.es/proposal-temporal/#sec-temporal-getdifferencesettings)
 /// The abstract operation GetDifferenceSettings takes arguments operation (since or until),
 /// options (an Object), unitGroup (date, time, or datetime), disallowedUnits (a List of Temporal units),

nova_vm/src/ecmascript/builtins/temporal/duration.rs

@@ -450,11 +450,13 @@ pub(crate) fn to_temporal_partial_duration_record<'gc>(
 /// It returns a new Temporal.Duration instance that is the
 /// negation of duration.
 pub(crate) fn create_negated_temporal_duration<'gc>(
-    _agent: &mut Agent,
-    _item: temporal_rs::Duration,
+    agent: &mut Agent,
+    item: temporal_rs::Duration,
     mut _gc: GcScope<'gc, '_>,
 ) -> JsResult<'gc, temporal_rs::Duration> {
     // 1. Return ! CreateTemporalDuration(-duration.[[Years]], -duration.[[Months]], -duration.[[Weeks]], -duration.[[Days]], -duration.[[Hours]], -duration.[[Minutes]], -duration.[[Seconds]], -duration.[[Milliseconds]], -duration.[[Microseconds]], -duration.[[Nanoseconds]]).
+    let _duration = temporal_rs::Duration::negated(&item);
+    //TODO: IMPL create_temporal_duration()
     unimplemented!()
 }
 

nova_vm/src/ecmascript/builtins/temporal/instant/instant_prototype.rs

@@ -3,14 +3,16 @@ use temporal_rs::options::{RoundingMode, RoundingOptions, Unit};
 use crate::{
     ecmascript::{
         abstract_operations::{
-            operations_on_objects::try_create_data_property_or_throw, type_conversion::to_number,
+            operations_on_objects::{get, try_create_data_property_or_throw},
+            type_conversion::to_number,
         },
         builders::ordinary_object_builder::OrdinaryObjectBuilder,
         builtins::{
             ArgumentsList, Behaviour, Builtin, BuiltinGetter,
             ordinary::ordinary_object_create_with_intrinsics,
             temporal::{
                 error::temporal_err_to_js_err,
+                get_temporal_fractional_second_digits_option,
                 instant::{
                     add_duration_to_instant, create_temporal_instant, difference_temporal_instant,
                     require_internal_slot_temporal_instant, to_temporal_instant,
@@ -408,11 +410,76 @@ impl TemporalInstantPrototype {
 
     /// ### [8.3.11 Temporal.Instant.prototype.toString ( [ options ] )](https://tc39.es/proposal-temporal/#sec-temporal.instant.prototype.tostring)
     fn to_string<'gc>(
-        _agent: &mut Agent,
-        _this_value: Value,
-        _args: ArgumentsList,
-        mut _gc: GcScope<'gc, '_>,
+        agent: &mut Agent,
+        this_value: Value,
+        args: ArgumentsList,
+        mut gc: GcScope<'gc, '_>,
     ) -> JsResult<'gc, Value<'gc>> {
+        // 1. Let instant be the this value.
+        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())
+            .unbind()?
+            .bind(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").
+        // 5. Let digits be ? GetTemporalFractionalSecondDigitsOption(resolvedOptions).
+        let digits = get_temporal_fractional_second_digits_option(
+            agent,
+            resolved_options.get(agent),
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        // 6. Let roundingMode be ? GetRoundingModeOption(resolvedOptions, trunc).
+        let rounding_mode = get_rounding_mode_option(
+            agent,
+            resolved_options.get(agent),
+            RoundingMode::Trunc,
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        // 7. Let smallestUnit be ? GetTemporalUnitValuedOption(resolvedOptions, "smallestUnit", unset).
+        let smallest_unit = get_temporal_unit_valued_option(
+            agent,
+            resolved_options.get(agent),
+            BUILTIN_STRING_MEMORY.smallestUnit.to_property_key(),
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        // 8. Let timeZone be ? Get(resolvedOptions, "timeZone").
+        let tz = get(
+            agent,
+            resolved_options.get(agent),
+            BUILTIN_STRING_MEMORY.timeZone.to_property_key(),
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        // 9. Perform ? ValidateTemporalUnitValue(smallestUnit, time).
+        // 10. If smallestUnit is hour, throw a RangeError exception.
+        if smallest_unit.unwrap() == 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() {
+            // a. Set timeZone to ? ToTemporalTimeZoneIdentifier(timeZone).
+            todo!()
+        };
+        // 12. Let precision be ToSecondsStringPrecisionRecord(smallestUnit, digits).
+        // 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!()
     }