feat(cli): add now builtin function

Author: omfj

nova_cli/src/helper.rs

@@ -9,8 +9,8 @@ use nova_vm::{
         builtins::{ArgumentsList, Behaviour, BuiltinFunctionArgs, create_builtin_function},
         execution::{Agent, JsResult, agent::ExceptionType},
         types::{
-            InternalMethods, IntoValue, Object, OrdinaryObject, PropertyDescriptor, PropertyKey,
-            String, Value,
+            BigInt, InternalMethods, IntoValue, Object, OrdinaryObject, PropertyDescriptor,
+            PropertyKey, String, Value,
         },
     },
     engine::{
@@ -82,6 +82,21 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
         Ok(String::from_string(agent, file, gc.into_nogc()).into_value())
     }
 
+    // 'now' function
+    fn now<'gc>(
+        agent: &mut Agent,
+        _this: Value,
+        _args: ArgumentsList,
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let bigint = BigInt::from_u128(agent, now, gc.into_nogc());
+        Ok(bigint.into_value())
+    }
+
     let function = create_builtin_function(
         agent,
         Behaviour::Regular(print),
@@ -127,6 +142,29 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
             gc.reborrow(),
         )
         .unwrap();
+
+    let function = create_builtin_function(
+        agent,
+        Behaviour::Regular(now),
+        BuiltinFunctionArgs::new(0, "now"),
+        gc.nogc(),
+    );
+    let property_key = PropertyKey::from_static_str(agent, "now", gc.nogc());
+    global
+        .get(agent)
+        .internal_define_own_property(
+            agent,
+            property_key.unbind(),
+            PropertyDescriptor {
+                value: Some(function.into_value().unbind()),
+                writable: Some(true),
+                enumerable: Some(false),
+                configurable: Some(true),
+                ..Default::default()
+            },
+            gc.reborrow(),
+        )
+        .unwrap();
 }
 
 pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object, mut gc: GcScope) {

nova_vm/src/ecmascript/types/language/bigint.rs

@@ -189,6 +189,19 @@ impl<'a> BigInt<'a> {
         Self::SmallBigInt(SmallBigInt::zero())
     }
 
+    pub fn from_bigint(agent: &mut Agent, bigint: &BigIntHeapData, gc: NoGcScope<'a, '_>) -> Self {
+        if let Ok(result) = SmallBigInt::try_from(&bigint.data) {
+            Self::SmallBigInt(result)
+        } else {
+            agent
+                .heap
+                .create(BigIntHeapData {
+                    data: bigint.data.clone(),
+                })
+                .bind(gc)
+        }
+    }
+
     #[inline]
     pub fn from_i64(agent: &mut Agent, value: i64) -> Self {
         if let Ok(result) = SmallBigInt::try_from(value) {
@@ -207,6 +220,30 @@ impl<'a> BigInt<'a> {
         }
     }
 
+    #[inline]
+    pub fn from_i128(agent: &mut Agent, value: i128, gc: NoGcScope<'a, '_>) -> Self {
+        if let Ok(result) = SmallBigInt::try_from(value) {
+            Self::SmallBigInt(result)
+        } else {
+            agent
+                .heap
+                .create(BigIntHeapData { data: value.into() })
+                .bind(gc)
+        }
+    }
+
+    #[inline]
+    pub fn from_u128(agent: &mut Agent, value: u128, gc: NoGcScope<'a, '_>) -> Self {
+        if let Ok(result) = SmallBigInt::try_from(value) {
+            Self::SmallBigInt(result)
+        } else {
+            agent
+                .heap
+                .create(BigIntHeapData { data: value.into() })
+                .bind(gc)
+        }
+    }
+
     #[inline]
     pub(crate) fn from_num_bigint(agent: &mut Agent, value: num_bigint::BigInt) -> Self {
         if let Ok(result) = SmallBigInt::try_from(&value) {

nova_vm/src/engine/context.rs

@@ -437,6 +437,8 @@ trivially_bindable!(i32);
 trivially_bindable!(u32);
 trivially_bindable!(i64);
 trivially_bindable!(u64);
+trivially_bindable!(i128);
+trivially_bindable!(u128);
 trivially_bindable!(isize);
 trivially_bindable!(usize);
 #[cfg(feature = "proposal-float16array")]

nova_vm/src/engine/small_bigint.rs

@@ -188,6 +188,18 @@ impl TryFrom<u64> for SmallBigInt {
     }
 }
 
+impl TryFrom<u128> for SmallBigInt {
+    type Error = ();
+    fn try_from(value: u128) -> Result<Self, Self::Error> {
+        if (Self::MIN as u128..=Self::MAX as u128).contains(&value) {
+            // SAFETY: Checked to be in range.
+            Ok(unsafe { Self::from_i64_unchecked(value as i64) })
+        } else {
+            Err(())
+        }
+    }
+}
+
 impl TryFrom<usize> for SmallBigInt {
     type Error = ();
     fn try_from(value: usize) -> Result<Self, Self::Error> {