Added Placeholders for InstantConstructor%Temporal.Instant% and InstantPrototype%Temporal.Instant.Prototype% as well as heap data and handles

Author: sebastianjacmatt

nova_vm/src/builtin_strings

@@ -248,6 +248,7 @@ isSealed
 #[cfg(feature = "array-buffer")]isView
 isWellFormed
 #[cfg(feature = "annex-b-string")]italics
+#[cfg(feature = "temporal")]Instant
 Iterator
 iterator
 join
@@ -317,6 +318,14 @@ prototype
 Proxy
 push
 race
+#[cfg(feature = "temporal")]PlainDateTime
+#[cfg(feature = "temporal")]PlainDate
+#[cfg(feature = "temporal")]PlainTime
+#[cfg(feature = "temporal")]PlainYearMonth
+#[cfg(feature = "temporal")]PlainMonthDay
+#[cfg(feature = "temporal")]Duration
+#[cfg(feature = "temporal")]ZonedDateTime
+#[cfg(feature = "temporal")]Now
 #[cfg(feature = "math")]random
 RangeError
 raw

nova_vm/src/ecmascript/builtins/temporal.rs

@@ -2,11 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-
-use temporal_rs::{Instant, Duration, /* etc */};
-
-use core::f64::consts;
-use std::thread::Builder;
+pub mod instant;
 
 use crate::{
     ecmascript::{
@@ -38,7 +34,7 @@ impl TemporalObject {
         let this = intrinsics.temporal();
 
         let builders = OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
-            .with_property_capacity(1)
+            .with_property_capacity(2)
             .with_prototype(object_prototype)
             .with_property(|builder| {
                 builder
@@ -48,58 +44,7 @@ impl TemporalObject {
                     .with_configurable(true)
                     .build()
             })
+            .with_builtin_function_property::<instant::InstantConstructor>()
             .build();
     }  
-}
-
-
-
-/* 
-struct TemporalPlainDateTime;
-impl Builtin for TemporalPlainDateTime {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainDateTime;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::PlainDateTime);
-}
-
-struct TemporalPlainDate;
-impl Builtin for TemporalPlainDate {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainDate;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::PlainDate);
-}
-
-struct TemporalPlainTime;
-impl Builtin for TemporalPlainTime {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainTime;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::PlainTime);
-}
-
-struct TemporalPlainYearMonth;
-impl Builtin for TemporalPlainYearMonth {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainYearMonth;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::PlainYearMonth);
-}
-
-struct TemporalPlainMonthDay;
-impl Builtin for TemporalPlainMonthDay {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainMonthDay;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::PlainMonthDay);
-}
-
-struct TemporalDuration;
-impl Builtin for TemporalDuration {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.Duration;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::Duration);
-}
-
-struct TemporalZonedDateTime;
-impl Builtin for TemporalZonedDateTime {
-    const NAME: String<'static> = BUILTIN_STRING_MEMORY.ZonedDateTime;
-    const LENGTH: u8 = 1;
-    const BEHAVIOUR: Behaviour = Behaviour::Regular(TemporalObject::ZonedDateTime);
-}*/
+}

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

@@ -0,0 +1,143 @@
+use crate::{
+    ecmascript::{
+        builders::{builtin_function_builder::BuiltinFunctionBuilder, ordinary_object_builder::OrdinaryObjectBuilder},
+        builtins::{
+            ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor
+        },
+        execution::{agent::{Agent}, JsResult, Realm},
+        types::{
+            InternalSlots, IntoObject, Object, OrdinaryObject, String, Value, BUILTIN_STRING_MEMORY
+        },
+    },
+    engine::context::{bindable_handle, GcScope, NoGcScope},
+    heap::{indexes::BaseIndex, CompactionLists, CreateHeapData, Heap, HeapMarkAndSweep, IntrinsicConstructorIndexes, WorkQueues},
+};
+/// Constructor function object for %Temporal.Instant%.
+pub(crate) struct InstantConstructor;
+impl Builtin for InstantConstructor {
+    const NAME: String<'static> = BUILTIN_STRING_MEMORY.Instant;
+    const LENGTH: u8 = 1;
+    const BEHAVIOUR: Behaviour = Behaviour::Constructor(InstantConstructor::construct);
+}
+impl BuiltinIntrinsicConstructor for InstantConstructor {
+    const INDEX: IntrinsicConstructorIndexes = IntrinsicConstructorIndexes::TemporalInstant;
+}
+
+impl InstantConstructor {
+    fn construct<'gc>(agent: &mut Agent, this_value: Value, args: ArgumentsList, new_target: Option<Object>, gc: GcScope<'gc, '_>) -> JsResult<'gc, Value<'gc>> {
+        todo!();
+    }
+    pub(crate) fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>, gc: NoGcScope) {
+        let intrinsics = agent.get_realm_record_by_id(realm).intrinsics();        
+        let instant_prototype = intrinsics.temporal_instant_prototype();
+        
+        BuiltinFunctionBuilder::new_intrinsic_constructor::<InstantConstructor>(agent, realm)
+        .with_property_capacity(1)
+        .with_prototype_property(instant_prototype.into_object())
+        .build();
+        
+    }
+}
+/// %Temporal.Instant.Prototype%
+pub(crate) struct InstantPrototype;
+
+impl InstantPrototype {
+    pub fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>, gc: NoGcScope) {
+        let intrinsics = agent.get_realm_record_by_id(realm).intrinsics();
+        let this = intrinsics.temporal_instant_prototype();
+        let object_prototype = intrinsics.object_prototype();
+        let instant_constructor = intrinsics.temporal_instant();
+
+        OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
+            .with_property_capacity(1)  // TODO add correct property capacity
+            .with_prototype(object_prototype)
+            .with_constructor_property(instant_constructor)
+            // TODO add all prototype methods
+            .build();
+    }
+}
+/// HEAP DATA
+#[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
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Instant<'a>(BaseIndex<'a, InstantHeapData<'static>>);
+impl Instant<'_> {
+    //TODO
+    pub(crate) const fn _def() -> Self {
+        todo!()
+    }
+}
+bindable_handle!(Instant);
+
+impl<'a> From<Instant<'a>> for Value<'a> {
+    fn from(v: Instant<'a>) -> Self { todo!() }
+}
+impl<'a> From<Instant<'a>> for Object<'a> {
+    fn from(v: Instant<'a>) -> Self { todo!() }
+}
+impl<'a> TryFrom<Value<'a>> for Instant<'a> {
+    type Error = ();
+    fn try_from(v: Value<'a>) -> Result<Self, ()> {
+        todo!()
+    }
+}
+impl<'a> TryFrom<Object<'a>> for Instant<'a> {
+    type Error = ();
+    fn try_from(o: Object<'a>) -> Result<Self, ()> {
+        todo!()
+    }
+}
+
+// TODO impl trait bounds properly
+impl<'a> InternalSlots<'a> for Instant<'a> {
+    // TODO: Add TemporalInstant to ProtoIntrinsics
+    //const DEFAULT_PROTOTYPE: ProtoIntrinsics = ProtoIntrinsics::TemporalInstant;
+    fn get_backing_object(self, agent: &Agent) -> Option<OrdinaryObject<'static>> {
+        todo!()
+    }
+    fn set_backing_object(self, agent: &mut Agent, backing_object: OrdinaryObject<'static>) {
+        todo!()
+    }
+    
+}
+
+impl HeapMarkAndSweep for Instant<'static> {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        todo!()
+    }
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        todo!()
+    }
+}
+
+impl<'a> CreateHeapData<InstantHeapData<'a>, Instant<'a>> for Heap {
+    fn create(&mut self, data: InstantHeapData<'a>) -> Instant<'a> {
+        todo!()
+    }
+}

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

