feat(ops): op2 support for u64/i64 return values (#73)

We can support u64/i64 in the return value position, though due to an unknown bug in fastcalls (unsure if it is in rusty_v8 or deno_core), we cannot make them fast yet. In anticipation that this will be fixed at some point, we start using FastCall::new_with_bigint.

Using a 64-bit value requires #[bigint] to remind implementers that this is more than just a simple number and may have some performance implications.

Author: mmastrac

core/runtime/ops.rs

@@ -609,6 +609,8 @@ mod tests {
       op_test_bool_result,
       op_test_float,
       op_test_float_result,
+      op_test_i64,
+      op_test_u64,
       op_test_string_owned,
       op_test_string_ref,
       op_test_string_cow,
@@ -979,6 +981,38 @@ mod tests {
     Ok(())
   }
 
+  #[op2(core)]
+  #[bigint]
+  pub fn op_test_u64(#[bigint] input: u64) -> u64 {
+    input
+  }
+
+  #[op2(core)]
+  #[bigint]
+  pub fn op_test_i64(#[bigint] input: i64) -> i64 {
+    input
+  }
+
+  #[tokio::test]
+  pub async fn test_op_64() -> Result<(), Box<dyn std::error::Error>> {
+    run_test2(
+      10,
+      "op_test_i64",
+      &format!("assert(op_test_i64({}n) == {}n)", i64::MAX, i64::MAX),
+    )?;
+    run_test2(
+      10,
+      "op_test_i64",
+      &format!("assert(op_test_i64({}n) == {}n)", i64::MIN, i64::MIN),
+    )?;
+    run_test2(
+      10,
+      "op_test_u64",
+      &format!("assert(op_test_u64({}n) == {}n)", u64::MAX, u64::MAX),
+    )?;
+    Ok(())
+  }
+
   #[op2(core, fast)]
   pub fn op_test_string_owned(#[string] s: String) -> u32 {
     s.len() as _
@@ -1338,9 +1372,9 @@ mod tests {
   #[op2(core, fast)]
   pub fn op_buffer_slice(
     #[buffer] input: &[u8],
-    inlen: usize,
+    #[bigint] inlen: usize,
     #[buffer] output: &mut [u8],
-    outlen: usize,
+    #[bigint] outlen: usize,
   ) {
     assert_eq!(inlen, input.len());
     assert_eq!(outlen, output.len());

ops/op2/README.md

@@ -145,7 +145,7 @@ Uint32, Int32, Number, BigInt
 <td>
 
 ```rust
-i64
+#[bigint] i64
 ```
 
 </td><td>
@@ -159,7 +159,7 @@ Uint32, Int32, Number, BigInt
 <td>
 
 ```rust
-u64
+#[bigint] u64
 ```
 
 </td><td>
@@ -173,7 +173,7 @@ Uint32, Int32, Number, BigInt
 <td>
 
 ```rust
-isize
+#[bigint] isize
 ```
 
 </td><td>
@@ -187,7 +187,7 @@ Uint32, Int32, Number, BigInt
 <td>
 
 ```rust
-usize
+#[bigint] usize
 ```
 
 </td><td>
@@ -782,6 +782,62 @@ Uint32
 <tr>
 <td>
 
+```rust
+#[bigint] i64
+```
+
+</td><td>
+
+</td><td>
+BigInt
+</td><td>
+
+</td></tr>
+<tr>
+<td>
+
+```rust
+#[bigint] u64
+```
+
+</td><td>
+
+</td><td>
+BigInt
+</td><td>
+
+</td></tr>
+<tr>
+<td>
+
+```rust
+#[bigint] isize
+```
+
+</td><td>
+
+</td><td>
+BigInt
+</td><td>
+
+</td></tr>
+<tr>
+<td>
+
+```rust
+#[bigint] usize
+```
+
+</td><td>
+
+</td><td>
+BigInt
+</td><td>
+
+</td></tr>
+<tr>
+<td>
+
 ```rust
 f32
 ```

ops/op2/dispatch_fast.rs

@@ -258,7 +258,9 @@ pub fn generate_dispatch_fast(
   let fast_definition = quote! {
     use #deno_core::v8::fast_api::Type;
     use #deno_core::v8::fast_api::CType;
-    #deno_core::v8::fast_api::FastFunction::new(
+    // TODO(mmastrac): We're setting this up for future success but returning
+    // u64/i64 from fastcall functions does not work. Test again in the future.
+    #deno_core::v8::fast_api::FastFunction::new_with_bigint(
       &[ Type::V8Value, #( #input_types ),* ],
       #output_type,
       Self::#fast_function as *const ::std::ffi::c_void
@@ -473,10 +475,14 @@ fn map_retval_to_v8_fastcall_type(
     | Arg::Numeric(NumericArg::i16)
     | Arg::Numeric(NumericArg::i8) => V8FastCallType::I32,
     Arg::Numeric(NumericArg::u64) | Arg::Numeric(NumericArg::usize) => {
-      V8FastCallType::U64
+      // TODO(mmastrac): In my testing, I was not able to get this working properly
+      // V8FastCallType::U64
+      return Ok(None);
     }
     Arg::Numeric(NumericArg::i64) | Arg::Numeric(NumericArg::isize) => {
-      V8FastCallType::I64
+      // TODO(mmastrac): In my testing, I was not able to get this working properly
+      // V8FastCallType::I64
+      return Ok(None);
     }
     Arg::Numeric(NumericArg::f32) => V8FastCallType::F32,
     Arg::Numeric(NumericArg::f64) => V8FastCallType::F64,

ops/op2/dispatch_slow.rs

@@ -525,6 +525,16 @@ pub fn return_value_infallible(
     | Arg::Numeric(NumericArg::i32) => {
       quote!(#retval.set_int32(#result as i32);)
     }
+    Arg::Numeric(NumericArg::i64 | NumericArg::isize) => {
+      *needs_retval = true;
+      *needs_scope = true;
+      quote!(#retval.set(v8::BigInt::new_from_i64(&mut scope, #result as _).into());)
+    }
+    Arg::Numeric(NumericArg::u64 | NumericArg::usize) => {
+      *needs_retval = true;
+      *needs_scope = true;
+      quote!(#retval.set(v8::BigInt::new_from_u64(&mut #scope, #result as _).into());)
+    }
     Arg::Numeric(NumericArg::f32 | NumericArg::f64) => {
       quote!(#retval.set_double(#result as _);)
     }