chore: enable clippy unused_async rule (#22834)

8 files changed, 357 insertions, 342 deletions

diff --git a/ext/crypto/lib.rs b/ext/crypto/lib.rs
index 5e99e99df..8a526bb40 100644
--- a/ext/crypto/lib.rs
+++ b/ext/crypto/lib.rs
@@ -198,104 +198,106 @@ pub async fn op_crypto_sign_key(
   #[serde] args: SignArg,
   #[buffer] zero_copy: JsBuffer,
 ) -> Result<ToJsBuffer, AnyError> {
-  let data = &*zero_copy;
-  let algorithm = args.algorithm;
-
-  let signature = match algorithm {
-    Algorithm::RsassaPkcs1v15 => {
-      use rsa::pkcs1v15::SigningKey;
-      let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
-      match args
-        .hash
-        .ok_or_else(|| type_error("Missing argument hash".to_string()))?
-      {
-        CryptoHash::Sha1 => {
-          let signing_key = SigningKey::<Sha1>::new(private_key);
-          signing_key.sign(data)
-        }
-        CryptoHash::Sha256 => {
-          let signing_key = SigningKey::<Sha256>::new(private_key);
-          signing_key.sign(data)
-        }
-        CryptoHash::Sha384 => {
-          let signing_key = SigningKey::<Sha384>::new(private_key);
-          signing_key.sign(data)
-        }
-        CryptoHash::Sha512 => {
-          let signing_key = SigningKey::<Sha512>::new(private_key);
-          signing_key.sign(data)
+  deno_core::unsync::spawn_blocking(move || {
+    let data = &*zero_copy;
+    let algorithm = args.algorithm;
+
+    let signature = match algorithm {
+      Algorithm::RsassaPkcs1v15 => {
+        use rsa::pkcs1v15::SigningKey;
+        let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
+        match args
+          .hash
+          .ok_or_else(|| type_error("Missing argument hash".to_string()))?
+        {
+          CryptoHash::Sha1 => {
+            let signing_key = SigningKey::<Sha1>::new(private_key);
+            signing_key.sign(data)
+          }
+          CryptoHash::Sha256 => {
+            let signing_key = SigningKey::<Sha256>::new(private_key);
+            signing_key.sign(data)
+          }
+          CryptoHash::Sha384 => {
+            let signing_key = SigningKey::<Sha384>::new(private_key);
+            signing_key.sign(data)
+          }
+          CryptoHash::Sha512 => {
+            let signing_key = SigningKey::<Sha512>::new(private_key);
+            signing_key.sign(data)
+          }
         }
+        .to_vec()
       }
-      .to_vec()
-    }
-    Algorithm::RsaPss => {
-      let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
-
-      let salt_len = args
-        .salt_length
-        .ok_or_else(|| type_error("Missing argument saltLength".to_string()))?
-        as usize;
-
-      let mut rng = OsRng;
-      match args
-        .hash
-        .ok_or_else(|| type_error("Missing argument hash".to_string()))?
-      {
-        CryptoHash::Sha1 => {
-          let signing_key = Pss::new_with_salt::<Sha1>(salt_len);
-          let hashed = Sha1::digest(data);
-          signing_key.sign(Some(&mut rng), &private_key, &hashed)?
-        }
-        CryptoHash::Sha256 => {
-          let signing_key = Pss::new_with_salt::<Sha256>(salt_len);
-          let hashed = Sha256::digest(data);
-          signing_key.sign(Some(&mut rng), &private_key, &hashed)?
-        }
-        CryptoHash::Sha384 => {
-          let signing_key = Pss::new_with_salt::<Sha384>(salt_len);
-          let hashed = Sha384::digest(data);
-          signing_key.sign(Some(&mut rng), &private_key, &hashed)?
-        }
-        CryptoHash::Sha512 => {
-          let signing_key = Pss::new_with_salt::<Sha512>(salt_len);
-          let hashed = Sha512::digest(data);
-          signing_key.sign(Some(&mut rng), &private_key, &hashed)?
+      Algorithm::RsaPss => {
+        let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
+
+        let salt_len = args.salt_length.ok_or_else(|| {
+          type_error("Missing argument saltLength".to_string())
+        })? as usize;
+
+        let mut rng = OsRng;
+        match args
+          .hash
+          .ok_or_else(|| type_error("Missing argument hash".to_string()))?
+        {
+          CryptoHash::Sha1 => {
+            let signing_key = Pss::new_with_salt::<Sha1>(salt_len);
+            let hashed = Sha1::digest(data);
+            signing_key.sign(Some(&mut rng), &private_key, &hashed)?
+          }
+          CryptoHash::Sha256 => {
+            let signing_key = Pss::new_with_salt::<Sha256>(salt_len);
+            let hashed = Sha256::digest(data);
+            signing_key.sign(Some(&mut rng), &private_key, &hashed)?
+          }
+          CryptoHash::Sha384 => {
+            let signing_key = Pss::new_with_salt::<Sha384>(salt_len);
+            let hashed = Sha384::digest(data);
+            signing_key.sign(Some(&mut rng), &private_key, &hashed)?
+          }
+          CryptoHash::Sha512 => {
+            let signing_key = Pss::new_with_salt::<Sha512>(salt_len);
+            let hashed = Sha512::digest(data);
+            signing_key.sign(Some(&mut rng), &private_key, &hashed)?
+          }
         }
+        .to_vec()
       }
-      .to_vec()
-    }
-    Algorithm::Ecdsa => {
-      let curve: &EcdsaSigningAlgorithm =
-        args.named_curve.ok_or_else(not_supported)?.into();
-
-      let rng = RingRand::SystemRandom::new();
-      let key_pair = EcdsaKeyPair::from_pkcs8(curve, &args.key.data, &rng)?;
-      // We only support P256-SHA256 & P384-SHA384. These are recommended signature pairs.
-      // https://briansmith.org/rustdoc/ring/signature/index.html#statics
-      if let Some(hash) = args.hash {
-        match hash {
-          CryptoHash::Sha256 | CryptoHash::Sha384 => (),
-          _ => return Err(type_error("Unsupported algorithm")),
-        }
-      };
-
-      let signature = key_pair.sign(&rng, data)?;
-
-      // Signature data as buffer.
-      signature.as_ref().to_vec()
-    }
-    Algorithm::Hmac => {
-      let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
+      Algorithm::Ecdsa => {
+        let curve: &EcdsaSigningAlgorithm =
+          args.named_curve.ok_or_else(not_supported)?.into();
+
+        let rng = RingRand::SystemRandom::new();
+        let key_pair = EcdsaKeyPair::from_pkcs8(curve, &args.key.data, &rng)?;
+        // We only support P256-SHA256 & P384-SHA384. These are recommended signature pairs.
+        // https://briansmith.org/rustdoc/ring/signature/index.html#statics
+        if let Some(hash) = args.hash {
+          match hash {
+            CryptoHash::Sha256 | CryptoHash::Sha384 => (),
+            _ => return Err(type_error("Unsupported algorithm")),
+          }
+        };
+
+        let signature = key_pair.sign(&rng, data)?;
+
+        // Signature data as buffer.
+        signature.as_ref().to_vec()
+      }
+      Algorithm::Hmac => {
+        let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
 
-      let key = HmacKey::new(hash, &args.key.data);
+        let key = HmacKey::new(hash, &args.key.data);
 
-      let signature = ring::hmac::sign(&key, data);
-      signature.as_ref().to_vec()
-    }
-    _ => return Err(type_error("Unsupported algorithm".to_string())),
-  };
+        let signature = ring::hmac::sign(&key, data);
+        signature.as_ref().to_vec()
+      }
+      _ => return Err(type_error("Unsupported algorithm".to_string())),
+    };
 
-  Ok(signature.into())
+    Ok(signature.into())
+  })
+  .await?
 }
 
 #[derive(Deserialize)]
@@ -314,106 +316,108 @@ pub async fn op_crypto_verify_key(
   #[serde] args: VerifyArg,
   #[buffer] zero_copy: JsBuffer,
 ) -> Result<bool, AnyError> {
-  let data = &*zero_copy;
-  let algorithm = args.algorithm;
-
-  let verification = match algorithm {
-    Algorithm::RsassaPkcs1v15 => {
-      use rsa::pkcs1v15::Signature;
-      use rsa::pkcs1v15::VerifyingKey;
-      let public_key = read_rsa_public_key(args.key)?;
-      let signature: Signature = args.signature.as_ref().try_into()?;
-      match args
-        .hash
-        .ok_or_else(|| type_error("Missing argument hash".to_string()))?
-      {
-        CryptoHash::Sha1 => {
-          let verifying_key = VerifyingKey::<Sha1>::new(public_key);
-          verifying_key.verify(data, &signature).is_ok()
-        }
-        CryptoHash::Sha256 => {
-          let verifying_key = VerifyingKey::<Sha256>::new(public_key);
-          verifying_key.verify(data, &signature).is_ok()
-        }
-        CryptoHash::Sha384 => {
-          let verifying_key = VerifyingKey::<Sha384>::new(public_key);
-          verifying_key.verify(data, &signature).is_ok()
-        }
-        CryptoHash::Sha512 => {
-          let verifying_key = VerifyingKey::<Sha512>::new(public_key);
-          verifying_key.verify(data, &signature).is_ok()
+  deno_core::unsync::spawn_blocking(move || {
+    let data = &*zero_copy;
+    let algorithm = args.algorithm;
+
+    let verification = match algorithm {
+      Algorithm::RsassaPkcs1v15 => {
+        use rsa::pkcs1v15::Signature;
+        use rsa::pkcs1v15::VerifyingKey;
+        let public_key = read_rsa_public_key(args.key)?;
+        let signature: Signature = args.signature.as_ref().try_into()?;
+        match args
+          .hash
+          .ok_or_else(|| type_error("Missing argument hash".to_string()))?
+        {
+          CryptoHash::Sha1 => {
+            let verifying_key = VerifyingKey::<Sha1>::new(public_key);
+            verifying_key.verify(data, &signature).is_ok()
+          }
+          CryptoHash::Sha256 => {
+            let verifying_key = VerifyingKey::<Sha256>::new(public_key);
+            verifying_key.verify(data, &signature).is_ok()
+          }
+          CryptoHash::Sha384 => {
+            let verifying_key = VerifyingKey::<Sha384>::new(public_key);
+            verifying_key.verify(data, &signature).is_ok()
+          }
+          CryptoHash::Sha512 => {
+            let verifying_key = VerifyingKey::<Sha512>::new(public_key);
+            verifying_key.verify(data, &signature).is_ok()
+          }
         }
       }
-    }
-    Algorithm::RsaPss => {
-      let public_key = read_rsa_public_key(args.key)?;
-      let signature = args.signature.as_ref();
-
-      let salt_len = args
-        .salt_length
-        .ok_or_else(|| type_error("Missing argument saltLength".to_string()))?
-        as usize;
-
-      match args
-        .hash
-        .ok_or_else(|| type_error("Missing argument hash".to_string()))?
-      {
-        CryptoHash::Sha1 => {
-          let pss = Pss::new_with_salt::<Sha1>(salt_len);
-          let hashed = Sha1::digest(data);
-          pss.verify(&public_key, &hashed, signature).is_ok()
-        }
-        CryptoHash::Sha256 => {
-          let pss = Pss::new_with_salt::<Sha256>(salt_len);
-          let hashed = Sha256::digest(data);
-          pss.verify(&public_key, &hashed, signature).is_ok()
-        }
-        CryptoHash::Sha384 => {
-          let pss = Pss::new_with_salt::<Sha384>(salt_len);
-          let hashed = Sha384::digest(data);
-          pss.verify(&public_key, &hashed, signature).is_ok()
-        }
-        CryptoHash::Sha512 => {
-          let pss = Pss::new_with_salt::<Sha512>(salt_len);
-          let hashed = Sha512::digest(data);
-          pss.verify(&public_key, &hashed, signature).is_ok()
+      Algorithm::RsaPss => {
+        let public_key = read_rsa_public_key(args.key)?;
+        let signature = args.signature.as_ref();
+
+        let salt_len = args.salt_length.ok_or_else(|| {
+          type_error("Missing argument saltLength".to_string())
+        })? as usize;
+
+        match args
+          .hash
+          .ok_or_else(|| type_error("Missing argument hash".to_string()))?
+        {
+          CryptoHash::Sha1 => {
+            let pss = Pss::new_with_salt::<Sha1>(salt_len);
+            let hashed = Sha1::digest(data);
+            pss.verify(&public_key, &hashed, signature).is_ok()
+          }
+          CryptoHash::Sha256 => {
+            let pss = Pss::new_with_salt::<Sha256>(salt_len);
+            let hashed = Sha256::digest(data);
+            pss.verify(&public_key, &hashed, signature).is_ok()
+          }
+          CryptoHash::Sha384 => {
+            let pss = Pss::new_with_salt::<Sha384>(salt_len);
+            let hashed = Sha384::digest(data);
+            pss.verify(&public_key, &hashed, signature).is_ok()
+          }
+          CryptoHash::Sha512 => {
+            let pss = Pss::new_with_salt::<Sha512>(salt_len);
+            let hashed = Sha512::digest(data);
+            pss.verify(&public_key, &hashed, signature).is_ok()
+          }
         }
       }
-    }
-    Algorithm::Hmac => {
-      let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
-      let key = HmacKey::new(hash, &args.key.data);
-      ring::hmac::verify(&key, data, &args.signature).is_ok()
-    }
-    Algorithm::Ecdsa => {
-      let signing_alg: &EcdsaSigningAlgorithm =
-        args.named_curve.ok_or_else(not_supported)?.into();
-      let verify_alg: &EcdsaVerificationAlgorithm =
-        args.named_curve.ok_or_else(not_supported)?.into();
-
-      let private_key;
-
-      let public_key_bytes = match args.key.r#type {
-        KeyType::Private => {
-          let rng = RingRand::SystemRandom::new();
-          private_key =
-            EcdsaKeyPair::from_pkcs8(signing_alg, &args.key.data, &rng)?;
-
-          private_key.public_key().as_ref()
-        }
-        KeyType::Public => &*args.key.data,
-        _ => return Err(type_error("Invalid Key format".to_string())),
-      };
-
-      let public_key =
-        ring::signature::UnparsedPublicKey::new(verify_alg, public_key_bytes);
-
-      public_key.verify(data, &args.signature).is_ok()
-    }
-    _ => return Err(type_error("Unsupported algorithm".to_string())),
-  };
+      Algorithm::Hmac => {
+        let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
+        let key = HmacKey::new(hash, &args.key.data);
+        ring::hmac::verify(&key, data, &args.signature).is_ok()
+      }
+      Algorithm::Ecdsa => {
+        let signing_alg: &EcdsaSigningAlgorithm =
+          args.named_curve.ok_or_else(not_supported)?.into();
+        let verify_alg: &EcdsaVerificationAlgorithm =
+          args.named_curve.ok_or_else(not_supported)?.into();
+
+        let private_key;
+
+        let public_key_bytes = match args.key.r#type {
+          KeyType::Private => {
+            let rng = RingRand::SystemRandom::new();
+            private_key =
+              EcdsaKeyPair::from_pkcs8(signing_alg, &args.key.data, &rng)?;
+
+            private_key.public_key().as_ref()
+          }
+          KeyType::Public => &*args.key.data,
+          _ => return Err(type_error("Invalid Key format".to_string())),
+        };
+
+        let public_key =
+          ring::signature::UnparsedPublicKey::new(verify_alg, public_key_bytes);
+
+        public_key.verify(data, &args.signature).is_ok()
+      }
+      _ => return Err(type_error("Unsupported algorithm".to_string())),
+    };
 
-  Ok(verification)
+    Ok(verification)
+  })
+  .await?
 }
 
 #[derive(Deserialize)]
@@ -437,153 +441,160 @@ pub async fn op_crypto_derive_bits(
   #[serde] args: DeriveKeyArg,
   #[buffer] zero_copy: Option<JsBuffer>,
 ) -> Result<ToJsBuffer, AnyError> {
-  let algorithm = args.algorithm;
-  match algorithm {
-    Algorithm::Pbkdf2 => {
-      let zero_copy = zero_copy.ok_or_else(not_supported)?;
-      let salt = &*zero_copy;
-      // The caller must validate these cases.
-      assert!(args.length > 0);
-      assert!(args.length % 8 == 0);
-
-      let algorithm = match args.hash.ok_or_else(not_supported)? {
-        CryptoHash::Sha1 => pbkdf2::PBKDF2_HMAC_SHA1,
-        CryptoHash::Sha256 => pbkdf2::PBKDF2_HMAC_SHA256,
-        CryptoHash::Sha384 => pbkdf2::PBKDF2_HMAC_SHA384,
-        CryptoHash::Sha512 => pbkdf2::PBKDF2_HMAC_SHA512,
-      };
-
-      // This will never panic. We have already checked length earlier.
-      let iterations =
-        NonZeroU32::new(args.iterations.ok_or_else(not_supported)?).unwrap();
-      let secret = args.key.data;
-      let mut out = vec![0; args.length / 8];
-      pbkdf2::derive(algorithm, iterations, salt, &secret, &mut out);
-      Ok(out.into())
-    }
-    Algorithm::Ecdh => {
-      let named_curve = args
-        .named_curve
-        .ok_or_else(|| type_error("Missing argument namedCurve".to_string()))?;
-
-      let public_key = args
-        .public_key
-        .ok_or_else(|| type_error("Missing argument publicKey"))?;
-
-      match named_curve {
-        CryptoNamedCurve::P256 => {
-          let secret_key = p256::SecretKey::from_pkcs8_der(&args.key.data)
-            .map_err(|_| type_error("Unexpected error decoding private key"))?;
-
-          let public_key = match public_key.r#type {
-            KeyType::Private => {
-              p256::SecretKey::from_pkcs8_der(&public_key.data)
-                .map_err(|_| {
-                  type_error("Unexpected error decoding private key")
-                })?
-                .public_key()
-            }
-            KeyType::Public => {
-              let point = p256::EncodedPoint::from_bytes(public_key.data)
-                .map_err(|_| {
-                  type_error("Unexpected error decoding private key")
-                })?;
-
-              let pk = p256::PublicKey::from_encoded_point(&point);
-              // pk is a constant time Option.
-              if pk.is_some().into() {
-                pk.unwrap()
-              } else {
-                return Err(type_error(
-                  "Unexpected error decoding private key",
-                ));
+  deno_core::unsync::spawn_blocking(move || {
+    let algorithm = args.algorithm;
+    match algorithm {
+      Algorithm::Pbkdf2 => {
+        let zero_copy = zero_copy.ok_or_else(not_supported)?;
+        let salt = &*zero_copy;
+        // The caller must validate these cases.
+        assert!(args.length > 0);
+        assert!(args.length % 8 == 0);
+
+        let algorithm = match args.hash.ok_or_else(not_supported)? {
+          CryptoHash::Sha1 => pbkdf2::PBKDF2_HMAC_SHA1,
+          CryptoHash::Sha256 => pbkdf2::PBKDF2_HMAC_SHA256,
+          CryptoHash::Sha384 => pbkdf2::PBKDF2_HMAC_SHA384,
+          CryptoHash::Sha512 => pbkdf2::PBKDF2_HMAC_SHA512,
+        };
+
+        // This will never panic. We have already checked length earlier.
+        let iterations =
+          NonZeroU32::new(args.iterations.ok_or_else(not_supported)?).unwrap();
+        let secret = args.key.data;
+        let mut out = vec![0; args.length / 8];
+        pbkdf2::derive(algorithm, iterations, salt, &secret, &mut out);
+        Ok(out.into())
+      }
+      Algorithm::Ecdh => {
+        let named_curve = args.named_curve.ok_or_else(|| {
+          type_error("Missing argument namedCurve".to_string())
+        })?;
+
+        let public_key = args
+          .public_key
+          .ok_or_else(|| type_error("Missing argument publicKey"))?;
+
+        match named_curve {
+          CryptoNamedCurve::P256 => {
+            let secret_key = p256::SecretKey::from_pkcs8_der(&args.key.data)
+              .map_err(|_| {
+                type_error("Unexpected error decoding private key")
+              })?;
+
+            let public_key = match public_key.r#type {
+              KeyType::Private => {
+                p256::SecretKey::from_pkcs8_der(&public_key.data)
+                  .map_err(|_| {
+                    type_error("Unexpected error decoding private key")
+                  })?
+                  .public_key()
               }
-            }
-            _ => unreachable!(),
-          };
-
-          let shared_secret = p256::elliptic_curve::ecdh::diffie_hellman(
-            secret_key.to_nonzero_scalar(),
-            public_key.as_affine(),
-          );
-
-          // raw serialized x-coordinate of the computed point
-          Ok(shared_secret.raw_secret_bytes().to_vec().into())
-        }
-        CryptoNamedCurve::P384 => {
-          let secret_key = p384::SecretKey::from_pkcs8_der(&args.key.data)
-            .map_err(|_| type_error("Unexpected error decoding private key"))?;
-
-          let public_key = match public_key.r#type {
-            KeyType::Private => {
-              p384::SecretKey::from_pkcs8_der(&public_key.data)
-                .map_err(|_| {
-                  type_error("Unexpected error decoding private key")
-                })?
-                .public_key()
-            }
-            KeyType::Public => {
-              let point = p384::EncodedPoint::from_bytes(public_key.data)
-                .map_err(|_| {
-                  type_error("Unexpected error decoding private key")
-                })?;
-
-              let pk = p384::PublicKey::from_encoded_point(&point);
-              // pk is a constant time Option.
-              if pk.is_some().into() {
-                pk.unwrap()
-              } else {
-                return Err(type_error(
-                  "Unexpected error decoding private key",
-                ));
+              KeyType::Public => {
+                let point = p256::EncodedPoint::from_bytes(public_key.data)
+                  .map_err(|_| {
+                    type_error("Unexpected error decoding private key")
+                  })?;
+
+                let pk = p256::PublicKey::from_encoded_point(&point);
+                // pk is a constant time Option.
+                if pk.is_some().into() {
+                  pk.unwrap()
+                } else {
+                  return Err(type_error(
+                    "Unexpected error decoding private key",
+                  ));
+                }
               }
-            }
-            _ => unreachable!(),
-          };
+              _ => unreachable!(),
+            };
+
+            let shared_secret = p256::elliptic_curve::ecdh::diffie_hellman(
+              secret_key.to_nonzero_scalar(),
+              public_key.as_affine(),
+            );
+
+            // raw serialized x-coordinate of the computed point
+            Ok(shared_secret.raw_secret_bytes().to_vec().into())
+          }
+          CryptoNamedCurve::P384 => {
+            let secret_key = p384::SecretKey::from_pkcs8_der(&args.key.data)
+              .map_err(|_| {
+                type_error("Unexpected error decoding private key")
+              })?;
+
+            let public_key = match public_key.r#type {
+              KeyType::Private => {
+                p384::SecretKey::from_pkcs8_der(&public_key.data)
+                  .map_err(|_| {
+                    type_error("Unexpected error decoding private key")
+                  })?
+                  .public_key()
+              }
+              KeyType::Public => {
+                let point = p384::EncodedPoint::from_bytes(public_key.data)
+                  .map_err(|_| {
+                    type_error("Unexpected error decoding private key")
+                  })?;
+
+                let pk = p384::PublicKey::from_encoded_point(&point);
+                // pk is a constant time Option.
+                if pk.is_some().into() {
+                  pk.unwrap()
+                } else {
+                  return Err(type_error(
+                    "Unexpected error decoding private key",
+                  ));
+                }
+              }
+              _ => unreachable!(),
+            };
 
-          let shared_secret = p384::elliptic_curve::ecdh::diffie_hellman(
-            secret_key.to_nonzero_scalar(),
-            public_key.as_affine(),
-          );
+            let shared_secret = p384::elliptic_curve::ecdh::diffie_hellman(
+              secret_key.to_nonzero_scalar(),
+              public_key.as_affine(),
+            );
 
-          // raw serialized x-coordinate of the computed point
-          Ok(shared_secret.raw_secret_bytes().to_vec().into())
+            // raw serialized x-coordinate of the computed point
+            Ok(shared_secret.raw_secret_bytes().to_vec().into())
+          }
         }
       }
+      Algorithm::Hkdf => {
+        let zero_copy = zero_copy.ok_or_else(not_supported)?;
+        let salt = &*zero_copy;
+        let algorithm = match args.hash.ok_or_else(not_supported)? {
+          CryptoHash::Sha1 => hkdf::HKDF_SHA1_FOR_LEGACY_USE_ONLY,
+          CryptoHash::Sha256 => hkdf::HKDF_SHA256,
+          CryptoHash::Sha384 => hkdf::HKDF_SHA384,
+          CryptoHash::Sha512 => hkdf::HKDF_SHA512,
+        };
+
+        let info = args
+          .info
+          .ok_or_else(|| type_error("Missing argument info".to_string()))?;
+        // IKM
+        let secret = args.key.data;
+        // L
+        let length = args.length / 8;
+
+        let salt = hkdf::Salt::new(algorithm, salt);
+        let prk = salt.extract(&secret);
+        let info = &[&*info];
+        let okm = prk.expand(info, HkdfOutput(length)).map_err(|_e| {
+          custom_error(
+            "DOMExceptionOperationError",
+            "The length provided for HKDF is too large",
+          )
+        })?;
+        let mut r = vec![0u8; length];
+        okm.fill(&mut r)?;
+        Ok(r.into())
+      }
+      _ => Err(type_error("Unsupported algorithm".to_string())),
     }
-    Algorithm::Hkdf => {
-      let zero_copy = zero_copy.ok_or_else(not_supported)?;
-      let salt = &*zero_copy;
-      let algorithm = match args.hash.ok_or_else(not_supported)? {
-        CryptoHash::Sha1 => hkdf::HKDF_SHA1_FOR_LEGACY_USE_ONLY,
-        CryptoHash::Sha256 => hkdf::HKDF_SHA256,
-        CryptoHash::Sha384 => hkdf::HKDF_SHA384,
-        CryptoHash::Sha512 => hkdf::HKDF_SHA512,
-      };
-
-      let info = args
-        .info
-        .ok_or_else(|| type_error("Missing argument info".to_string()))?;
-      // IKM
-      let secret = args.key.data;
-      // L
-      let length = args.length / 8;
-
-      let salt = hkdf::Salt::new(algorithm, salt);
-      let prk = salt.extract(&secret);
-      let info = &[&*info];
-      let okm = prk.expand(info, HkdfOutput(length)).map_err(|_e| {
-        custom_error(
-          "DOMExceptionOperationError",
-          "The length provided for HKDF is too large",
-        )
-      })?;
-      let mut r = vec![0u8; length];
-      okm.fill(&mut r)?;
-      Ok(r.into())
-    }
-    _ => Err(type_error("Unsupported algorithm".to_string())),
-  }
+  })
+  .await?
 }
 
 fn read_rsa_public_key(key_data: KeyData) -> Result<RsaPublicKey, AnyError> {
diff --git a/ext/net/02_tls.js b/ext/net/02_tls.js
index 7fde7d12b..04b0a5850 100644
--- a/ext/net/02_tls.js
+++ b/ext/net/02_tls.js
@@ -166,6 +166,7 @@ function listenTls({
   return new TlsListener(rid, localAddr);
 }
 
+// deno-lint-ignore require-await
 async function startTls(
   conn,
   {
@@ -174,7 +175,7 @@ async function startTls(
     alpnProtocols = undefined,
   } = {},
 ) {
-  const { 0: rid, 1: localAddr, 2: remoteAddr } = await op_tls_start({
+  const { 0: rid, 1: localAddr, 2: remoteAddr } = op_tls_start({
     rid: conn[internalRidSymbol],
     hostname,
     caCerts,
diff --git a/ext/net/io.rs b/ext/net/io.rs
index 9254fce08..f3aed3fcb 100644
--- a/ext/net/io.rs
+++ b/ext/net/io.rs
@@ -152,6 +152,7 @@ impl UnixStreamResource {
   fn write(self: Rc<Self>, _data: &[u8]) -> AsyncResult<usize> {
     unreachable!()
   }
+  #[allow(clippy::unused_async)]
   pub async fn shutdown(self: Rc<Self>) -> Result<(), AnyError> {
     unreachable!()
   }
diff --git a/ext/net/ops_tls.rs b/ext/net/ops_tls.rs
index b16dafa71..e83173e90 100644
--- a/ext/net/ops_tls.rs
+++ b/ext/net/ops_tls.rs
@@ -159,9 +159,9 @@ pub struct StartTlsArgs {
   alpn_protocols: Option<Vec<String>>,
 }
 
-#[op2(async)]
+#[op2]
 #[serde]
-pub async fn op_tls_start<NP>(
+pub fn op_tls_start<NP>(
   state: Rc<RefCell<OpState>>,
   #[serde] args: StartTlsArgs,
 ) -> Result<(ResourceId, IpAddr, IpAddr), AnyError>
diff --git a/ext/node/ops/ipc.rs b/ext/node/ops/ipc.rs
index 3cdb569ab..dc0c086c1 100644
--- a/ext/node/ops/ipc.rs
+++ b/ext/node/ops/ipc.rs
@@ -408,6 +408,7 @@ mod impl_ {
     use deno_core::RcRef;
     use std::rc::Rc;
 
+    #[allow(clippy::unused_async)]
     #[cfg(unix)]
     pub async fn pair() -> (Rc<IpcJsonStreamResource>, tokio::net::UnixStream) {
       let (a, b) = tokio::net::UnixStream::pair().unwrap();
diff --git a/ext/web/timers.rs b/ext/web/timers.rs
index 8e2f94338..b3060a46f 100644
--- a/ext/web/timers.rs
+++ b/ext/web/timers.rs
@@ -43,5 +43,6 @@ where
   buf[1] = subsec_nanos;
 }
 
+#[allow(clippy::unused_async)]
 #[op2(async(lazy), fast)]
 pub async fn op_defer() {}
diff --git a/ext/webgpu/01_webgpu.js b/ext/webgpu/01_webgpu.js
index 55ca9c382..31b0a75f6 100644
--- a/ext/webgpu/01_webgpu.js
+++ b/ext/webgpu/01_webgpu.js
@@ -324,6 +324,7 @@ class GPU {
   /**
    * @param {GPURequestAdapterOptions} options
    */
+  // deno-lint-ignore require-await
   async requestAdapter(options = {}) {
     webidl.assertBranded(this, GPUPrototype);
     options = webidl.converters.GPURequestAdapterOptions(
@@ -332,7 +333,7 @@ class GPU {
       "Argument 1",
     );
 
-    const { err, ...data } = await op_webgpu_request_adapter(
+    const { err, ...data } = op_webgpu_request_adapter(
       options.powerPreference,
       options.forceFallbackAdapter,
     );
@@ -411,6 +412,7 @@ class GPUAdapter {
    * @param {GPUDeviceDescriptor} descriptor
    * @returns {Promise<GPUDevice>}
    */
+  // deno-lint-ignore require-await
   async requestDevice(descriptor = {}) {
     webidl.assertBranded(this, GPUAdapterPrototype);
     const prefix = "Failed to execute 'requestDevice' on 'GPUAdapter'";
@@ -431,7 +433,7 @@ class GPUAdapter {
       }
     }
 
-    const { rid, features, limits } = await op_webgpu_request_device(
+    const { rid, features, limits } = op_webgpu_request_device(
       this[_adapter].rid,
       descriptor.label,
       requiredFeatures,
@@ -455,7 +457,7 @@ class GPUAdapter {
    * @param {string[]} unmaskHints
    * @returns {Promise<GPUAdapterInfo>}
    */
-  async requestAdapterInfo(unmaskHints = []) {
+  requestAdapterInfo(unmaskHints = []) {
     webidl.assertBranded(this, GPUAdapterPrototype);
     const prefix = "Failed to execute 'requestAdapterInfo' on 'GPUAdapter'";
     unmaskHints = webidl.converters["sequence<DOMString>"](
@@ -469,9 +471,7 @@ class GPUAdapter {
       architecture,
       device,
       description,
-    } = await op_webgpu_request_adapter_info(
-      this[_adapter].rid,
-    );
+    } = op_webgpu_request_adapter_info(this[_adapter].rid);
 
     const adapterInfo = webidl.createBranded(GPUAdapterInfo);
     adapterInfo[_vendor] = ArrayPrototypeIncludes(unmaskHints, "vendor")
@@ -484,7 +484,7 @@ class GPUAdapter {
       : "";
     adapterInfo[_description] =
       ArrayPrototypeIncludes(unmaskHints, "description") ? description : "";
-    return adapterInfo;
+    return PromiseResolve(adapterInfo);
   }
 
   [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
diff --git a/ext/webgpu/lib.rs b/ext/webgpu/lib.rs
index 99c8fcf6b..5c0dc79c2 100644
--- a/ext/webgpu/lib.rs
+++ b/ext/webgpu/lib.rs
@@ -381,9 +381,9 @@ pub struct GpuAdapterDevice {
   is_software: bool,
 }
 
-#[op2(async)]
+#[op2]
 #[serde]
-pub async fn op_webgpu_request_adapter(
+pub fn op_webgpu_request_adapter(
   state: Rc<RefCell<OpState>>,
   #[serde] power_preference: Option<wgpu_types::PowerPreference>,
   force_fallback_adapter: bool,
@@ -645,9 +645,9 @@ impl From<GpuRequiredFeatures> for wgpu_types::Features {
   }
 }
 
-#[op2(async)]
+#[op2]
 #[serde]
-pub async fn op_webgpu_request_device(
+pub fn op_webgpu_request_device(
   state: Rc<RefCell<OpState>>,
   #[smi] adapter_rid: ResourceId,
   #[string] label: String,
@@ -702,9 +702,9 @@ pub struct GPUAdapterInfo {
   description: String,
 }
 
-#[op2(async)]
+#[op2]
 #[serde]
-pub async fn op_webgpu_request_adapter_info(
+pub fn op_webgpu_request_adapter_info(
   state: Rc<RefCell<OpState>>,
   #[smi] adapter_rid: ResourceId,
 ) -> Result<GPUAdapterInfo, AnyError> {