added proper duration backing

Author: sebastianjacmatt

nova_vm/src/builtin_strings

@@ -107,6 +107,7 @@ description
 #[cfg(feature = "array-buffer")]detached
 done
 #[cfg(feature = "regexp")]dotAll
+#[cfg(feature="temporal")]Duration
 #[cfg(feature = "math")]E
 encodeURI
 encodeURIComponent
@@ -444,6 +445,7 @@ Symbol.toStringTag
 Symbol.unscopables
 SyntaxError
 #[cfg(feature = "temporal")]Temporal
+#[cfg(feature = "temporal")]Temporal.Duration
 #[cfg(feature = "temporal")]Temporal.Instant
 #[cfg(feature = "math")]tan
 #[cfg(feature = "math")]tanh

nova_vm/src/ecmascript/builtins/ordinary.rs

@@ -16,8 +16,11 @@ use caches::{CacheToPopulate, Caches, PropertyLookupCache, PropertyOffset};
 #[cfg(feature = "shared-array-buffer")]
 use crate::ecmascript::builtins::data_view::data::SharedDataViewRecord;
 #[cfg(feature = "temporal")]
-use crate::ecmascript::builtins::temporal::instant::data::InstantHeapData;
-use crate::ecmascript::builtins::temporal::plain_time::data::PlainTimeHeapData;
+use crate::ecmascript::builtins::temporal::{
+    instant::data::InstantHeapData,
+    plain_time::data::PlainTimeHeapData,
+    duration::data::DurationHeapData
+};
 use crate::{
     ecmascript::{
         abstract_operations::operations_on_objects::{
@@ -1688,6 +1691,10 @@ pub(crate) fn ordinary_object_create_with_intrinsics<'a>(
             agent.heap.create(InstantHeapData::default()).into_object()
         }
         #[cfg(feature = "temporal")]
+        ProtoIntrinsics::TemporalDuration => {
+            agent.heap.create(DurationHeapData::default()).into_object()
+        }
+        #[cfg(feature = "temporal")]
         ProtoIntrinsics::TemporalPlainTime => agent
             .heap
             .create(PlainTimeHeapData::default())
@@ -2081,6 +2088,8 @@ fn get_intrinsic_constructor<'a>(
         #[cfg(feature = "temporal")]
         ProtoIntrinsics::TemporalInstant => Some(intrinsics.temporal_instant().into_function()),
         #[cfg(feature = "temporal")]
+        ProtoIntrinsics::TemporalDuration => Some(intrinsics.temporal_duration().into_function()),
+        #[cfg(feature = "temporal")]
         ProtoIntrinsics::TemporalPlainTime => {
             Some(intrinsics.temporal_plain_time().into_function())
         }

nova_vm/src/ecmascript/builtins/temporal.rs

@@ -36,6 +36,7 @@ impl Temporal {
         let this = intrinsics.temporal();
 
         let instant_constructor = intrinsics.temporal_instant();
+        let duration_constructor = intrinsics.temporal_duration();
         let plain_time_constructor = intrinsics.temporal_plain_time();
 
         OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
@@ -64,6 +65,14 @@ impl Temporal {
             // 1.2.5 Temporal.PlainYearMonth ( . . . )
             // 1.2.6 Temporal.PlainMonthDay ( . . . )
             // 1.2.7 Temporal.Duration ( . . . )
+            .with_property(|builder| {
+                builder
+                    .with_key(BUILTIN_STRING_MEMORY.Duration.into())
+                    .with_value(duration_constructor.into_value())
+                    .with_enumerable(false)
+                    .with_configurable(true)
+                    .build()
+            })
             // 1.2.8 Temporal.ZonedDateTime ( . . . )
             // 1.3.1 Temporal.Now
             .with_property(|builder| {

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

@@ -1,20 +1,29 @@
+pub(crate) mod data;
+pub mod duration_constructor;
+pub mod duration_prototype;
+
 use crate::{
     ecmascript::{
         abstract_operations::{
             operations_on_objects::get, type_conversion::to_integer_if_integral,
         },
-        execution::{Agent, JsResult, agent::ExceptionType},
-        types::{BUILTIN_STRING_MEMORY, Object, String, Value},
+        execution::{Agent, JsResult, ProtoIntrinsics, agent::ExceptionType},
+        types::{
+            BUILTIN_STRING_MEMORY, InternalMethods, InternalSlots, Object, OrdinaryObject, String,
+            Value,
+        },
     },
     engine::{
         context::{Bindable, GcScope, NoGcScope, bindable_handle},
-        rootable::Scopable,
+        rootable::{HeapRootData, HeapRootRef, Rootable, Scopable},
+    },
+    heap::{
+        CompactionLists, CreateHeapData, Heap, HeapMarkAndSweep, HeapSweepWeakReference,
+        WorkQueues, indexes::BaseIndex,
     },
-    heap::indexes::BaseIndex,
 };
 use core::ops::{Index, IndexMut};
 
-pub(crate) mod data;
 use self::data::DurationHeapData;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
@@ -35,42 +44,49 @@ impl TemporalDuration<'_> {
 bindable_handle!(TemporalDuration);
 
 impl<'a> From<TemporalDuration<'a>> for Value<'a> {
-    fn from(_value: TemporalDuration<'a>) -> Self {
-        todo!()
-        //Value::Duration(value)
+    fn from(value: TemporalDuration<'a>) -> Self {
+        Value::Duration(value)
     }
 }
 impl<'a> From<TemporalDuration<'a>> for Object<'a> {
-    fn from(_value: TemporalDuration<'a>) -> Self {
-        todo!()
-        //Object::Duration(value)
+    fn from(value: TemporalDuration<'a>) -> Self {
+        Object::Duration(value)
     }
 }
 impl<'a> TryFrom<Value<'a>> for TemporalDuration<'a> {
     type Error = ();
 
-    fn try_from(_value: Value<'a>) -> Result<Self, ()> {
-        todo!()
-        // match value {
-        //     Value::Duration(idx) => Ok(idx),
-        //     _ => Err(()),
-        // }
+    fn try_from(value: Value<'a>) -> Result<Self, ()> {
+        match value {
+            Value::Duration(idx) => Ok(idx),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> InternalSlots<'a> for TemporalDuration<'a> {
+    const DEFAULT_PROTOTYPE: ProtoIntrinsics = ProtoIntrinsics::TemporalDuration;
+    fn get_backing_object(self, agent: &Agent) -> Option<OrdinaryObject<'static>> {
+        agent[self].object_index
+    }
+    fn set_backing_object(self, agent: &mut Agent, backing_object: OrdinaryObject<'static>) {
+        assert!(agent[self].object_index.replace(backing_object).is_none());
     }
 }
 
+impl<'a> InternalMethods<'a> for TemporalDuration<'a> {}
+
 impl Index<TemporalDuration<'_>> for Agent {
     type Output = DurationHeapData<'static>;
 
-    fn index(&self, _index: TemporalDuration<'_>) -> &Self::Output {
-        unimplemented!()
-        //&self.heap.durations[index]
+    fn index(&self, index: TemporalDuration<'_>) -> &Self::Output {
+        &self.heap.durations[index]
     }
 }
 
 impl IndexMut<TemporalDuration<'_>> for Agent {
-    fn index_mut(&mut self, _index: TemporalDuration) -> &mut Self::Output {
-        unimplemented!()
-        //&mut self.heap.durations[index]
+    fn index_mut(&mut self, index: TemporalDuration) -> &mut Self::Output {
+        &mut self.heap.durations[index]
     }
 }
 
@@ -89,6 +105,52 @@ impl IndexMut<TemporalDuration<'_>> for Vec<DurationHeapData<'static>> {
             .expect("heap access out of bounds")
     }
 }
+
+impl Rootable for TemporalDuration<'_> {
+    type RootRepr = HeapRootRef;
+
+    fn to_root_repr(value: Self) -> Result<Self::RootRepr, HeapRootData> {
+        Err(HeapRootData::Duration(value.unbind()))
+    }
+
+    fn from_root_repr(value: &Self::RootRepr) -> Result<Self, HeapRootRef> {
+        Err(*value)
+    }
+
+    fn from_heap_ref(heap_ref: HeapRootRef) -> Self::RootRepr {
+        heap_ref
+    }
+
+    fn from_heap_data(heap_data: HeapRootData) -> Option<Self> {
+        match heap_data {
+            HeapRootData::Duration(object) => Some(object),
+            _ => None,
+        }
+    }
+}
+
+impl HeapMarkAndSweep for TemporalDuration<'static> {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        queues.durations.push(*self);
+    }
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        compactions.durations.shift_index(&mut self.0);
+    }
+}
+
+impl HeapSweepWeakReference for TemporalDuration<'static> {
+    fn sweep_weak_reference(self, compactions: &CompactionLists) -> Option<Self> {
+        compactions.durations.shift_weak_index(self.0).map(Self)
+    }
+}
+
+impl<'a> CreateHeapData<DurationHeapData<'a>, TemporalDuration<'a>> for Heap {
+    fn create(&mut self, data: DurationHeapData<'a>) -> TemporalDuration<'a> {
+        self.durations.push(data.unbind());
+        self.alloc_counter += core::mem::size_of::<DurationHeapData<'static>>();
+        TemporalDuration(BaseIndex::last_t(&self.durations))
+    }
+}
 /// 7.5.19 CreateTemporalDuration ( years, months, weeks,
 /// days, hours, minutes, seconds,
 /// milliseconds, microseconds, nanoseconds [ , newTarget ] )
@@ -144,7 +206,7 @@ pub(crate) fn create_temporal_duration<'gc>(// years,
 pub(crate) fn to_temporal_duration<'gc>(
     agent: &mut Agent,
     item: Value,
-    mut gc: GcScope<'gc, '_>,
+    gc: GcScope<'gc, '_>,
 ) -> JsResult<'gc, temporal_rs::Duration> {
     let item = item.bind(gc.nogc());
     // 1. If item is an Object and item has an [[InitializedTemporalDuration]] internal slot, then
@@ -388,21 +450,19 @@ 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,
-    mut gc: GcScope<'gc, '_>,
+    _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!()
 }
 
 #[inline(always)]
 fn require_internal_slot_temporal_duration<'a>(
