don't change parameters referring to generics used elsewhere

Author: ada4a

clippy_lints/src/needless_path_new.rs

@@ -88,14 +88,31 @@ fn check_arguments<'tcx>(
 
     let implements_asref_path = |arg| implements_trait(cx, arg, asref_def_id, &[path_ty.into()]);
 
-    if let ty::FnDef(def_id, ..) = type_definition.kind()
+    if let ty::FnDef(def_id, generic_args) = type_definition.kind()
         // if there are any bound vars, just give up... we might be able to be smarter here
         && let Some(fn_sig) = type_definition.fn_sig(tcx).no_bound_vars()
     {
         let parameters = fn_sig.inputs();
 
         let bounds = tcx.param_env(def_id).caller_bounds();
         dbg!(bounds);
+        let generic_args_we_can_change: Vec<_> = generic_args
+            .iter()
+            .filter_map(|g| g.as_type())
+            // if a generic is used in multiple places, we should better not touch it,
+            // since we'd need to suggest changing both parameters that using it at once,
+            // which might not be possible
+            .filter(|g| {
+                let inputs_and_output = fn_sig.inputs().iter().copied().chain([fn_sig.output()]);
+                inputs_and_output.filter(|i| i.contains(*g)).count() < 2
+            })
+            .collect();
+        dbg!(&generic_args_we_can_change);
+
+        if generic_args_we_can_change.is_empty() {
+            // can't change anything
+            return;
+        }
 
         for (argument, parameter) in iter::zip(arguments, parameters) {
             // we want `argument` to be `Path::new(x)`, which has one arg, x

tests/ui/needless_path_new.rs

@@ -10,6 +10,7 @@ fn takes_impl_path(_: impl AsRef<Path>) {}
 fn takes_path_and_impl_path(_: &Path, _: impl AsRef<Path>) {}
 
 fn takes_two_impl_paths_with_the_same_generic<P: AsRef<Path>>(_: P, _: P) {}
+fn takes_two_impl_paths_with_different_generics<P: AsRef<Path>>(_: P, _: P) {}
 
 struct Foo;
 
@@ -37,8 +38,8 @@ fn main() {
         Path::new("bar"), //~ needless_path_new
     );
 
-    // we can and should change both at the same time
-    takes_two_impl_paths_with_the_same_generic(
+    // we can and should change both independently
+    takes_two_impl_paths_with_different_generics(
         Path::new("foo"), //~ needless_path_new
         Path::new("bar"), //~ needless_path_new
     );
@@ -58,8 +59,7 @@ fn main() {
     Foo::takes_path_and_impl_path(Path::new("foo"), "bar");
     f.takes_self_and_path_and_impl_path(Path::new("foo"), "bar");
 
-    fn foo() -> Option<&'static Path> {
-        // Some(...) is `ExprKind::Call`, but we don't consider it
-        Some(Path::new("foo.txt"))
-    }
+    // we are conservative and don't suggest changing a parameter
+    // if it contains a generic type used elsewhere in the function
+    takes_two_impl_paths_with_the_same_generic(Path::new("foo"), Path::new("bar"));
 }