added data.rs

Author: sebastianjacmatt

nova_vm/src/ecmascript/builtins/ordinary.rs

@@ -6,9 +6,7 @@ pub(crate) mod caches;
 pub mod shape;
 
 use std::{
-    collections::{TryReserveError, hash_map::Entry},
-    ops::ControlFlow,
-    vec,
+    collections::{hash_map::Entry, TryReserveError}, ops::ControlFlow, time::Instant, vec
 };
 
 use caches::{CacheToPopulate, Caches, PropertyLookupCache, PropertyOffset};
@@ -17,16 +15,12 @@ use crate::{
     ecmascript::{
         abstract_operations::operations_on_objects::{
             try_create_data_property, try_get, try_get_function_realm,
-        },
-        execution::agent::{TryError, TryResult, unwrap_try},
-        types::{
-            IntoValue, SetCachedProps, SetResult, TryGetResult, TryHasResult, handle_try_get_result,
-        },
+        }, builtins::temporal::instant::data::InstantHeapData, execution::agent::{unwrap_try, TryError, TryResult}, types::{
+            handle_try_get_result, IntoValue, SetCachedProps, SetResult, TryGetResult, TryHasResult
+        }
     },
     engine::{
-        Scoped,
-        context::{Bindable, GcScope, NoGcScope},
-        rootable::Scopable,
+        context::{Bindable, GcScope, NoGcScope}, rootable::Scopable, Scoped
     },
     heap::element_array::{ElementStorageRef, PropertyStorageRef},
 };
@@ -1674,6 +1668,11 @@ pub(crate) fn ordinary_object_create_with_intrinsics<'a>(
             .heap
             .create(ErrorHeapData::new(ExceptionType::SyntaxError, None, None))
             .into_object(),
+        #[cfg(feature = "temporal")]
+        ProtoIntrinsics::TemporalInstant => agent
+            .heap
+            .create(InstantHeapData::default())
+            .into_object(),
         ProtoIntrinsics::TypeError => agent
             .heap
             .create(ErrorHeapData::new(ExceptionType::TypeError, None, None))
@@ -1952,6 +1951,8 @@ pub(crate) fn get_prototype_from_constructor<'a>(
             ProtoIntrinsics::RegExpStringIterator => None,
             ProtoIntrinsics::Symbol => Some(intrinsics.symbol().into_function()),
             ProtoIntrinsics::SyntaxError => Some(intrinsics.syntax_error().into_function()),
+            #[cfg(feature = "temporal")]
+            ProtoIntrinsics::TemporalInstant => Some(intrinsics.type_error().into_function()),
             ProtoIntrinsics::TypeError => Some(intrinsics.type_error().into_function()),
             #[cfg(feature = "array-buffer")]
             ProtoIntrinsics::Uint16Array => Some(intrinsics.uint16_array().into_function()),

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

@@ -1,17 +1,19 @@
 use core::ops::{Index, IndexMut};
 
+pub(crate) mod data;
+
 use crate::{
     ecmascript::{
         builders::{builtin_function_builder::BuiltinFunctionBuilder, ordinary_object_builder::OrdinaryObjectBuilder},
         builtins::{
             ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor
         },
-        execution::{agent::Agent, JsResult, Realm},
+        execution::{agent::Agent, JsResult, ProtoIntrinsics, Realm},
         types::{
             InternalMethods, InternalSlots, IntoObject, Object, OrdinaryObject, String, Value, BUILTIN_STRING_MEMORY
         },
     },
-    engine::{context::{bindable_handle, GcScope, NoGcScope}, rootable::{HeapRootRef, Rootable}},
+    engine::{context::{bindable_handle, Bindable, GcScope, NoGcScope}, rootable::{HeapRootData, HeapRootRef, Rootable}},
     heap::{indexes::BaseIndex, CompactionLists, CreateHeapData, Heap, HeapMarkAndSweep, HeapSweepWeakReference, IntrinsicConstructorIndexes, WorkQueues},
 };
 /// Constructor function object for %Temporal.Instant%.
@@ -58,36 +60,11 @@ impl InstantPrototype {
             .build();
     }
 }
-/// HEAP DATA -- Move to internal instant/data.rs
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct InstantValue(/*TODO:BigInt*/);
-
-impl InstantValue {
-    // TODO
-}
-#[derive(Debug, Clone, Copy)]
-pub struct InstantHeapData<'a> {
-    pub(crate) object_index: Option<OrdinaryObject<'a>>,
-    pub(crate) date: InstantValue,
-}
-
-impl InstantHeapData<'_> {
-    // TODO
-}
 
