refactor: migrate ext/node/ops to op2 (#20805)

2 files changed, 73 insertions, 68 deletions

diff --git a/ext/node/ops/crypto/mod.rs b/ext/node/ops/crypto/mod.rs
index ce45c0640..372f7dcb5 100644
--- a/ext/node/ops/crypto/mod.rs
+++ b/ext/node/ops/crypto/mod.rs
@@ -2,9 +2,7 @@
 use deno_core::error::generic_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::op;
 use deno_core::op2;
-use deno_core::serde_v8;
 use deno_core::unsync::spawn_blocking;
 use deno_core::JsBuffer;
 use deno_core::OpState;
@@ -41,36 +39,42 @@ mod digest;
 mod primes;
 pub mod x509;
 
-#[op]
-pub fn op_node_check_prime(num: serde_v8::BigInt, checks: usize) -> bool {
-  primes::is_probably_prime(&num, checks)
+#[op2(fast)]
+pub fn op_node_check_prime(
+  #[bigint] num: i64,
+  #[number] checks: usize,
+) -> bool {
+  primes::is_probably_prime(&BigInt::from(num), checks)
 }
 
-// TODO(bartlomieju): blocked on `op2` crashing on `ArrayBufferView`
-#[op]
+#[op2(fast)]
 pub fn op_node_check_prime_bytes(
-  bytes: &[u8],
-  checks: usize,
+  #[anybuffer] bytes: &[u8],
+  #[number] checks: usize,
 ) -> Result<bool, AnyError> {
   let candidate = BigInt::from_bytes_be(num_bigint::Sign::Plus, bytes);
   Ok(primes::is_probably_prime(&candidate, checks))
 }
 
-#[op]
+#[op2(async)]
 pub async fn op_node_check_prime_async(
-  num: serde_v8::BigInt,
-  checks: usize,
+  #[bigint] num: i64,
+  #[number] checks: usize,
 ) -> Result<bool, AnyError> {
   // TODO(@littledivy): use rayon for CPU-bound tasks
-  Ok(spawn_blocking(move || primes::is_probably_prime(&num, checks)).await?)
+  Ok(
+    spawn_blocking(move || {
+      primes::is_probably_prime(&BigInt::from(num), checks)
+    })
+    .await?,
+  )
 }
 
-// TODO(bartlomieju): blocked on `op2` supporting returning a future
-#[op]
+#[op2(async)]
 pub fn op_node_check_prime_bytes_async(
-  bytes: &[u8],
-  checks: usize,
-) -> Result<impl Future<Output = Result<bool, AnyError>> + 'static, AnyError> {
+  #[anybuffer] bytes: &[u8],
+  #[number] checks: usize,
+) -> Result<impl Future<Output = Result<bool, AnyError>>, AnyError> {
   let candidate = BigInt::from_bytes_be(num_bigint::Sign::Plus, bytes);
   // TODO(@littledivy): use rayon for CPU-bound tasks
   Ok(async move {
@@ -942,16 +946,17 @@ fn scrypt(
   }
 }
 
-#[op]
+#[allow(clippy::too_many_arguments)]
+#[op2]
 pub fn op_node_scrypt_sync(
-  password: StringOrBuffer,
-  salt: StringOrBuffer,
-  keylen: u32,
-  cost: u32,
-  block_size: u32,
-  parallelization: u32,
-  maxmem: u32,
-  output_buffer: &mut [u8],
+  #[serde] password: StringOrBuffer,
+  #[serde] salt: StringOrBuffer,
+  #[smi] keylen: u32,
+  #[smi] cost: u32,
+  #[smi] block_size: u32,
+  #[smi] parallelization: u32,
+  #[smi] maxmem: u32,
+  #[anybuffer] output_buffer: &mut [u8],
 ) -> Result<(), AnyError> {
   scrypt(
     password,
@@ -965,15 +970,16 @@ pub fn op_node_scrypt_sync(
   )
 }
 
-#[op]
+#[op2(async)]
+#[serde]
 pub async fn op_node_scrypt_async(
-  password: StringOrBuffer,
-  salt: StringOrBuffer,
-  keylen: u32,
-  cost: u32,
-  block_size: u32,
-  parallelization: u32,
-  maxmem: u32,
+  #[serde] password: StringOrBuffer,
+  #[serde] salt: StringOrBuffer,
+  #[smi] keylen: u32,
+  #[smi] cost: u32,
+  #[smi] block_size: u32,
+  #[smi] parallelization: u32,
+  #[smi] maxmem: u32,
 ) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut output_buffer = vec![0u8; keylen as usize];
diff --git a/ext/node/ops/zlib/mod.rs b/ext/node/ops/zlib/mod.rs
index dc1a49715..d14b4342f 100644
--- a/ext/node/ops/zlib/mod.rs
+++ b/ext/node/ops/zlib/mod.rs
@@ -3,7 +3,6 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::op;
 use deno_core::op2;
 use deno_core::OpState;
 use libz_sys::*;
@@ -285,21 +284,20 @@ pub fn op_zlib_close(
   Ok(())
 }
 
-#[op]
+#[allow(clippy::too_many_arguments)]
+#[op2(async)]
+#[serde]
 pub fn op_zlib_write_async(
   state: Rc<RefCell<OpState>>,
-  handle: u32,
-  flush: i32,
-  input: &[u8],
-  in_off: u32,
-  in_len: u32,
-  out: &mut [u8],
-  out_off: u32,
-  out_len: u32,
-) -> Result<
-  impl Future<Output = Result<(i32, u32, u32), AnyError>> + 'static,
-  AnyError,
-> {
+  #[smi] handle: u32,
+  #[smi] flush: i32,
+  #[buffer] input: &[u8],
+  #[smi] in_off: u32,
+  #[smi] in_len: u32,
+  #[buffer] out: &mut [u8],
+  #[smi] out_off: u32,
+  #[smi] out_len: u32,
+) -> Result<impl Future<Output = Result<(i32, u32, u32), AnyError>>, AnyError> {
   let mut state_mut = state.borrow_mut();
   let resource = zlib(&mut state_mut, handle)?;
 
@@ -318,19 +316,20 @@ pub fn op_zlib_write_async(
   })
 }
 
-// TODO(bartlomieju): op2 can't seem to handle clippy ignore here
-#[op]
+#[allow(clippy::too_many_arguments)]
+#[op2(fast)]
+#[smi]
 pub fn op_zlib_write(
   state: &mut OpState,
-  handle: u32,
-  flush: i32,
-  input: &[u8],
-  in_off: u32,
-  in_len: u32,
-  out: &mut [u8],
-  out_off: u32,
-  out_len: u32,
-  result: &mut [u32],
+  #[smi] handle: u32,
+  #[smi] flush: i32,
+  #[buffer] input: &[u8],
+  #[smi] in_off: u32,
+  #[smi] in_len: u32,
+  #[buffer] out: &mut [u8],
+  #[smi] out_off: u32,
+  #[smi] out_len: u32,
+  #[buffer] result: &mut [u32],
 ) -> Result<i32, AnyError> {
   let resource = zlib(state, handle)?;
 
@@ -345,16 +344,16 @@ pub fn op_zlib_write(
   Ok(zlib.err)
 }
 
-// TODO(bartlomieju): op2 can't seem to handle clippy ignore here
-#[op]
+#[op2(fast)]
+#[smi]
 pub fn op_zlib_init(
   state: &mut OpState,
-  handle: u32,
-  level: i32,
-  window_bits: i32,
-  mem_level: i32,
-  strategy: i32,
-  dictionary: &[u8],
+  #[smi] handle: u32,
+  #[smi] level: i32,
+  #[smi] window_bits: i32,
+  #[smi] mem_level: i32,
+  #[smi] strategy: i32,
+  #[buffer] dictionary: &[u8],
 ) -> Result<i32, AnyError> {
   let resource = zlib(state, handle)?;
   let mut zlib = resource.inner.borrow_mut();