Fix clippy::semicolon_if_nothing_returned warnings

crates/fspy/src/command.rs

@@ -71,7 +71,7 @@ impl Command {
                     OsString::from_vec(value.unwrap_or_default().into()),
                 )
             })
-            .collect()
+            .collect();
     }
 
     pub fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Command {

crates/fspy_preload_unix/src/interceptions/spawn/exec/mod.rs

@@ -36,7 +36,7 @@ fn handle_exec(
     let result = unsafe {
         client.handle_exec(config, RawExec { prog, argv, envp }, |raw_command, pre_exec| {
             if let Some(pre_exec) = pre_exec {
-                pre_exec.run()?
+                pre_exec.run()?;
             };
             Ok(execve::original()(raw_command.prog, raw_command.argv, raw_command.envp))
         })

crates/fspy_seccomp_unotify/tests/arg_types.rs

@@ -83,7 +83,7 @@ async fn run_in_pre_exec(
 
         assert!(exit_status.success());
 
-        let syscalls = recorders.into_iter().map(|recorder| recorder.0.into_iter()).flatten();
+        let syscalls = recorders.into_iter().flat_map(|recorder| recorder.0.into_iter());
         io::Result::Ok(syscalls.collect())
     })
     .await??)

crates/fspy_shared_unix/src/exec/shebang.rs

@@ -13,15 +13,11 @@ fn is_whitespace(c: u8) -> bool {
 }
 
 #[derive(Clone, Copy, Debug)]
+#[derive(Default)]
 pub struct ParseShebangOptions {
     pub split_arguments: bool, // TODO: recursive
 }
 
-impl Default for ParseShebangOptions {
-    fn default() -> Self {
-        Self { split_arguments: cfg!(target_vendor = "apple") }
-    }
-}
 
 pub fn parse_shebang(
     mut peek_executable: impl FnMut(&Path, &mut [u8]) -> nix::Result<usize>,

crates/fspy_shared_unix/src/exec/which.rs

@@ -115,20 +115,20 @@ mod tests {
         let file: &BStr = B("foo").as_bstr();
         let path: &BStr = B("/bin:/usr/bin").as_bstr();
         let access = mock_access(&["/bin/foo"], &[], &[]);
-        let res = which(&file, &path, access, |found| {
+        let res = which(file, path, access, |found| {
             *called.borrow_mut() = Some(found.to_owned());
             Ok(())
         });
         assert!(res.is_ok());
-        assert_eq!(&*called.borrow().as_ref().unwrap(), b"/bin/foo".as_bstr());
+        assert_eq!(called.borrow().as_ref().unwrap(), b"/bin/foo".as_bstr());
     }
 
     #[test]
     fn test_which_not_found() {
         let file: &BStr = B("foo").as_bstr();
         let path: &BStr = B("/bin:/usr/bin").as_bstr();
         let access = mock_access(&[], &[], &[]);
-        let res = which(&file, &path, access, |_| Ok(()));
+        let res = which(file, path, access, |_| Ok(()));
         assert_eq!(res.unwrap_err(), nix::Error::ENOENT);
     }
 
@@ -137,7 +137,7 @@ mod tests {
         let file: &BStr = B("foo").as_bstr();
         let path: &BStr = B("/bin:/usr/bin").as_bstr();
         let access = mock_access(&[], &["/bin/foo", "/usr/bin/foo"], &[]);
-        let res = which(&file, &path, access, |_| Ok(()));
+        let res = which(file, path, access, |_| Ok(()));
         assert_eq!(res.unwrap_err(), nix::Error::EACCES);
     }
 
@@ -146,7 +146,7 @@ mod tests {
         let file: &BStr = B("foo").as_bstr();
         let path: &BStr = B("/usr/bin:/bin").as_bstr();
         let access = mock_access(&[], &[], &["/bin/foo"]);
-        let res = which(&file, &path, access, |_| Ok(()));
+        let res = which(file, path, access, |_| Ok(()));
         assert_eq!(res.unwrap_err(), nix::Error::ENOTDIR);
     }
 
@@ -156,20 +156,20 @@ mod tests {
         let file: &BStr = B("/usr/bin/foo").as_bstr();
         let path: &BStr = B("").as_bstr();
         let access = mock_access(&["/usr/bin/foo"], &[], &[]);
-        let res = which(&file, &path, access, |found| {
+        let res = which(file, path, access, |found| {
             *called.borrow_mut() = Some(found.to_owned());
             Ok(())
         });
         assert!(res.is_ok());
-        assert_eq!(&*called.borrow().as_ref().unwrap(), b"/usr/bin/foo".as_bstr());
+        assert_eq!(called.borrow().as_ref().unwrap(), b"/usr/bin/foo".as_bstr());
     }
 
     #[test]
     fn test_which_empty_file() {
         let file: &BStr = B("").as_bstr();
         let path: &BStr = B("/bin:/usr/bin").as_bstr();
         let access = mock_access(&[], &[], &[]);
-        let res = which(&file, &path, access, |_| Ok(()));
+        let res = which(file, path, access, |_| Ok(()));
         assert_eq!(res.unwrap_err(), nix::Error::ENOENT);
     }
 
@@ -179,7 +179,7 @@ mod tests {
         let file: &BStr = B(&long_name).as_bstr();
         let path: &BStr = B("/bin:/usr/bin").as_bstr();
         let access = mock_access(&[], &[], &[]);
-        let res = which(&file, &path, access, |_| Ok(()));
+        let res = which(file, path, access, |_| Ok(()));
         assert_eq!(res.unwrap_err(), nix::Error::ENAMETOOLONG);
     }
 
@@ -189,11 +189,11 @@ mod tests {
         let file: &BStr = B("foo").as_bstr();
         let path: &BStr = B(":/bin").as_bstr();
         let access = mock_access(&["foo"], &[], &[]);
-        let res = which(&file, &path, access, |found| {
+        let res = which(file, path, access, |found| {
             *called.borrow_mut() = Some(found.to_owned());
             Ok(())
         });
         assert!(res.is_ok());
-        assert_eq!(&*called.borrow().as_ref().unwrap(), b"foo".as_bstr());
+        assert_eq!(called.borrow().as_ref().unwrap(), b"foo".as_bstr());
     }
 }

crates/fspy_shared_unix/src/spawn/linux/elf.rs

@@ -20,7 +20,7 @@ pub fn is_dynamically_linked_to_libc(executable: impl AsRef<[u8]>) -> nix::Resul
 }
 
 fn get_interp(executable: &[u8]) -> nix::Result<Option<&BStr>> {
-    let elf = ElfBytes::<'_, AnyEndian>::minimal_parse(executable.as_ref())
+    let elf = ElfBytes::<'_, AnyEndian>::minimal_parse(executable)
         .map_err(|_| nix::Error::ENOEXEC)?;
     let Some(headers) = elf.segments() else {
         return Ok(None);
@@ -44,16 +44,15 @@ mod tests {
     use super::*;
     #[test]
     fn dynamic_executable() {
-        assert_eq!(is_dynamically_linked_to_libc(read("/bin/sh").unwrap()).unwrap(), true);
+        assert!(is_dynamically_linked_to_libc(read("/bin/sh").unwrap()).unwrap());
     }
     #[test]
     fn static_executable() {
         let cat = read("/bin/cat").unwrap();
         let ld_so_path = get_interp(&cat).unwrap().unwrap();
 
-        assert_eq!(
-            is_dynamically_linked_to_libc(read(OsStr::from_bytes(ld_so_path)).unwrap()).unwrap(),
-            false
+        assert!(
+            !is_dynamically_linked_to_libc(read(OsStr::from_bytes(ld_so_path)).unwrap()).unwrap()
         );
     }
 }

crates/vite_package_manager/src/package_manager.rs

@@ -880,7 +880,7 @@ mod tests {
         let package_json_path = temp_dir.path().join("package.json");
         let package_json: serde_json::Value =
             serde_json::from_slice(&fs::read(&package_json_path).unwrap()).unwrap();
-        println!("package_json: {:?}", package_json);
+        println!("package_json: {package_json:?}");
         assert!(package_json["packageManager"].as_str().unwrap().starts_with("pnpm@"));
         // keep other fields
         assert_eq!(package_json["version"].as_str().unwrap(), "1.0.0");
@@ -913,7 +913,7 @@ mod tests {
         let package_json_path = temp_dir_path.join("package.json");
         let package_json: serde_json::Value =
             serde_json::from_slice(&fs::read(&package_json_path).unwrap()).unwrap();
-        println!("package_json: {:?}", package_json);
+        println!("package_json: {package_json:?}");
         assert!(package_json["packageManager"].as_str().unwrap().starts_with("yarn@"));
         // keep other fields
         assert_eq!(package_json["name"].as_str().unwrap(), "test-package");
@@ -939,12 +939,12 @@ mod tests {
 
         // check shim files
         let bin_prefix = result.get_bin_prefix();
-        assert!(is_exists_file(&bin_prefix.join("npm")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("npm.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("npm.ps1")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("npx")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("npx.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("npx.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npm")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npm.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npm.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npx")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npx.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("npx.ps1")).unwrap());
 
         // run npm --version
         let mut paths =
@@ -985,12 +985,12 @@ mod tests {
 
         // check shim files
         let bin_prefix = result.get_bin_prefix();
-        assert!(is_exists_file(&bin_prefix.join("pnpm.cjs")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("pnpm.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("pnpm.ps1")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("pnpx.cjs")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("pnpx.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("pnpx.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpm.cjs")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpm.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpm.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpx.cjs")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpx.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("pnpx.ps1")).unwrap());
 
         // run pnpm --version
         let mut paths =
@@ -1126,13 +1126,13 @@ mod tests {
 
         // check shim files
         let bin_prefix = result.get_bin_prefix();
-        assert!(is_exists_file(&bin_prefix.join("yarn.js")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn.ps1")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.js")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg.ps1")).unwrap());
 
         // run pnpm --version
         let mut paths =
@@ -1226,13 +1226,13 @@ mod tests {
 
         // check shim files
         let bin_prefix = result.get_bin_prefix();
-        assert!(is_exists_file(&bin_prefix.join("yarn.js")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarn.ps1")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg.cmd")).unwrap());
-        assert!(is_exists_file(&bin_prefix.join("yarnpkg.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.js")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarn.ps1")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg.cmd")).unwrap());
+        assert!(is_exists_file(bin_prefix.join("yarnpkg.ps1")).unwrap());
 
         // run yarn --version
         let mut cmd = "yarn";
@@ -1292,13 +1292,13 @@ mod tests {
 
         let result = PackageManager::builder(temp_dir_path).build().await;
         assert!(result.is_err());
-        println!("result: {:?}", result);
+        println!("result: {result:?}");
         // Check if it's the expected error type
         if let Err(Error::PackageManagerVersionNotFound { name, version, .. }) = result {
             assert_eq!(name, "yarn");
             assert_eq!(version, "10000000000.0.0");
         } else {
-            panic!("Expected PackageManagerVersionNotFound error, got {:?}", result);
+            panic!("Expected PackageManagerVersionNotFound error, got {result:?}");
         }
     }
 
@@ -1311,7 +1311,7 @@ mod tests {
         create_package_json(&temp_dir_path, package_content);
 
         let result = PackageManager::builder(temp_dir_path).build().await;
-        println!("result: {:?}", result);
+        println!("result: {result:?}");
         assert!(result.is_err());
     }
 
@@ -1348,7 +1348,7 @@ mod tests {
         let result = PackageManager::builder(temp_dir_path).build().await;
         assert!(result.is_err());
         // Check if it's the expected error type
-        if let Err(Error::UnrecognizedPackageManager) = result {
+        if matches!(result, Err(Error::UnrecognizedPackageManager)) {
             // Expected error
         } else {
             panic!("Expected UnrecognizedPackageManager error");
@@ -1420,18 +1420,18 @@ mod tests {
                 .await;
         assert!(result.is_ok());
         let target_dir = result.unwrap();
-        println!("result: {:?}", target_dir);
-        assert!(is_exists_file(&target_dir.join("bin/yarn")).unwrap());
-        assert!(is_exists_file(&target_dir.join("bin/yarn.cmd")).unwrap());
+        println!("result: {target_dir:?}");
+        assert!(is_exists_file(target_dir.join("bin/yarn")).unwrap());
+        assert!(is_exists_file(target_dir.join("bin/yarn.cmd")).unwrap());
 
         // again should skip download
         let result =
             download_package_manager(PackageManagerType::Yarn, "@yarnpkg/cli-dist", "4.9.2", None)
                 .await;
         assert!(result.is_ok());
         let target_dir = result.unwrap();
-        assert!(is_exists_file(&target_dir.join("bin/yarn")).unwrap());
-        assert!(is_exists_file(&target_dir.join("bin/yarn.cmd")).unwrap());
+        assert!(is_exists_file(target_dir.join("bin/yarn")).unwrap());
+        assert!(is_exists_file(target_dir.join("bin/yarn.cmd")).unwrap());
 
         remove_dir_all_force(target_dir).await.unwrap();
     }

crates/vite_package_manager/src/request.rs

@@ -468,7 +468,7 @@ mod tests {
         let url = format!("{}/file.txt", server.base_url());
 
         let result = client.download_file(&url, &target_file).await;
-        assert!(result.is_ok(), "Failed to download file: {:?}", result);
+        assert!(result.is_ok(), "Failed to download file: {result:?}");
 
         // Verify file exists and has correct content
         assert!(target_file.exists());
@@ -513,7 +513,7 @@ mod tests {
 
         let url = format!("{}/test-package.tgz", server.base_url());
         let result = download_and_extract_tgz_with_hash(&url, &target_dir, None).await;
-        assert!(result.is_ok(), "Failed to download and extract: {:?}", result);
+        assert!(result.is_ok(), "Failed to download and extract: {result:?}");
 
         assert!(target_dir.join("package/bin/yarn").exists());
         assert!(target_dir.join("package/bin/yarn.cmd").exists());

crates/vite_package_manager/src/shim.rs

@@ -116,7 +116,7 @@ mod tests {
     use super::*;
 
     fn format_shim(shim: &str) -> String {
-        shim.replace(" ", "·")
+        shim.replace(' ', "·")
     }
 
     #[test]
@@ -402,7 +402,7 @@ mod tests {
             assert!(ps1.contains(path));
 
             let cmd = cmd_shim(path);
-            let expected_cmd_path = path.replace("/", "\\");
+            let expected_cmd_path = path.replace('/', "\\");
             assert!(cmd.contains(&expected_cmd_path));
         }
     }

crates/vite_path/src/absolute.rs

@@ -206,7 +206,7 @@ mod tests {
 
     #[test]
     fn non_absolute() {
-        assert!(AbsolutePath::new(Path::new("foo/bar")).is_none())
+        assert!(AbsolutePath::new(Path::new("foo/bar")).is_none());
     }
 
     #[test]