style: fix clippy::semicolon_if_nothing_returned

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/vite_package_manager/src/package_manager.rs

@@ -934,7 +934,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");
@@ -967,7 +967,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");
@@ -993,12 +993,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 =
@@ -1039,12 +1039,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 =
@@ -1180,13 +1180,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 =
@@ -1280,13 +1280,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";
@@ -1346,13 +1346,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:?}");
         }
     }
 
@@ -1365,7 +1365,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());
     }
 
@@ -1402,7 +1402,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");
@@ -1474,18 +1474,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();
     }
@@ -1683,7 +1683,7 @@ mod tests {
                 version: "1.0.0".into(),
                 hash: None,
                 bin_name: pm_type.to_string().into(),
-                workspace_root: temp_dir_path.clone(),
+                workspace_root: temp_dir_path,
                 install_dir,
             }
         }

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]

crates/vite_path/src/relative.rs

@@ -326,54 +326,54 @@ mod tests {
     #[test]
     fn normalize_dots() {
         let rel_path = RelativePathBuf::new("./foo/./bar/.").unwrap();
-        assert_eq!(rel_path.as_str(), "foo/bar")
+        assert_eq!(rel_path.as_str(), "foo/bar");
     }
 
     #[test]
     fn normalize_trailing_slashes() {
         let rel_path = RelativePathBuf::new("foo/bar//").unwrap();
-        assert_eq!(rel_path.as_str(), "foo/bar")
+        assert_eq!(rel_path.as_str(), "foo/bar");
     }
     #[test]
     fn preserve_double_dots() {
         let rel_path = RelativePathBuf::new("../foo/../bar/..").unwrap();
-        assert_eq!(rel_path.as_str(), "../foo/../bar/..")
+        assert_eq!(rel_path.as_str(), "../foo/../bar/..");
     }
 
     #[test]
     fn push() {
         let mut rel_path = RelativePathBuf::new("foo/bar").unwrap();
         rel_path.push(RelativePathBuf::new(Path::new("baz")).unwrap());
-        assert_eq!(rel_path.as_str(), "foo/bar/baz")
+        assert_eq!(rel_path.as_str(), "foo/bar/baz");
     }
 
     #[test]
     fn push_empty() {
         let mut rel_path = RelativePathBuf::new("foo/bar").unwrap();
         rel_path.push(RelativePathBuf::new("").unwrap());
-        assert_eq!(rel_path.as_str(), "foo/bar")
+        assert_eq!(rel_path.as_str(), "foo/bar");
     }
 
     #[test]
     fn join() {
         let rel_path = RelativePathBuf::new("foo/bar").unwrap();
         let joined_path = rel_path.as_relative_path().join(RelativePathBuf::new("baz").unwrap());
-        assert_eq!(joined_path.as_str(), "foo/bar/baz")
+        assert_eq!(joined_path.as_str(), "foo/bar/baz");
     }
 
     #[test]
     fn join_empty() {
         let rel_path = RelativePathBuf::new("").unwrap();
         let joined_path = rel_path.as_relative_path().join(RelativePathBuf::new("baz").unwrap());
-        assert_eq!(joined_path.as_str(), "baz")
+        assert_eq!(joined_path.as_str(), "baz");
     }
 
     #[test]
     fn strip_prefix() {
         let rel_path = RelativePathBuf::new("foo/bar/baz").unwrap();
         let prefix = RelativePathBuf::new("foo").unwrap();
         let stripped_path = rel_path.strip_prefix(prefix).unwrap();
-        assert_eq!(stripped_path.as_str(), "bar/baz")
+        assert_eq!(stripped_path.as_str(), "bar/baz");
     }
 
     #[test]