-bindable_handle!(InstantHeapData);
 
-impl HeapMarkAndSweep for InstantHeapData<'static> {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        todo!()
-    }
-    fn sweep_values(&mut self, compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
-// HANDLES -- Keep public facing within instant.rs
+use self::data::InstantHeapData;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(transparent)]
 pub struct Instant<'a>(BaseIndex<'a, InstantHeapData<'static>>);
 impl Instant<'_> {
     //TODO
@@ -103,20 +80,20 @@ bindable_handle!(Instant);
 
 impl<'a> From<Instant<'a>> for Value<'a> {
     fn from(value: Instant<'a>) -> Self { 
-        Value::Instant(value) // todo: add to value.rs
+        Value::Instant(value)
      }
 }
 impl<'a> From<Instant<'a>> for Object<'a> {
     fn from(value: Instant<'a>) -> Self {
-        Object::Instant(value) // todo: add to object.rs
+        Object::Instant(value)
     }
 }
 impl<'a> TryFrom<Value<'a>> for Instant<'a> {
     type Error = ();
 
     fn try_from(value: Value<'a>) -> Result<Self, ()> {
         match value {
-            Value::Instant(idx) => Ok(idx), // todo: add to value.rs
+            Value::Instant(idx) => Ok(idx),
             _ => Err(()),
         }
     }
@@ -125,66 +102,103 @@ impl<'a> TryFrom<Object<'a>> for Instant<'a> {
     type Error = ();
     fn try_from(object: Object<'a>) -> Result<Self, ()> {
         match object {
-            Object::Instant(idx) => Ok(idx), // todo: add to object.rs
+            Object::Instant(idx) => Ok(idx),
             _ => Err(()),
         }
     }
 }
 
-// TODO impl trait bounds properly
 impl<'a> InternalSlots<'a> for Instant<'a> {
-    // TODO: Add TemporalInstant to ProtoIntrinsics
-    //const DEFAULT_PROTOTYPE: ProtoIntrinsics = ProtoIntrinsics::TemporalInstant;
+    const DEFAULT_PROTOTYPE: ProtoIntrinsics = ProtoIntrinsics::TemporalInstant;
     fn get_backing_object(self, agent: &Agent) -> Option<OrdinaryObject<'static>> {
-        todo!()
+        agent[self].object_index // not implemented for `agent::Agent`
     }
     fn set_backing_object(self, agent: &mut Agent, backing_object: OrdinaryObject<'static>) {
-        todo!()
+        assert!(agent[self].object_index.replace(backing_object).is_none()); // not implemented for `agent::Agent`
     }
 
 }
 
 impl<'a> InternalMethods<'a> for Instant<'a> {}
 
-impl HeapMarkAndSweep for Instant<'static> {
-    fn mark_values(&self, queues: &mut WorkQueues) {
-        todo!()
+impl Index<Instant<'_>> for Agent {
+    type Output = InstantHeapData<'static>;
+
+    fn index(&self, index: Instant<'_>) -> &Self::Output {
+        &self.heap.instants[index]
     }
-    fn sweep_values(&mut self, compactions: &CompactionLists) {
-        todo!()
+}
+
+impl IndexMut<Instant<'_>> for Agent {
+    fn index_mut(&mut self, index: Instant) -> &mut Self::Output {
+        &mut self.heap.instants[index]
     }
 }
 