@@ -40,7 +40,9 @@ use crate::ecmascript::builtins::structured_data::shared_array_buffer_objects::{
     shared_array_buffer_prototype::SharedArrayBufferPrototype,
 };
 #[cfg(feature = "temporal")]
-use crate::ecmascript::builtins::temporal::TemporalObject;
+use crate::ecmascript::builtins::temporal::{
+    instant::InstantConstructor, instant::InstantPrototype, TemporalObject
+};
 #[cfg(feature = "regexp")]
 use crate::ecmascript::builtins::text_processing::regexp_objects::{
     regexp_constructor::RegExpConstructor, regexp_prototype::RegExpPrototype,
@@ -65,7 +67,6 @@ use crate::ecmascript::builtins::{
 use crate::{
     ecmascript::{
         builtins::{
-            Array, BuiltinFunction,
             control_abstraction_objects::{
                 async_function_objects::{
                     async_function_constructor::AsyncFunctionConstructor,
@@ -88,31 +89,22 @@ use crate::{
                 promise_objects::{
                     promise_constructor::PromiseConstructor, promise_prototype::PromisePrototype,
                 },
-            },
-            global_object::GlobalObject,
-            indexed_collections::array_objects::{
+            }, global_object::GlobalObject, indexed_collections::array_objects::{
                 array_constructor::ArrayConstructor,
                 array_iterator_objects::array_iterator_prototype::ArrayIteratorPrototype,
                 array_prototype::ArrayPrototype,
-            },
-            iteration::iterator_constructor::IteratorConstructor,
-            keyed_collections::map_objects::{
+            }, iteration::iterator_constructor::IteratorConstructor, keyed_collections::map_objects::{
                 map_constructor::MapConstructor,
                 map_iterator_objects::map_iterator_prototype::MapIteratorPrototype,
                 map_prototype::MapPrototype,
-            },
-            managing_memory::finalization_registry_objects::{
+            }, managing_memory::finalization_registry_objects::{
                 finalization_registry_constructor::FinalizationRegistryConstructor,
                 finalization_registry_prototype::FinalizationRegistryPrototype,
-            },
-            ordinary::shape::ObjectShape,
-            primitive_objects::{PrimitiveObject, PrimitiveObjectHeapData},
-            reflection::{proxy_constructor::ProxyConstructor, reflect_object::ReflectObject},
-            text_processing::string_objects::{
+            }, ordinary::shape::ObjectShape, primitive_objects::{PrimitiveObject, PrimitiveObjectHeapData}, reflection::{proxy_constructor::ProxyConstructor, reflect_object::ReflectObject}, text_processing::string_objects::{
                 string_constructor::StringConstructor,
                 string_iterator_objects::StringIteratorPrototype,
                 string_prototype::StringPrototype,
-            },
+            }, Array, BuiltinFunction
         },
         execution::Agent,
         fundamental_objects::{
@@ -148,10 +140,7 @@ use crate::{
     },
     engine::context::NoGcScope,
     heap::{
-        CompactionLists, HeapMarkAndSweep, IntrinsicConstructorIndexes, IntrinsicFunctionIndexes,
-        IntrinsicObjectIndexes, IntrinsicObjectShapes, IntrinsicPrimitiveObjectIndexes, WorkQueues,
-        indexes::BaseIndex, intrinsic_function_count, intrinsic_object_count,
-        intrinsic_primitive_object_count,
+        indexes::BaseIndex, intrinsic_function_count, intrinsic_object_count, intrinsic_primitive_object_count, CompactionLists, HeapMarkAndSweep, IntrinsicConstructorIndexes, IntrinsicFunctionIndexes, IntrinsicObjectIndexes, IntrinsicObjectShapes, IntrinsicPrimitiveObjectIndexes, WorkQueues
     },
 };
 #[derive(Debug, Clone)]
@@ -308,9 +297,12 @@ impl Intrinsics {
         #[cfg(feature = "math")]
         MathObject::create_intrinsic(agent, realm, gc);
 
-        #[cfg(feature = "temporal")]
-        TemporalObject::create_intrinsic(agent, realm, gc);
-        
+        #[cfg(feature = "temporal")] {
+            TemporalObject::create_intrinsic(agent, realm, gc);
+            // Instant
+            InstantConstructor::create_intrinsic(agent, realm, gc);
+            InstantPrototype::create_intrinsic(agent, realm, gc);
+        }
 
         #[cfg(feature = "date")]
         DatePrototype::create_intrinsic(agent, realm);
@@ -1017,6 +1009,15 @@ impl Intrinsics {
         IntrinsicObjectIndexes::TemporalObject.get_backing_object(self.object_index_base)
     }
 
+    /// %Temporal.Instant%
+    pub(crate) const fn temporal_instant(&self) -> BuiltinFunction<'static> {
+        IntrinsicConstructorIndexes::TemporalInstant.get_builtin_function(self.builtin_function_index_base)
+    }
+    /// %Temporal.Instant.Prototype%
+    pub(crate) const fn temporal_instant_prototype(&self) -> OrdinaryObject<'static> {
+        IntrinsicObjectIndexes::TemporalInstantPrototype.get_backing_object(self.object_index_base)
+    }
+
     /// %Number.prototype%
     pub(crate) fn number_prototype(&self) -> PrimitiveObject<'static> {
         IntrinsicPrimitiveObjectIndexes::NumberPrototype

nova_vm/src/heap/heap_constants.rs

@@ -36,6 +36,10 @@ pub(crate) enum IntrinsicObjectIndexes {
     DatePrototype,
     #[cfg(feature = "temporal")]
     TemporalObject,
+    #[cfg(feature = "temporal")]
+    TemporalInstant,
+    #[cfg(feature = "temporal")]
+    TemporalInstantPrototype,
     // Text processing
     #[cfg(feature = "regexp")]
     RegExpPrototype,
@@ -172,6 +176,8 @@ pub(crate) enum IntrinsicConstructorIndexes {
     BigInt,
     #[cfg(feature = "date")]
     Date,
+    #[cfg(feature = "temporal")]
+    TemporalInstant,
 
     // Text processing
     String,