-    agent: &mut Agent,
-    value: Value,
-    gc: NoGcScope<'a, '_>,
+    _agent: &mut Agent,
+    _value: Value,
+    _gc: NoGcScope<'a, '_>,
 ) -> JsResult<'a, TemporalDuration<'a>> {
     unimplemented!()
     // TODO:

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

@@ -0,0 +1,47 @@
+use crate::{
+    ecmascript::{
+        builders::builtin_function_builder::BuiltinFunctionBuilder,
+        builtins::{
+            ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor
+        },
+        execution::{Agent, JsResult, Realm},
+        types::{BUILTIN_STRING_MEMORY, IntoObject, Object, String, Value},
+    },
+    engine::context::{GcScope, NoGcScope},
+    heap::IntrinsicConstructorIndexes,
+};
+
+pub(crate) struct TemporalDurationConstructor;
+
+impl Builtin for TemporalDurationConstructor {
+    const NAME: String<'static> = BUILTIN_STRING_MEMORY.Duration;
+    const LENGTH: u8 = 1;
+    const BEHAVIOUR: Behaviour = Behaviour::Constructor(TemporalDurationConstructor::constructor);
+}
+impl BuiltinIntrinsicConstructor for TemporalDurationConstructor {
+    const INDEX: IntrinsicConstructorIndexes = IntrinsicConstructorIndexes::TemporalDuration;
+}
+
+impl TemporalDurationConstructor {
+    fn constructor<'gc>(
+        _agent: &mut Agent,
+        _: Value,
+        _args: ArgumentsList,
+        _new_target: Option<Object>,
+        mut _gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        unimplemented!()
+    }
+
+    pub(crate) fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>, _gc: NoGcScope) {
+        let intrinsics = agent.get_realm_record_by_id(realm).intrinsics();
+        let duration_prototype = intrinsics.temporal_duration_prototype();
+
+        BuiltinFunctionBuilder::new_intrinsic_constructor::<TemporalDurationConstructor>(
+            agent, realm,
+        )
+        .with_property_capacity(5)
+        .with_prototype_property(duration_prototype.into_object())
+        .build();
+    }
+}

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

