get_epoch_milliseconds and get_epoch_nanoseconds

Author: lockels

nova_vm/src/builtin_strings

@@ -184,6 +184,8 @@ get size
 #[cfg(feature = "array-buffer")]getBigUint64
 #[cfg(feature = "date")]getDate
 #[cfg(feature = "date")]getDay
+#[cfg(feature = "temporal")]getEpochMilliseconds
+#[cfg(feature = "temporal")]getEpochNanoSeconds
 #[cfg(feature = "proposal-float16array")]getFloat16
 #[cfg(feature = "array-buffer")]getFloat32
 #[cfg(feature = "array-buffer")]getFloat64

nova_vm/src/ecmascript/builtins/ordinary.rs

@@ -16,7 +16,7 @@ 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::InstantRecord;
+use crate::ecmascript::builtins::temporal::instant::data::InstantHeapData;
 use crate::{
     ecmascript::{
         abstract_operations::operations_on_objects::{
@@ -1684,7 +1684,7 @@ pub(crate) fn ordinary_object_create_with_intrinsics<'a>(
             .into_object(),
         #[cfg(feature = "temporal")]
         ProtoIntrinsics::TemporalInstant => {
-            agent.heap.create(InstantRecord::default()).into_object()
+            agent.heap.create(InstantHeapData::default()).into_object()
         }
         ProtoIntrinsics::TypeError => agent
             .heap

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

@@ -140,7 +140,7 @@ impl TemporalInstantConstructor {
         let item = args.get(0).bind(gc.nogc());
         // 1. Return ? ToTemporalInstant(item).
         let instant = to_temporal_instant(agent, item.unbind(), gc)?;
-        let instant = agent.heap.create(InstantRecord {
+        let instant = agent.heap.create(InstantHeapData {
             object_index: None,
             instant,
         });
@@ -345,6 +345,22 @@ fn to_temporal_instant<'gc>(
 /// %Temporal.Instant.Prototype%
 pub(crate) struct TemporalInstantPrototype;
 
+struct TemporalInstantPrototypeGetEpochMilliseconds;
+impl Builtin for TemporalInstantPrototypeGetEpochMilliseconds {
+    const NAME: String<'static> = BUILTIN_STRING_MEMORY.getEpochMilliseconds;
+    const LENGTH: u8 = 0;
+    const BEHAVIOUR: Behaviour =
+        Behaviour::Regular(TemporalInstantPrototype::get_epoch_milliseconds);
+}
+
+struct TemporalInstantPrototypeGetEpochNanoSeconds;
+impl Builtin for TemporalInstantPrototypeGetEpochNanoSeconds {
+    const NAME: String<'static> = BUILTIN_STRING_MEMORY.getEpochNanoSeconds;
+    const LENGTH: u8 = 0;
+    const BEHAVIOUR: Behaviour =
+        Behaviour::Regular(TemporalInstantPrototype::get_epoch_nanoseconds);
+}
+
 impl TemporalInstantPrototype {
     pub fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>, _: NoGcScope) {
         let intrinsics = agent.get_realm_record_by_id(realm).intrinsics();
@@ -353,18 +369,62 @@ impl TemporalInstantPrototype {
         let instant_constructor = intrinsics.temporal_instant();
 
         OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
-            .with_property_capacity(1)
+            .with_property_capacity(3)
             .with_prototype(object_prototype)
             .with_constructor_property(instant_constructor)
+            .with_builtin_function_property::<TemporalInstantPrototypeGetEpochMilliseconds>()
+            .with_builtin_function_property::<TemporalInstantPrototypeGetEpochNanoSeconds>()
             .build();
     }
+
+    /// ### [8.3.3 get Temporal.Instant.prototype.epochMilliseconds](https://tc39.es/proposal-temporal/#sec-get-temporal.instant.prototype.epochmilliseconds)
+    fn get_epoch_milliseconds<'gc>(
+        agent: &mut Agent,
+        this_value: Value,
+        _: ArgumentsList,
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        // 1. Let instant be the this value.
+        // 2. Perform ? RequireInternalSlot(instant, [[InitializedTemporalInstant]]).
+        let instant = requrire_temporal_instant_internal_slot(agent, this_value, gc.nogc())
+            .unbind()?
+            .bind(gc.nogc());
+        // 3. Let ns be instant.[[EpochNanoseconds]].
+        // 4. Let ms be floor(ℝ(ns) / 10**6).
+        // 5. Return 𝔽(ms).
+        let value = instant.inner_instant(agent).epoch_milliseconds();
+        Ok(Value::from_i64(agent, value, gc.into_nogc()))
+    }
+
+    /// ### [8.3.4 get Temporal.Instant.prototype.epochNanoseconds](https://tc39.es/proposal-temporal/#sec-get-temporal.instant.prototype.epochnanoseconds)
+    fn get_epoch_nanoseconds<'gc>(
+        agent: &mut Agent,
+        this_value: Value,
+        _: ArgumentsList,
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        // 1. Let instant be the this value.
+        // 2. Perform ? RequireInternalSlot(instant, [[InitializedTemporalInstant]]).
+        let instant = requrire_temporal_instant_internal_slot(agent, this_value, gc.nogc())
+            .unbind()?
+            .bind(gc.nogc());
+        // 3. Return instant.[[EpochNanoseconds]].
+        let value = instant.inner_instant(agent).epoch_nanoseconds().as_i128();
+        todo!()
+    }
 }
 
-use self::data::InstantRecord;
+use self::data::InstantHeapData;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
-pub struct TemporalInstant<'a>(BaseIndex<'a, InstantRecord<'static>>);
+pub struct TemporalInstant<'a>(BaseIndex<'a, InstantHeapData<'static>>);
+
 impl TemporalInstant<'_> {
+    pub(crate) fn inner_instant(self, agent: &Agent) -> temporal_rs::Instant {
+        agent[self].instant
+    }
+
     //TODO
     pub(crate) const fn _def() -> Self {
         TemporalInstant(BaseIndex::from_u32_index(0))
@@ -431,7 +491,7 @@ impl<'a> InternalMethods<'a> for TemporalInstant<'a> {}
 
 // TODO: get rid of Index impls, replace with get/get_mut/get_direct/get_direct_mut functions
 impl Index<TemporalInstant<'_>> for Agent {
-    type Output = InstantRecord<'static>;
+    type Output = InstantHeapData<'static>;
 
     fn index(&self, index: TemporalInstant<'_>) -> &Self::Output {
         &self.heap.instants[index]
@@ -444,16 +504,16 @@ impl IndexMut<TemporalInstant<'_>> for Agent {
     }
 }
 
-impl Index<TemporalInstant<'_>> for Vec<InstantRecord<'static>> {
-    type Output = InstantRecord<'static>;
+impl Index<TemporalInstant<'_>> for Vec<InstantHeapData<'static>> {
+    type Output = InstantHeapData<'static>;
 
     fn index(&self, index: TemporalInstant<'_>) -> &Self::Output {
         self.get(index.get_index())
             .expect("heap access out of bounds")
     }
 }
 
-impl IndexMut<TemporalInstant<'_>> for Vec<InstantRecord<'static>> {
+impl IndexMut<TemporalInstant<'_>> for Vec<InstantHeapData<'static>> {
     fn index_mut(&mut self, index: TemporalInstant<'_>) -> &mut Self::Output {
         self.get_mut(index.get_index())
             .expect("heap access out of bounds")
@@ -498,10 +558,26 @@ impl HeapSweepWeakReference for TemporalInstant<'static> {
     }
 }
 
-impl<'a> CreateHeapData<InstantRecord<'a>, TemporalInstant<'a>> for Heap {
-    fn create(&mut self, data: InstantRecord<'a>) -> TemporalInstant<'a> {
+impl<'a> CreateHeapData<InstantHeapData<'a>, TemporalInstant<'a>> for Heap {
+    fn create(&mut self, data: InstantHeapData<'a>) -> TemporalInstant<'a> {
         self.instants.push(data.unbind());
-        self.alloc_counter += core::mem::size_of::<InstantRecord<'static>>();
+        self.alloc_counter += core::mem::size_of::<InstantHeapData<'static>>();
         TemporalInstant(BaseIndex::last_t(&self.instants))
     }
 }
+
+#[inline(always)]
+fn requrire_temporal_instant_internal_slot<'a>(
+    agent: &mut Agent,
+    value: Value,
+    gc: NoGcScope<'a, '_>,
+) -> JsResult<'a, TemporalInstant<'a>> {
+    match value {
+        Value::Instant(instant) => Ok(instant.bind(gc)),
+        _ => Err(agent.throw_exception_with_static_message(
+            ExceptionType::TypeError,
+            "Object is not a Temporal Instant",
+            gc,
+        )),
+    }
+}

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

@@ -10,12 +10,12 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Copy)]
-pub struct InstantRecord<'a> {
+pub struct InstantHeapData<'a> {
     pub(crate) object_index: Option<OrdinaryObject<'a>>,
     pub(crate) instant: temporal_rs::Instant,
 }
 
-impl InstantRecord<'_> {
+impl InstantHeapData<'_> {
     pub fn default() -> Self {
         Self {
             object_index: None,
@@ -25,9 +25,9 @@ impl InstantRecord<'_> {
 }
 
 trivially_bindable!(temporal_rs::Instant);
-bindable_handle!(InstantRecord);
+bindable_handle!(InstantHeapData);
 
-impl HeapMarkAndSweep for InstantRecord<'static> {
+impl HeapMarkAndSweep for InstantHeapData<'static> {
     fn mark_values(&self, queues: &mut WorkQueues) {
         let Self {
             object_index,

nova_vm/src/heap.rs

@@ -32,7 +32,7 @@ use crate::ecmascript::builtins::date::data::DateHeapData;
 #[cfg(feature = "shared-array-buffer")]
 use crate::ecmascript::builtins::shared_array_buffer::data::SharedArrayBufferRecord;
 #[cfg(feature = "temporal")]
-use crate::ecmascript::builtins::temporal::instant::data::InstantRecord;
+use crate::ecmascript::builtins::temporal::instant::data::InstantHeapData;
 #[cfg(feature = "array-buffer")]
 use crate::ecmascript::builtins::{
     ArrayBuffer, ArrayBufferHeapData,
@@ -144,7 +144,7 @@ pub(crate) struct Heap {
     #[cfg(feature = "date")]
     pub(crate) dates: Vec<Option<DateHeapData<'static>>>,
     #[cfg(feature = "temporal")]
-    pub(crate) instants: Vec<InstantRecord<'static>>,
+    pub(crate) instants: Vec<InstantHeapData<'static>>,
     pub(crate) ecmascript_functions: Vec<Option<ECMAScriptFunctionHeapData<'static>>>,
     /// ElementsArrays is where all keys and values arrays live;
     /// Element arrays are static arrays of Values plus