refactor: run clippy with --all-targets

Boshen · Boshen · commit 53a2df0da4bd · 2024-12-11T20:15:37.000+08:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -102,7 +102,7 @@ jobs:
       - uses: Boshen/setup-rust@main
         with:
           components: clippy
-      - run: cargo clippy --all-features -- -D warnings
+      - run: cargo clippy --all-features --all-targets -- -D warnings
 
   doc:
     name: Doc
diff --git a/benches/resolver.rs b/benches/resolver.rs
@@ -17,7 +17,7 @@ fn data() -> Vec<(PathBuf, &'static str)> {
         (cwd.clone(), "@napi-rs/wasm-runtime"),
         (cwd.clone(), "ava"),
         (cwd.clone(), "emnapi"),
-        (cwd.clone(), "typescript"),
+        (cwd, "typescript"),
         // relative path
         (f1.clone(), "./"),
         (f1.clone(), "./lib/index"),
diff --git a/justfile b/justfile
@@ -52,7 +52,7 @@ test:
 
 # Lint the whole project
 lint:
-  cargo clippy --all-features -- --deny warnings
+  cargo clippy --all-features --all-targets -- --deny warnings
 
 # Generate doc
 doc:
diff --git a/src/tests/alias.rs b/src/tests/alias.rs
@@ -6,6 +6,7 @@ use normalize_path::NormalizePath;
 
 use crate::{AliasValue, Resolution, ResolveContext, ResolveError, ResolveOptions, Resolver};
 
+#[allow(clippy::too_many_lines)]
 #[test]
 #[cfg(not(target_os = "windows"))] // MemoryFS's path separator is always `/` so the test will not pass in windows.
 fn alias() {
diff --git a/src/tests/dependencies.rs b/src/tests/dependencies.rs
@@ -4,8 +4,6 @@
 mod windows {
     use std::path::PathBuf;
 
-    use rustc_hash::FxHashSet;
-
     use super::super::memory_fs::MemoryFS;
     use crate::{ResolveContext, ResolveOptions, ResolverGeneric};
 
@@ -96,13 +94,11 @@ mod windows {
         for (name, context, request, result, file_dependencies, missing_dependencies) in data {
             let mut ctx = ResolveContext::default();
             let path = PathBuf::from(context);
-            let resolved =
+            let resolved_path =
                 resolver.resolve_with_context(path, request, &mut ctx).map(|r| r.full_path());
-            assert_eq!(resolved, Ok(PathBuf::from(result)));
-            let file_dependencies =
-                FxHashSet::from_iter(file_dependencies.iter().map(PathBuf::from));
-            let missing_dependencies =
-                FxHashSet::from_iter(missing_dependencies.iter().map(PathBuf::from));
+            assert_eq!(resolved_path, Ok(PathBuf::from(result)));
+            let file_dependencies = file_dependencies.iter().map(PathBuf::from).collect();
+            let missing_dependencies = missing_dependencies.iter().map(PathBuf::from).collect();
             assert_eq!(ctx.file_dependencies, file_dependencies, "{name}");
             assert_eq!(ctx.missing_dependencies, missing_dependencies, "{name}");
         }
diff --git a/src/tests/exports_field.rs b/src/tests/exports_field.rs
@@ -2522,7 +2522,7 @@ fn test_cases() {
             ..ResolveOptions::default()
         });
         let cached_path = resolver.cache.value(Path::new(""));
-        let resolved = resolver
+        let resolved_path = resolver
             .package_exports_resolve(
                 &cached_path,
                 case.request,
@@ -2533,18 +2533,23 @@ fn test_cases() {
         if let Some(expect) = case.expect {
             if expect.is_empty() {
                 assert!(
-                    matches!(resolved, Err(ResolveError::PackagePathNotExported(_, _))),
+                    matches!(resolved_path, Err(ResolveError::PackagePathNotExported(_, _))),
                     "{} {:?}",
                     &case.name,
-                    &resolved
+                    &resolved_path
                 );
             } else {
                 for expect in expect {
-                    assert_eq!(resolved, Ok(Some(Path::new(expect).normalize())), "{}", &case.name);
+                    assert_eq!(
+                        resolved_path,
+                        Ok(Some(Path::new(expect).normalize())),
+                        "{}",
+                        &case.name
+                    );
                 }
             }
         } else {
-            assert!(resolved.is_err(), "{} {resolved:?}", &case.name);
+            assert!(resolved_path.is_err(), "{} {resolved_path:?}", &case.name);
         }
     }
 }
diff --git a/src/tests/imports_field.rs b/src/tests/imports_field.rs
@@ -106,6 +106,7 @@ fn imports_field(value: serde_json::Value) -> JSONMap {
     serde_json::from_str(&s).unwrap()
 }
 
+#[allow(clippy::too_many_lines)]
 #[test]
 fn test_cases() {
     let test_cases = [
@@ -1298,7 +1299,7 @@ fn test_cases() {
     for case in test_cases {
         let resolver = Resolver::default();
         let cached_path = resolver.cache.value(Path::new(""));
-        let resolved = resolver
+        let resolved_path = resolver
             .package_imports_exports_resolve(
                 case.request,
                 &case.imports_field,
@@ -1310,14 +1311,19 @@ fn test_cases() {
             .map(|p| p.map(|p| p.to_path_buf()));
         if let Some(expect) = case.expect {
             if expect.is_empty() {
-                assert!(matches!(resolved, Ok(None)), "{} {:?}", &case.name, &resolved);
+                assert!(matches!(resolved_path, Ok(None)), "{} {:?}", &case.name, &resolved_path);
             } else {
                 for expect in expect {
-                    assert_eq!(resolved, Ok(Some(Path::new(expect).normalize())), "{}", &case.name);
+                    assert_eq!(
+                        resolved_path,
+                        Ok(Some(Path::new(expect).normalize())),
+                        "{}",
+                        &case.name
+                    );
                 }
             }
         } else {
-            assert!(resolved.is_err(), "{} {resolved:?}", &case.name);
+            assert!(resolved_path.is_err(), "{} {resolved_path:?}", &case.name);
         }
     }
 }
