chore: clippy future cleanups (#8514)

4 files changed, 22 insertions, 38 deletions

diff --git a/core/bindings.rs b/core/bindings.rs
index 4825ed66d..d9c875e60 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -335,7 +335,7 @@ fn print(
   _rv: v8::ReturnValue,
 ) {
   let arg_len = args.length();
-  assert!(arg_len >= 0 && arg_len <= 2);
+  assert!((0..=2).contains(&arg_len));
 
   let obj = args.get(0);
   let is_err_arg = args.get(1);
@@ -850,10 +850,7 @@ fn get_proxy_details(
   rv.set(proxy_details.into());
 }
 
-fn throw_type_error<'s>(
-  scope: &mut v8::HandleScope<'s>,
-  message: impl AsRef<str>,
-) {
+fn throw_type_error(scope: &mut v8::HandleScope, message: impl AsRef<str>) {
   let message = v8::String::new(scope, message.as_ref()).unwrap();
   let exception = v8::Exception::type_error(scope, message);
   scope.throw_exception(exception);
diff --git a/core/error.rs b/core/error.rs
index 331feba20..1d31df5ed 100644
--- a/core/error.rs
+++ b/core/error.rs
@@ -186,11 +186,11 @@ impl JsError {
         .and_then(|m| m.to_string(scope))
         .map(|s| s.to_rust_string_lossy(scope))
         .unwrap_or_else(|| "".to_string());
-      let message = if name != "" && message_prop != "" {
+      let message = if !name.is_empty() && !message_prop.is_empty() {
         format!("Uncaught {}: {}", name, message_prop)
-      } else if name != "" {
+      } else if !name.is_empty() {
         format!("Uncaught {}", name)
-      } else if message_prop != "" {
+      } else if !message_prop.is_empty() {
         format!("Uncaught {}", message_prop)
       } else {
         "Uncaught".to_string()
diff --git a/core/resources2.rs b/core/resources2.rs
index 52bd4f3e7..62cb3f056 100644
--- a/core/resources2.rs
+++ b/core/resources2.rs
@@ -33,6 +33,7 @@ impl dyn Resource {
   }
 
   #[inline(always)]
+  #[allow(clippy::needless_lifetimes)]
   fn downcast_rc<'a, T: Resource>(self: &'a Rc<Self>) -> Option<&'a Rc<T>> {
     if self.is::<T>() {
       let ptr = self as *const Rc<_> as *const Rc<T>;
diff --git a/core/runtime.rs b/core/runtime.rs
index 7f71af09a..c079783f3 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -501,13 +501,13 @@ impl JsRuntime {
       let poll_imports = self.poll_dyn_imports(cx)?;
       assert!(poll_imports.is_ready());
 
-      self.evaluate_dyn_imports()?;
+      self.evaluate_dyn_imports();
 
       self.check_promise_exceptions()?;
     }
 
     // Top level module
-    self.evaluate_pending_module()?;
+    self.evaluate_pending_module();
 
     let state = state_rc.borrow();
     let has_pending_ops = !state.pending_ops.is_empty();
@@ -814,7 +814,7 @@ impl JsRuntime {
     }
 
     if status == v8::ModuleStatus::Evaluated {
-      self.dyn_import_done(load_id, id)?;
+      self.dyn_import_done(load_id, id);
     }
 
     Ok(())
@@ -828,7 +828,7 @@ impl JsRuntime {
   fn mod_evaluate_inner(
     &mut self,
     id: ModuleId,
-  ) -> Result<mpsc::Receiver<Result<(), AnyError>>, AnyError> {
+  ) -> mpsc::Receiver<Result<(), AnyError>> {
     self.shared_init();
 
     let state_rc = Self::state(self.v8_isolate());
@@ -894,11 +894,11 @@ impl JsRuntime {
       }
     }
 
-    Ok(receiver)
+    receiver
   }
 
   pub async fn mod_evaluate(&mut self, id: ModuleId) -> Result<(), AnyError> {
-    let mut receiver = self.mod_evaluate_inner(id)?;
+    let mut receiver = self.mod_evaluate_inner(id);
 
     poll_fn(|cx| {
       if let Poll::Ready(maybe_result) = receiver.poll_next_unpin(cx) {
@@ -915,11 +915,7 @@ impl JsRuntime {
     .await
   }
 
-  fn dyn_import_error(
-    &mut self,
-    id: ModuleLoadId,
-    err: AnyError,
-  ) -> Result<(), AnyError> {
+  fn dyn_import_error(&mut self, id: ModuleLoadId, err: AnyError) {
     let state_rc = Self::state(self.v8_isolate());
     let context = self.global_context();
 
@@ -943,14 +939,9 @@ impl JsRuntime {
 
     resolver.reject(scope, exception).unwrap();
     scope.perform_microtask_checkpoint();
-    Ok(())
   }
 
-  fn dyn_import_done(
-    &mut self,
-    id: ModuleLoadId,
-    mod_id: ModuleId,
-  ) -> Result<(), AnyError> {
+  fn dyn_import_done(&mut self, id: ModuleLoadId, mod_id: ModuleId) {
     let state_rc = Self::state(self.v8_isolate());
     let context = self.global_context();
 
@@ -978,7 +969,6 @@ impl JsRuntime {
     let module_namespace = module.get_module_namespace();
     resolver.resolve(scope, module_namespace).unwrap();
     scope.perform_microtask_checkpoint();
-    Ok(())
   }
 
   fn prepare_dyn_imports(
@@ -1011,7 +1001,7 @@ impl JsRuntime {
               state.pending_dyn_imports.push(load.into_future());
             }
             Err(err) => {
-              self.dyn_import_error(dyn_import_id, err)?;
+              self.dyn_import_error(dyn_import_id, err);
             }
           }
         }
@@ -1057,14 +1047,14 @@ impl JsRuntime {
                     let state = state_rc.borrow_mut();
                     state.pending_dyn_imports.push(load.into_future());
                   }
-                  Err(err) => self.dyn_import_error(dyn_import_id, err)?,
+                  Err(err) => self.dyn_import_error(dyn_import_id, err),
                 }
               }
               Err(err) => {
                 // A non-javascript error occurred; this could be due to a an invalid
                 // module specifier, or a problem with the source map, or a failure
                 // to fetch the module source code.
-                self.dyn_import_error(dyn_import_id, err)?
+                self.dyn_import_error(dyn_import_id, err)
               }
             }
           } else {
@@ -1092,7 +1082,7 @@ impl JsRuntime {
   /// Thus during turn of event loop we need to check if V8 has
   /// resolved or rejected the promise. If the promise is still pending
   /// then another turn of event loop must be performed.
-  fn evaluate_pending_module(&mut self) -> Result<(), AnyError> {
+  fn evaluate_pending_module(&mut self) {
     let state_rc = Self::state(self.v8_isolate());
 
     let context = self.global_context();
@@ -1130,11 +1120,9 @@ impl JsRuntime {
         }
       }
     };
-
-    Ok(())
   }
 
-  fn evaluate_dyn_imports(&mut self) -> Result<(), AnyError> {
+  fn evaluate_dyn_imports(&mut self) {
     let state_rc = Self::state(self.v8_isolate());
 
     loop {
@@ -1184,18 +1172,16 @@ impl JsRuntime {
       if let Some(result) = maybe_result {
         match result {
           Ok((dyn_import_id, module_id)) => {
-            self.dyn_import_done(dyn_import_id, module_id)?;
+            self.dyn_import_done(dyn_import_id, module_id);
           }
           Err((dyn_import_id, err1)) => {
-            self.dyn_import_error(dyn_import_id, err1)?;
+            self.dyn_import_error(dyn_import_id, err1);
           }
         }
       } else {
         break;
       }
     }
-
-    Ok(())
   }
 
   fn register_during_load(
@@ -2268,7 +2254,7 @@ pub mod tests {
     runtime.mod_instantiate(mod_a).unwrap();
     assert_eq!(dispatch_count.load(Ordering::Relaxed), 0);
 
-    runtime.mod_evaluate_inner(mod_a).unwrap();
+    runtime.mod_evaluate_inner(mod_a);
     assert_eq!(dispatch_count.load(Ordering::Relaxed), 1);
   }