@@ -0,0 +1,33 @@
+use crate::{
+    ecmascript::{
+        builders::ordinary_object_builder::OrdinaryObjectBuilder,
+        execution::{Agent, Realm},
+        types::BUILTIN_STRING_MEMORY,
+    },
+    engine::context::NoGcScope,
+    heap::WellKnownSymbolIndexes,
+};
+
+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 object_prototype = intrinsics.object_prototype();
+        let duration_constructor = intrinsics.temporal_duration();
+
+        OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
+            .with_property_capacity(15)
+            .with_prototype(object_prototype)
+            .with_constructor_property(duration_constructor)
+            .with_property(|builder| {
+                builder
+                    .with_key(WellKnownSymbolIndexes::ToStringTag.into())
+                    .with_value_readonly(BUILTIN_STRING_MEMORY.Temporal_Duration.into())
+                    .with_enumerable(false)
+                    .with_configurable(true)
+                    .build()
+            })
+            .build();
+    }
+}

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

@@ -16,7 +16,7 @@ use crate::{
         builtins::{
             ordinary::ordinary_create_from_constructor,
             temporal::{
-                duration::{TemporalDuration, create_temporal_duration, to_temporal_duration},
+                duration::{TemporalDuration, data::DurationHeapData, to_temporal_duration},
                 error::temporal_err_to_js_err,
                 get_difference_settings,
                 options::get_options_object,
@@ -387,7 +387,12 @@ fn difference_temporal_instant<'gc, const IS_UNTIL: bool>(
     // 5. Let result be ! TemporalDurationFromInternal(internalDuration, settings.[[LargestUnit]]).
     // 6. If operation is since, set result to CreateNegatedTemporsalDuration(result).
     // 7. Return result.
-    create_temporal_duration() // skip CreateNegatedTemporsalDuration and just CreateTemporsalDuration() with result
+    let result: temporal_rs::Duration = Default::default(); // TODO
+    // 7. Return result.
+    Ok(agent.heap.create(DurationHeapData {
+        object_index: None,
+        duration: result,
+    }))
 }
 
 #[inline(always)]