-impl HeapSweepWeakReference for Instant<'static> {
-    fn sweep_weak_reference(self, compactions: &CompactionLists) -> Option<Self> {
-        compactions.dates.shift_weak_index(self.0).map(Self)
+impl Index<Instant<'_>> for Vec<Option<InstantHeapData<'static>>> {
+    type Output = InstantHeapData<'static>;
+
+    fn index(&self, index: Instant<'_>) -> &Self::Output {
+        self.get(index.get_index())
+        .expect("heap access out of bounds")
+        .as_ref()
+        .expect("")
     }
 }
 
-impl<'a> CreateHeapData<InstantHeapData<'a>, Instant<'a>> for Heap {
-    fn create(&mut self, data: InstantHeapData<'a>) -> Instant<'a> {
-        todo!()
+impl IndexMut<Instant<'_>> for Vec<Option<InstantHeapData<'static>>> {
+    fn index_mut(&mut self, index: Instant<'_>) -> &mut Self::Output {
+        self.get_mut(index.get_index())
+            .expect("dasdas")
+            .as_mut()
+            .expect("")
     }
 }
 
-/* todo - impl keep public facing in temporal/instant.rs
+
 impl Rootable for Instant<'_> {
     type RootRepr = HeapRootRef;
 
     fn to_root_repr(value: Self) -> Result<Self::RootRepr, crate::engine::rootable::HeapRootData> {
-        todo!()
+        Err(HeapRootData::Instant(value.unbind()))
     }
 
     fn from_root_repr(value: &Self::RootRepr) -> Result<Self, crate::engine::rootable::HeapRootRef> {
-        todo!()
+        Err(*value)
     }
 
     fn from_heap_ref(heap_ref: crate::engine::rootable::HeapRootRef) -> Self::RootRepr {
-        todo!()
+        heap_ref
     }
 
     fn from_heap_data(heap_data: crate::engine::rootable::HeapRootData) -> Option<Self> {
-        todo!()
+        match heap_data {
+            HeapRootData::Instant(object) => Some(object),
+            _ => None,
+        }
+    }
+}
+
+
+impl HeapMarkAndSweep for Instant<'static> {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        queues.instants.push(*self);
+    }
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        compactions.instants.shift_index(&mut self.0);
+    }
+}
+
+impl HeapSweepWeakReference for Instant<'static> {
+    fn sweep_weak_reference(self, compactions: &CompactionLists) -> Option<Self> {
+        compactions.dates.shift_weak_index(self.0).map(Self)
+    }
+}
+
+impl<'a> CreateHeapData<InstantHeapData<'a>, Instant<'a>> for Heap {
+    fn create(&mut self, data: InstantHeapData<'a>) -> Instant<'a> {
+        self.instants.push(Some(data.unbind()));
+        self.alloc_counter += core::mem::size_of::<Option<InstantHeapData<'static>>>();
+        Instant(BaseIndex::last(&self.instants))
     }
 }
-*/

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

@@ -0,0 +1,28 @@
+
+use crate::{ecmascript::types::{OrdinaryObject,bigint::BigInt}, engine::context::bindable_handle, heap::HeapMarkAndSweep};
+
+#[derive(Debug, Clone, Copy)]
+pub struct InstantHeapData<'a> {
+    pub(crate) object_index: Option<OrdinaryObject<'a>>,
+    pub(crate) instant: BigInt<'a>,
+}
+
+impl InstantHeapData<'_> {
+    pub fn default() -> Self {
+        Self {
+            object_index: None,
+            instant: BigInt::zero(),
+        }
+    }
+}
+
+bindable_handle!(InstantHeapData);
+
+impl HeapMarkAndSweep for InstantHeapData<'static> {
+    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
+        todo!()
+    }
+    fn sweep_values(&mut self, compactions: &crate::heap::CompactionLists) {
+        todo!()
+    }
+}

nova_vm/src/ecmascript/execution/realm/intrinsics.rs

@@ -216,6 +216,8 @@ pub enum ProtoIntrinsics {
     RegExpStringIterator,
     Symbol,
     SyntaxError,
+    #[cfg(feature = "temporal")]
+    TemporalInstant,
     TypeError,
     #[cfg(feature = "array-buffer")]
     Uint16Array,
@@ -413,6 +415,7 @@ impl Intrinsics {
             ProtoIntrinsics::String => self.string().into(),
             ProtoIntrinsics::Symbol => self.symbol().into(),
             ProtoIntrinsics::SyntaxError => self.syntax_error().into(),
+            ProtoIntrinsics::TemporalInstant => self.temporal_instant().into(),
             ProtoIntrinsics::TypeError => self.type_error().into(),
             ProtoIntrinsics::URIError => self.uri_error().into(),
             ProtoIntrinsics::AggregateError => self.aggregate_error().into(),
@@ -500,6 +503,7 @@ impl Intrinsics {
             ProtoIntrinsics::String => self.string_prototype().into(),
             ProtoIntrinsics::Symbol => self.symbol_prototype().into(),
             ProtoIntrinsics::SyntaxError => self.syntax_error_prototype().into(),
+            ProtoIntrinsics::TemporalInstant => self.temporal().into(),
             ProtoIntrinsics::TypeError => self.type_error_prototype().into(),
             ProtoIntrinsics::URIError => self.uri_error_prototype().into(),
             ProtoIntrinsics::AggregateError => self.aggregate_error_prototype().into(),

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::InstantHeapData;
+use crate::ecmascript::builtins::temporal::instant::data::InstantHeapData;
 #[cfg(feature = "array-buffer")]
 use crate::ecmascript::builtins::{
     ArrayBuffer, ArrayBufferHeapData,