Merge branch 'difference_temporal_instant' into temporal_intrinsic

Author: sebastianjacmatt

nova_vm/src/builtin_strings

@@ -259,6 +259,7 @@ isSealed
 isWellFormed
 #[cfg(feature = "annex-b-string")]italics
 #[cfg(feature = "temporal")]Instant
+#[cfg(feature = "temporal")]largestUnit
 Iterator
 iterator
 join

nova_vm/src/ecmascript/builtins/temporal.rs

@@ -8,13 +8,22 @@ pub mod instant;
 pub mod options;
 pub mod plain_time;
 
+use temporal_rs::options::{DifferenceSettings, RoundingMode, Unit, UnitGroup};
+
 use crate::{
     ecmascript::{
         builders::ordinary_object_builder::OrdinaryObjectBuilder,
-        execution::{Agent, Realm},
-        types::{BUILTIN_STRING_MEMORY, IntoValue},
+        builtins::temporal::{
+            instant::instant_prototype::{DefaultOption, get_temporal_unit_valued_option},
+            options::{get_rounding_increment_option, get_rounding_mode_option},
+        },
+        execution::{Agent, JsResult, Realm},
+        types::{BUILTIN_STRING_MEMORY, IntoValue, Object},
+    },
+    engine::{
+        context::{Bindable, GcScope, NoGcScope, trivially_bindable},
+        rootable::Scopable,
     },
-    engine::context::NoGcScope,
     heap::WellKnownSymbolIndexes,
 };
 
@@ -68,3 +77,89 @@ impl Temporal {
             .build();
     }
 }
+
+trivially_bindable!(DifferenceSettings);
+trivially_bindable!(UnitGroup);
+trivially_bindable!(Unit);
+
+/// [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),
+/// fallbackSmallestUnit (a Temporal unit), and smallestLargestDefaultUnit (a Temporal unit) and returns either
+/// a normal completion containing a Record with fields [[SmallestUnit]] (a Temporal unit),
+/// [[LargestUnit]] (a Temporal unit), [[RoundingMode]] (a rounding mode),
+/// and [[RoundingIncrement]] (an integer in the inclusive interval from 1 to 10**9),
+/// or a throw completion. It reads unit and rounding options needed by difference operations.
+pub(crate) fn get_difference_settings<'gc, const IS_UNTIL: bool>(
+    agent: &mut Agent,
+    options: Object<'gc>,                 // options (an Object)
+    _unit_group: UnitGroup,               // unitGroup (date, time, or datetime)
+    _disallowed_units: Vec<Unit>,         // disallowedUnits (todo:a List of Temporal units)
+    _fallback_smallest_unit: Unit,        // fallbackSmallestUnit (a Temporal unit)
+    _smallest_largest_default_unit: Unit, // smallestLargestDefaultUnit (a Temporal unit)
+    mut gc: GcScope<'gc, '_>,
+) -> JsResult<'gc, DifferenceSettings> {
+    let _unit_group = _unit_group.bind(gc.nogc());
+    let _disallowed_units = _disallowed_units.bind(gc.nogc());
+    let _fallback_smallest_unit = _fallback_smallest_unit.bind(gc.nogc());
+    let _smallest_largest_default_unit = _smallest_largest_default_unit.bind(gc.nogc());
+
+    let options = options.scope(agent, gc.nogc());
+    // 1. NOTE: The following steps read options and perform independent validation in alphabetical order.
+    // 2. Let largestUnit be ? GetTemporalUnitValuedOption(options, "largestUnit", unset).
+    let largest_unit = get_temporal_unit_valued_option(
+        agent,
+        options.get(agent),
+        BUILTIN_STRING_MEMORY.largestUnit.to_property_key(),
+        DefaultOption::Unset,
+        gc.reborrow(),
+    )
+    .unbind()?
+    .bind(gc.nogc());
+    // 3. Let roundingIncrement be ? GetRoundingIncrementOption(options).
+    let rounding_increment =
+        get_rounding_increment_option(agent, options.get(agent), gc.reborrow())
+            .unbind()?
+            .bind(gc.nogc());
+    // 4. Let roundingMode be ? GetRoundingModeOption(options, trunc).
+    let rounding_mode = get_rounding_mode_option(
+        agent,
+        options.get(agent),
+        RoundingMode::Trunc,
+        gc.reborrow(),
+    )
+    .unbind()?
+    .bind(gc.nogc());
+    // 5. Let smallestUnit be ? GetTemporalUnitValuedOption(options, "smallestUnit", unset).
+    let smallest_unit = get_temporal_unit_valued_option(
+        agent,
+        options.get(agent),
+        BUILTIN_STRING_MEMORY.smallestUnit.to_property_key(),
+        DefaultOption::Unset,
+        gc.reborrow(),
+    )
+    .unbind()?
+    .bind(gc.nogc());
+    // 6. Perform ? ValidateTemporalUnitValue(largestUnit, unitGroup, « auto »).
+    // 7. If largestUnit is unset, then
+    //    a. Set largestUnit to auto.
+    // 8. If disallowedUnits contains largestUnit, throw a RangeError exception.
+    // 9. If operation is since, then
+    //    a. Set roundingMode to NegateRoundingMode(roundingMode).
+    // 10. Perform ? ValidateTemporalUnitValue(smallestUnit, unitGroup).
+    // 11. If smallestUnit is unset, then
+    //     a. Set smallestUnit to fallbackSmallestUnit.
+    // 12. If disallowedUnits contains smallestUnit, throw a RangeError exception.
+    // 13. Let defaultLargestUnit be LargerOfTwoTemporalUnits(smallestLargestDefaultUnit, smallestUnit).
+    // 14. If largestUnit is auto, set largestUnit to defaultLargestUnit.
+    // 15. If LargerOfTwoTemporalUnits(largestUnit, smallestUnit) is not largestUnit, throw a RangeError exception.
+    // 16. Let maximum be MaximumTemporalDurationRoundingIncrement(smallestUnit).
+    // 17. If maximum is not unset, perform ? ValidateTemporalRoundingIncrement(roundingIncrement, maximum, false).
+    // 18. Return the Record { [[SmallestUnit]]: smallestUnit, [[LargestUnit]]: largestUnit, [[RoundingMode]]: roundingMode, [[RoundingIncrement]]: roundingIncrement,  }.
+    let mut diff_settings = temporal_rs::options::DifferenceSettings::default();
+    diff_settings.largest_unit = Some(largest_unit);
+    diff_settings.smallest_unit = Some(smallest_unit);
+    diff_settings.rounding_mode = Some(rounding_mode);
+    diff_settings.increment = Some(rounding_increment);
+    Ok(diff_settings)
+}

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

