diff --git a/Cargo.lock b/Cargo.lock
index 93c15e1f..b9ba753b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -51,9 +51,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.19"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
+checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -81,22 +81,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.9"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -315,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed87a9d530bb41a67537289bafcac159cb3ee28460e0a4571123d2a778a6a882"
+checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -325,9 +325,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f4f3f3c77c94aff3c7e9aac9a2ca1974a5adf392a8bb751e827d6d127ab966"
+checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1692,9 +1692,9 @@ dependencies = [
 
 [[package]]
 name = "quick-xml"
-version = "0.38.0"
+version = "0.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8927b0664f5c5a98265138b7e3f90aa19a6b21353182469ace36d4ac527b7b1b"
+checksum = "9845d9dccf565065824e69f9f235fafba1587031eda353c1f1561cd6a6be78f4"
 dependencies = [
  "memchr",
 ]
@@ -2243,7 +2243,7 @@ dependencies = [
  "openssl-probe",
  "rustls-pki-types",
  "schannel",
- "security-framework 3.2.0",
+ "security-framework 3.3.0",
 ]
 
 [[package]]
@@ -2324,9 +2324,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "3.2.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
+checksum = "80fb1d92c5028aa318b4b8bd7302a5bfcf48be96a37fc6fc790f806b0004ee0c"
 dependencies = [
  "bitflags 2.9.1",
  "core-foundation 0.10.1",
@@ -3574,9 +3574,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.2"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
 dependencies = [
  "yoke",
  "zerofrom",
diff --git a/Cargo.toml b/Cargo.toml
index 107c536f..d474954d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ async-recursion = "1.1.1"
 bitflags = "2.9.1"
 byteorder = "1.5.0"
 byte-unit = "5.1.6"
-clap = "4.5.42"
+clap = "4.5.43"
 console = "0.16.0"
 cranelift = "0.122.0"
 criterion = { version = "0.7.0", default-features = false }
diff --git a/ristretto_classfile/src/attributes/attribute.rs b/ristretto_classfile/src/attributes/attribute.rs
index ffdfdac9..9dc56a6c 100644
--- a/ristretto_classfile/src/attributes/attribute.rs
+++ b/ristretto_classfile/src/attributes/attribute.rs
@@ -2068,14 +2068,12 @@ mod test {
         let mut bytes = Cursor::new(expected_bytes.to_vec());
 
         // Adjust the frame_type offest before comparing
-        if let Attribute::Code { attributes, .. } = &mut attribute {
-            if let Some(Attribute::StackMapTable { frames, .. }) = attributes.get_mut(2) {
-                if let Some(StackFrame::SameLocals1StackItemFrame { frame_type, .. }) =
-                    frames.get_mut(1)
-                {
-                    *frame_type = 66; // Update to match the expected frame type
-                }
-            }
+        if let Attribute::Code { attributes, .. } = &mut attribute
+            && let Some(Attribute::StackMapTable { frames, .. }) = attributes.get_mut(2)
+            && let Some(StackFrame::SameLocals1StackItemFrame { frame_type, .. }) =
+                frames.get_mut(1)
+        {
+            *frame_type = 66; // Update to match the expected frame type
         }
         let code_attribute = Attribute::from_bytes(&constant_pool, &mut bytes)?;
         assert_eq!(attribute, code_attribute);
diff --git a/ristretto_classfile/src/constant_pool.rs b/ristretto_classfile/src/constant_pool.rs
index b2c85bd2..ae43d7f3 100644
--- a/ristretto_classfile/src/constant_pool.rs
+++ b/ristretto_classfile/src/constant_pool.rs
@@ -204,7 +204,7 @@ impl ConstantPool {
     /// assert_eq!(None, iterator.next());
     /// ```
     #[must_use]
-    pub fn iter(&self) -> ConstantPoolIterator {
+    pub fn iter(&self) -> ConstantPoolIterator<'_> {
         ConstantPoolIterator::new(self)
     }
 
diff --git a/ristretto_classloader/src/class_path_entry/manifest.rs b/ristretto_classloader/src/class_path_entry/manifest.rs
index eb7878b5..811f2187 100644
--- a/ristretto_classloader/src/class_path_entry/manifest.rs
+++ b/ristretto_classloader/src/class_path_entry/manifest.rs
@@ -103,10 +103,10 @@ impl<'de> Deserialize<'de> for Manifest {
                         sections.insert(value.to_string(), IndexMap::new());
                     } else if current_section.is_none() {
                         attributes.insert(key.to_string(), value.to_string());
-                    } else if let Some(section) = &current_section {
-                        if let Some(section_map) = sections.get_mut(section) {
-                            section_map.insert(key.to_string(), value.to_string());
-                        }
+                    } else if let Some(section) = &current_section
+                        && let Some(section_map) = sections.get_mut(section)
+                    {
+                        section_map.insert(key.to_string(), value.to_string());
                     }
                 }
 
diff --git a/ristretto_gc/src/collector.rs b/ristretto_gc/src/collector.rs
index a21f7234..44356bbc 100644
--- a/ristretto_gc/src/collector.rs
+++ b/ristretto_gc/src/collector.rs
@@ -360,10 +360,10 @@ impl GarbageCollector {
     /// Checks if an object is already marked to avoid infinite loops during tracing. Used by
     /// the `Trace` implementations for cycle detection.
     pub(crate) fn is_object_marked(&self, ptr: SafePtr) -> bool {
-        if let Ok(objects) = self.objects.read() {
-            if let Some(metadata) = objects.get(&ptr) {
-                return metadata.is_marked();
-            }
+        if let Ok(objects) = self.objects.read()
+            && let Some(metadata) = objects.get(&ptr)
+        {
+            return metadata.is_marked();
         }
         false
     }
@@ -379,11 +379,11 @@ impl GarbageCollector {
     /// Marks an object as reachable in the object registry. Used during garbage collection to mark
     /// objects that are reachable from roots.
     pub(crate) fn mark_object(&self, ptr: SafePtr) {
-        if let Ok(mut objects) = self.objects.write() {
-            if let Some(metadata) = objects.get_mut(&ptr) {
-                trace!("object: {:#x} marked reachable", ptr.0);
-                metadata.mark();
-            }
+        if let Ok(mut objects) = self.objects.write()
+            && let Some(metadata) = objects.get_mut(&ptr)
+        {
+            trace!("object: {:#x} marked reachable", ptr.0);
+            metadata.mark();
         }
     }
 
@@ -391,16 +391,16 @@ impl GarbageCollector {
     /// the object, `false` if already marked. This is used for cycle detection during tracing to
     /// prevent infinite recursion.
     pub(crate) fn try_mark_object(&self, ptr: SafePtr) -> bool {
-        if let Ok(mut objects) = self.objects.write() {
-            if let Some(metadata) = objects.get_mut(&ptr) {
-                let was_unmarked = metadata.mark();
-                if was_unmarked {
-                    trace!("object: {:#x} marked reachable (first time)", ptr.0);
-                } else {
-                    trace!("object: {:#x} already marked, skipping trace", ptr.0);
-                }
-                return was_unmarked;
+        if let Ok(mut objects) = self.objects.write()
+            && let Some(metadata) = objects.get_mut(&ptr)
+        {
+            let was_unmarked = metadata.mark();
+            if was_unmarked {
+                trace!("object: {:#x} marked reachable (first time)", ptr.0);
+            } else {
+                trace!("object: {:#x} already marked, skipping trace", ptr.0);
             }
+            return was_unmarked;
         }
         false
     }
@@ -685,12 +685,11 @@ impl GarbageCollector {
             };
 
             let ptr = SafePtr::from_ptr(gc_trace_ptr.as_raw_ptr());
-            if let Ok(mut objects_guard) = objects.write() {
-                if let Some(metadata) = objects_guard.get_mut(&ptr) {
-                    if metadata.mark() {
-                        final_processed += 1;
-                    }
-                }
+            if let Ok(mut objects_guard) = objects.write()
+                && let Some(metadata) = objects_guard.get_mut(&ptr)
+                && metadata.mark()
+            {
+                final_processed += 1;
             }
         }
 
diff --git a/ristretto_gc/src/metadata.rs b/ristretto_gc/src/metadata.rs
index 4146301f..131b1027 100644
--- a/ristretto_gc/src/metadata.rs
+++ b/ristretto_gc/src/metadata.rs
@@ -154,31 +154,31 @@ impl ObjectMetadata {
         }
 
         // First, run the finalizer if present
-        if let Ok(mut finalizer_guard) = self.finalizer.try_lock() {
-            if let Some(finalizer) = finalizer_guard.take() {
-                // Execute finalizer in a safe context
-                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    finalizer();
-                }))
-                .unwrap_or_else(|_| {
-                    // Log finalizer panic but don't propagate it
-                    eprintln!("Warning: Finalizer panicked during object cleanup");
-                });
-            }
+        if let Ok(mut finalizer_guard) = self.finalizer.try_lock()
+            && let Some(finalizer) = finalizer_guard.take()
+        {
+            // Execute finalizer in a safe context
+            std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                finalizer();
+            }))
+            .unwrap_or_else(|_| {
+                // Log finalizer panic but don't propagate it
+                eprintln!("Warning: Finalizer panicked during object cleanup");
+            });
         }
 
         // Then, drop the object with additional safety checks
-        if let Ok(mut drop_fn_guard) = self.drop_fn.try_lock() {
-            if let Some(drop_fn) = drop_fn_guard.take() {
-                // Execute drop function in a safe context
-                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    drop_fn();
-                }))
-                .unwrap_or_else(|_| {
-                    // Log drop panic but don't propagate it
-                    eprintln!("Warning: Drop function panicked during object cleanup");
-                });
-            }
+        if let Ok(mut drop_fn_guard) = self.drop_fn.try_lock()
+            && let Some(drop_fn) = drop_fn_guard.take()
+        {
+            // Execute drop function in a safe context
+            std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                drop_fn();
+            }))
+            .unwrap_or_else(|_| {
+                // Log drop panic but don't propagate it
+                eprintln!("Warning: Drop function panicked during object cleanup");
+            });
         }
     }
 }
