Merge pull request #9 from sebastianjacmatt/temporal_duration_stubs

plain_time constructor and prototype structs and stubs

Author: sebastianjacmatt

nova_vm/src/builtin_strings

@@ -455,6 +455,7 @@ SyntaxError
 #[cfg(feature = "temporal")]Temporal
 #[cfg(feature = "temporal")]Temporal.Duration
 #[cfg(feature = "temporal")]Temporal.Instant
+#[cfg(feature = "temporal")]Temporal.PlainTime
 #[cfg(feature = "math")]tan
 #[cfg(feature = "math")]tanh
 #[cfg(feature = "regexp")]test

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

@@ -166,7 +166,7 @@ impl<'a> CreateHeapData<DurationHeapData<'a>, TemporalDuration<'a>> for Heap {
 /// It creates a Temporal.Duration instance and fills
 /// the internal slots with valid values.
 /// It performs the following steps when called:
-pub(crate) fn create_temporal_duration<'gc>(// years,
+pub(crate) fn _create_temporal_duration<'gc>(// years,
     // months,
     // weeks,
     // days,
@@ -449,7 +449,7 @@ pub(crate) fn to_temporal_partial_duration_record<'gc>(
 /// duration (a Temporal.Duration) and returns a Temporal.Duration.
 /// It returns a new Temporal.Duration instance that is the
 /// negation of duration.
-pub(crate) fn create_negated_temporal_duration<'gc>(
+pub(crate) fn _create_negated_temporal_duration<'gc>(
     _agent: &mut Agent,
     _item: temporal_rs::Duration,
     mut _gc: GcScope<'gc, '_>,

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

@@ -17,6 +17,8 @@ use crate::{
 };
 
 pub(crate) mod data;
+pub mod plain_time_constructor;
+pub mod plain_time_prototype;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]

nova_vm/src/ecmascript/builtins/temporal/plain_time/plain_time_constructor.rs

@@ -0,0 +1,46 @@
+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 TemporalPlainTimeConstructor;
+
+impl Builtin for TemporalPlainTimeConstructor {
+    const NAME: String<'static> = BUILTIN_STRING_MEMORY.PlainTime;
+    const LENGTH: u8 = 1;
+    const BEHAVIOUR: Behaviour = Behaviour::Constructor(TemporalPlainTimeConstructor::constructor);
+}
+
+impl BuiltinIntrinsicConstructor for TemporalPlainTimeConstructor {
+    const INDEX: IntrinsicConstructorIndexes = IntrinsicConstructorIndexes::TemporalPlainTime;
+}
+
+impl TemporalPlainTimeConstructor {
+    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 plain_time_prototype = intrinsics.temporal_plain_time_prototype();
+
+        BuiltinFunctionBuilder::new_intrinsic_constructor::<TemporalPlainTimeConstructor>(
+            agent, realm,
+        )
+        .with_property_capacity(1)
+        .with_prototype_property(plain_time_prototype.into_object())
+        .build();
+    }
+}

nova_vm/src/ecmascript/builtins/temporal/plain_time/plain_time_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 TemporalPlainTimePrototype;
+impl TemporalPlainTimePrototype {
+    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_plain_time_prototype();
+        let object_prototype = intrinsics.object_prototype();
+        let plain_time_constructor = intrinsics.temporal_plain_time();
+
+        OrdinaryObjectBuilder::new_intrinsic_object(agent, realm, this)
+            .with_property_capacity(2)
+            .with_prototype(object_prototype)
+            .with_constructor_property(plain_time_constructor)
+            .with_property(|builder| {
+                builder
+                    .with_key(WellKnownSymbolIndexes::ToStringTag.into())
+                    .with_value_readonly(BUILTIN_STRING_MEMORY.Temporal_PlainTime.into())
+                    .with_enumerable(false)
+                    .with_configurable(true)
+                    .build()
+            })
+            .build();
+    }
+}

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

@@ -50,6 +50,10 @@ use crate::ecmascript::builtins::temporal::{
         instant_constructor::TemporalInstantConstructor,
         instant_prototype::TemporalInstantPrototype,
     },
+    plain_time::{
+        plain_time_constructor::TemporalPlainTimeConstructor,
+        plain_time_prototype::TemporalPlainTimePrototype,
+    },
 };
 
 #[cfg(feature = "regexp")]
@@ -337,6 +341,10 @@ impl Intrinsics {
         TemporalDurationPrototype::create_intrinsic(agent, realm, gc);
         #[cfg(feature = "temporal")]
         TemporalDurationConstructor::create_intrinsic(agent, realm, gc);
+        #[cfg(feature = "temporal")]
+        TemporalPlainTimePrototype::create_intrinsic(agent, realm, gc);
+        #[cfg(feature = "temporal")]
+        TemporalPlainTimeConstructor::create_intrinsic(agent, realm, gc);
         #[cfg(feature = "date")]
         DatePrototype::create_intrinsic(agent, realm);
         #[cfg(feature = "date")]