@@ -104,7 +104,7 @@ impl IndexMut<TemporalDuration<'_>> for Vec<DurationHeapData<'static>> {
 /// It creates a Temporal.Duration instance and fills
 /// the internal slots with valid values.
 /// It performs the following steps when called:
-fn create_temporal_duration<'gc>(// years,
+pub(crate) fn create_temporal_duration<'gc>(// years,
     // months,
     // weeks,
     // days,

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

@@ -8,12 +8,19 @@ pub(crate) mod data;
 pub mod instant_constructor;
 pub mod instant_prototype;
 
+use temporal_rs::options::{Unit, UnitGroup};
+
 use crate::{
     ecmascript::{
         abstract_operations::type_conversion::{PreferredType, to_primitive_object},
         builtins::{
             ordinary::ordinary_create_from_constructor,
-            temporal::{duration::to_temporal_duration, error::temporal_err_to_js_err},
+            temporal::{
+                duration::{TemporalDuration, create_temporal_duration, to_temporal_duration},
+                error::temporal_err_to_js_err,
+                get_difference_settings,
+                options::get_options_object,
+            },
         },
         execution::{
             JsResult, ProtoIntrinsics,
@@ -327,23 +334,60 @@ fn add_duration_to_instant<'gc, const IS_ADD: bool>(
 /// rounds it, and returns it as a Temporal.Duration object.
 fn difference_temporal_instant<'gc, const IS_UNTIL: bool>(
     agent: &mut Agent,
-    instant: Value,
+    instant: TemporalInstant,
     other: Value,
     options: Value,
     mut gc: GcScope<'gc, '_>,
-) -> JsResult<'gc, Value<'gc>> {
-    let instant = instant.bind(gc.nogc());
+) -> JsResult<'gc, TemporalDuration<'gc>> {
+    let instant = instant.scope(agent, gc.nogc());
     let other = other.bind(gc.nogc());
-    let options = options.bind(gc.nogc());
+    let options = options.scope(agent, gc.nogc());
     // 1. Set other to ? ToTemporalInstant(other).
-    let other = to_temporal_instant(agent, other.unbind(), gc.reborrow());
+    let other = to_temporal_instant(agent, other.unbind(), gc.reborrow())
+        .unbind()?
+        .bind(gc.nogc());
     // 2. Let resolvedOptions be ? GetOptionsObject(options).
+    let resolved_options = get_options_object(agent, options.get(agent), gc.nogc())
+        .unbind()?
+        .bind(gc.nogc());
     // 3. Let settings be ? GetDifferenceSettings(operation, resolvedOptions, time, « », nanosecond, second).
+    let _result;
+    if IS_UNTIL {
+        const UNTIL: bool = true;
+        let settings = get_difference_settings::<UNTIL>(
+            agent,
+            resolved_options.unbind(),
+            UnitGroup::Time,
+            vec![],
+            Unit::Nanosecond,
+            Unit::Second,
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        _result =
+            temporal_rs::Instant::until(&instant.get(agent).inner_instant(agent), &other, settings);
+    } else {
+        const SINCE: bool = false;
+        let settings = get_difference_settings::<SINCE>(
+            agent,
+            resolved_options.unbind(),
+            UnitGroup::Time,
+            vec![],
+            Unit::Nanosecond,
+            Unit::Second,
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+        _result =
+            temporal_rs::Instant::since(&instant.get(agent).inner_instant(agent), &other, settings);
+    }
     // 4. Let internalDuration be DifferenceInstant(instant.[[EpochNanoseconds]], other.[[EpochNanoseconds]], settings.[[RoundingIncrement]], settings.[[SmallestUnit]], settings.[[RoundingMode]]).
     // 5. Let result be ! TemporalDurationFromInternal(internalDuration, settings.[[LargestUnit]]).
-    // 6. If operation is since, set result to CreateNegatedTemporalDuration(result).
+    // 6. If operation is since, set result to CreateNegatedTemporsalDuration(result).
     // 7. Return result.
-    unimplemented!()
+    create_temporal_duration() // skip CreateNegatedTemporsalDuration and just CreateTemporsalDuration() with result
 }
 
 #[inline(always)]

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

@@ -232,7 +232,7 @@ impl TemporalInstantPrototype {
         const UNTIL: bool = true;
         let result = difference_temporal_instant::<UNTIL>(
             agent,
-            instant.into_value().unbind(),
+            instant.unbind(),
             other.unbind(),
             options.unbind(),
             gc,
@@ -260,7 +260,7 @@ impl TemporalInstantPrototype {
         const SINCE: bool = false;
         let result = difference_temporal_instant::<SINCE>(
             agent,
-            instant.into_value().unbind(),
+            instant.unbind(),
             other.unbind(),
             options.unbind(),
             gc,