diff --git a/ristretto_vm/src/assignable.rs b/ristretto_vm/src/assignable.rs
index 2469aed1..1acbaf1d 100644
--- a/ristretto_vm/src/assignable.rs
+++ b/ristretto_vm/src/assignable.rs
@@ -68,10 +68,10 @@ impl Assignable for Arc<Class> {
         }
 
         // Check inheritance hierarchy
-        if let Some(parent) = other.parent()? {
-            if Box::pin(self.is_assignable_from(thread, &parent)).await? {
-                return Ok(true);
-            }
+        if let Some(parent) = other.parent()?
+            && Box::pin(self.is_assignable_from(thread, &parent)).await?
+        {
+            return Ok(true);
         }
 
         // Check interfaces
diff --git a/ristretto_vm/src/build/intrinsics.rs b/ristretto_vm/src/build/intrinsics.rs
index 39d01b9b..ba751623 100644
--- a/ristretto_vm/src/build/intrinsics.rs
+++ b/ristretto_vm/src/build/intrinsics.rs
@@ -247,11 +247,11 @@ fn java_version_vec(call: &ExprCall) -> Vec<Version> {
 }
 /// Returns the Java version based on the provided expression.
 fn java_version(expression: Option<&Expr>) -> Version {
-    if let Some(Expr::Path(path)) = expression {
-        if let Some(segment) = path.path.segments.first() {
-            let version = segment.ident.to_string();
-            return parse_java_version(&version);
-        }
+    if let Some(Expr::Path(path)) = expression
+        && let Some(segment) = path.path.segments.first()
+    {
+        let version = segment.ident.to_string();
+        return parse_java_version(&version);
     }
     panic!("Unsupported Java version in intrinsic method attribute: {expression:?}");
 }
diff --git a/ristretto_vm/src/instruction/invokedynamic.rs b/ristretto_vm/src/instruction/invokedynamic.rs
index 3d788c01..d39ebdf0 100644
--- a/ristretto_vm/src/instruction/invokedynamic.rs
+++ b/ristretto_vm/src/instruction/invokedynamic.rs
@@ -902,7 +902,11 @@ async fn validate_call_site(
     // Validate CallSite.type() matches expected MethodType
     let type_method = call_site_class.try_get_method("type", "()Ljava/lang/invoke/MethodType;")?;
     let call_site_type = thread
-        .try_execute(&call_site_class, &type_method, &[call_site.clone()])
+        .try_execute(
+            &call_site_class,
+            &type_method,
+            std::slice::from_ref(call_site),
+        )
         .await?;
     let expected_method_type = get_method_type(thread, bootstrap_method_descriptor).await?;
 
diff --git a/ristretto_vm/src/instruction/invokevirtual.rs b/ristretto_vm/src/instruction/invokevirtual.rs
index 3d734995..82072dad 100644
--- a/ristretto_vm/src/instruction/invokevirtual.rs
+++ b/ristretto_vm/src/instruction/invokevirtual.rs
@@ -70,10 +70,9 @@ pub(crate) fn resolve_method(
         while let Some(interface) = interfaces.pop() {
             if let Ok((interface, method)) =
                 lookup_method_in_hierarchy(interface.clone(), name, descriptor)
+                && !method.is_abstract()
             {
-                if !method.is_abstract() {
-                    return Ok((interface, method));
-                }
+                return Ok((interface, method));
             }
             let super_interfaces = interface.interfaces()?;
             interfaces.extend(super_interfaces);
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/ref/reference.rs b/ristretto_vm/src/intrinsic_methods/java/lang/ref/reference.rs
index 87d63cbe..36da2c8d 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/ref/reference.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/ref/reference.rs
@@ -132,7 +132,7 @@ mod tests {
             .object(
                 "java/lang/ref/WeakReference",
                 "Ljava/lang/Object;",
-                &[value.clone()],
+                std::slice::from_ref(&value),
             )
             .await?;
         let mut parameters = Parameters::default();
diff --git a/ristretto_vm/src/java_object.rs b/ristretto_vm/src/java_object.rs
index 5ca4ad76..6a0ebc3a 100644
--- a/ristretto_vm/src/java_object.rs
+++ b/ristretto_vm/src/java_object.rs
@@ -286,7 +286,7 @@ async fn to_class_object(thread: &Thread, class: &Arc<Class>) -> Result<Value> {
                 .try_invoke(
                     "java.lang.ClassLoader",
                     "getUnnamedModule()Ljava/lang/Module;",
-                    &[class_loader_object.clone()],
+                    std::slice::from_ref(&class_loader_object),
                 )
                 .await?;
             object.set_value_unchecked("module", module)?;
diff --git a/ristretto_vm/src/jit.rs b/ristretto_vm/src/jit.rs
index 9fba2ff2..7d18539c 100644
--- a/ristretto_vm/src/jit.rs
+++ b/ristretto_vm/src/jit.rs
@@ -192,14 +192,12 @@ fn compile_method(
             );
 
             let err = JitError(error);
-            if notify_pending {
-                if let Some((_, pending_senders)) =
+            if notify_pending
+                && let Some((_, pending_senders)) =
                     PENDING_COMPILATIONS.remove(fully_qualified_method_name)
-                {
-                    for sender in pending_senders {
-                        let _ =
-                            sender.send(Err(InternalError("JIT compilation failed".to_string())));
-                    }
+            {
+                for sender in pending_senders {
+                    let _ = sender.send(Err(InternalError("JIT compilation failed".to_string())));
                 }
             }
 
@@ -208,12 +206,11 @@ fn compile_method(
     };
 
     // Notify any pending waiters for this method if requested
-    if notify_pending {
-        if let Some((_, pending_senders)) = PENDING_COMPILATIONS.remove(fully_qualified_method_name)
-        {
-            for sender in pending_senders {
-                let _ = sender.send(Ok(function.clone()));
-            }
+    if notify_pending
+        && let Some((_, pending_senders)) = PENDING_COMPILATIONS.remove(fully_qualified_method_name)
+    {
+        for sender in pending_senders {
+            let _ = sender.send(Ok(function.clone()));
         }
     }
 
diff --git a/ristretto_vm/tests/compatibility.rs b/ristretto_vm/tests/compatibility.rs
index 529ba8d1..55a33bb6 100644
--- a/ristretto_vm/tests/compatibility.rs
+++ b/ristretto_vm/tests/compatibility.rs
@@ -35,10 +35,10 @@ fn compatibility_tests() -> Result<()> {
         let test_name = test_dir.to_string_lossy().to_string();
         let test_dir = tests_root_dir.join(test_dir);
 
-        if let Some(filter) = TEST_ENDS_WITH_FILTER {
-            if !test_name.ends_with(filter) {
-                return;
-            }
+        if let Some(filter) = TEST_ENDS_WITH_FILTER
+            && !test_name.ends_with(filter)
+        {
+            return;
         }
 
         // Determine if the test should be ignored
diff --git a/ristretto_vm/tests/enumeration.rs b/ristretto_vm/tests/enumeration.rs
index d3aada5f..6967d5a9 100644
--- a/ristretto_vm/tests/enumeration.rs
+++ b/ristretto_vm/tests/enumeration.rs
@@ -16,7 +16,7 @@ async fn test_is_enum() -> Result<()> {
         .invoke(
             "java.lang.Class",
             "getModifiers()I",
-            &[class_object.clone()],
+            std::slice::from_ref(&class_object),
         )
         .await?
         .expect("modifiers")
@@ -27,7 +27,7 @@ async fn test_is_enum() -> Result<()> {
         .invoke(
             "java.lang.Class",
             "getSuperclass()Ljava/lang/Class;",
-            &[class_object.clone()],
+            std::slice::from_ref(&class_object),
         )
         .await?
         .expect("super class");