[ptr_arg]: recognize methods that also exist on slices

y21 · y21 · commit bb694615b835 · 2023-11-15T14:59:11.000+01:00
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
@@ -29,6 +29,8 @@ use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use std::{fmt, iter};
 
+use crate::vec::is_allowed_vec_method;
+
 declare_clippy_lint! {
     /// ### What it does
     /// This lint checks for function arguments of type `&String`, `&Vec`,
@@ -661,7 +663,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                             },
                             // If the types match check for methods which exist on both types. e.g. `Vec::len` and
                             // `slice::len`
-                            ty::Adt(def, _) if def.did() == args.ty_did => {
+                            ty::Adt(def, _) if def.did() == args.ty_did && !is_allowed_vec_method(self.cx, e) => {
                                 set_skip_flag();
                             },
                             _ => (),
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
@@ -58,7 +58,7 @@ fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 /// Checks if the given expression is a method call to a `Vec` method
 /// that also exists on slices. If this returns true, it means that
 /// this expression does not actually require a `Vec` and could just work with an array.
-fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+pub fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     const ALLOWED_METHOD_NAMES: &[&str] = &["len", "as_ptr", "is_empty"];
 
     if let ExprKind::MethodCall(path, ..) = e.kind {
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
@@ -1,4 +1,9 @@
-#![allow(clippy::if_same_then_else, clippy::no_effect, clippy::redundant_closure_call)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::no_effect,
+    clippy::redundant_closure_call,
+    clippy::ptr_arg
+)]
 #![warn(clippy::needless_pass_by_ref_mut)]
 #![feature(lint_reasons)]
 //@no-rustfix
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -1,5 +1,5 @@
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:7:11
+  --> $DIR/needless_pass_by_ref_mut.rs:12:11
    |
 LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    |           ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
@@ -8,131 +8,131 @@ LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    = help: to override `-D warnings` add `#[allow(clippy::needless_pass_by_ref_mut)]`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:32:12
+  --> $DIR/needless_pass_by_ref_mut.rs:37:12
    |
 LL | fn foo6(s: &mut Vec<u32>) {
    |            ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:45:29
+  --> $DIR/needless_pass_by_ref_mut.rs:50:29
    |
 LL |     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
    |                             ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:50:31
+  --> $DIR/needless_pass_by_ref_mut.rs:55:31
    |
 LL |     fn badger(&mut self, vec: &mut Vec<i32>) -> usize {
    |                               ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:127:16
+  --> $DIR/needless_pass_by_ref_mut.rs:132:16
    |
 LL | async fn a1(x: &mut i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:131:16
+  --> $DIR/needless_pass_by_ref_mut.rs:136:16
    |
 LL | async fn a2(x: &mut i32, y: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:135:16
+  --> $DIR/needless_pass_by_ref_mut.rs:140:16
    |
 LL | async fn a3(x: &mut i32, y: String, z: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:139:16
+  --> $DIR/needless_pass_by_ref_mut.rs:144:16
    |
 LL | async fn a4(x: &mut i32, y: i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:143:24
+  --> $DIR/needless_pass_by_ref_mut.rs:148:24
    |
 LL | async fn a5(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:147:24
+  --> $DIR/needless_pass_by_ref_mut.rs:152:24
    |
 LL | async fn a6(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:151:32
+  --> $DIR/needless_pass_by_ref_mut.rs:156:32
    |
 LL | async fn a7(x: i32, y: i32, z: &mut i32) {
    |                                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:24
+  --> $DIR/needless_pass_by_ref_mut.rs:160:24
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:45
+  --> $DIR/needless_pass_by_ref_mut.rs:160:45
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:189:16
+  --> $DIR/needless_pass_by_ref_mut.rs:194:16
    |
 LL | fn cfg_warn(s: &mut u32) {}
    |                ^^^^^^^^ help: consider changing to: `&u32`
    |
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:195:20
+  --> $DIR/needless_pass_by_ref_mut.rs:200:20
    |
 LL |     fn cfg_warn(s: &mut u32) {}
    |                    ^^^^^^^^ help: consider changing to: `&u32`
    |
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:209:39
+  --> $DIR/needless_pass_by_ref_mut.rs:214:39
    |
 LL | async fn inner_async2(x: &mut i32, y: &mut u32) {
    |                                       ^^^^^^^^ help: consider changing to: `&u32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:217:26
+  --> $DIR/needless_pass_by_ref_mut.rs:222:26
    |
 LL | async fn inner_async3(x: &mut i32, y: &mut u32) {
    |                          ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:236:34
+  --> $DIR/needless_pass_by_ref_mut.rs:241:34
    |
 LL | pub async fn call_in_closure1(n: &mut str) {
    |                                  ^^^^^^^^ help: consider changing to: `&str`
    |
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:248:25
+  --> $DIR/needless_pass_by_ref_mut.rs:253:25
    |
 LL | pub async fn closure(n: &mut usize) -> impl '_ + FnMut() {
    |                         ^^^^^^^^^^ help: consider changing to: `&usize`
    |
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:255:20
+  --> $DIR/needless_pass_by_ref_mut.rs:260:20
    |
 LL | pub fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
    |                    ^^^^^^^^^^ help: consider changing to: `&usize`
    |
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:266:26
+  --> $DIR/needless_pass_by_ref_mut.rs:271:26
    |
 LL | pub async fn closure4(n: &mut usize) {
    |                          ^^^^^^^^^^ help: consider changing to: `&usize`
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
@@ -22,6 +22,12 @@ fn do_vec_mut(x: &mut Vec<i64>) {
     //Nothing here
 }
 
+fn do_vec_mut2(x: &mut Vec<i64>) {
+    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
+    x.len();
+    x.is_empty();
+}
+
 fn do_str(x: &String) {
     //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice will d
     //Nothing here either
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
@@ -13,38 +13,44 @@ error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a sl
 LL | fn do_vec_mut(x: &mut Vec<i64>) {
    |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:25:19
+   |
+LL | fn do_vec_mut2(x: &mut Vec<i64>) {
+   |                   ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
+
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:25:14
+  --> $DIR/ptr_arg.rs:31:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:30:18
+  --> $DIR/ptr_arg.rs:36:18
    |
 LL | fn do_str_mut(x: &mut String) {
    |                  ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:35:15
+  --> $DIR/ptr_arg.rs:41:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:40:19
+  --> $DIR/ptr_arg.rs:46:19
    |
 LL | fn do_path_mut(x: &mut PathBuf) {
    |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:49:18
+  --> $DIR/ptr_arg.rs:55:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:63:14
+  --> $DIR/ptr_arg.rs:69:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -62,7 +68,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:73:18
+  --> $DIR/ptr_arg.rs:79:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -79,7 +85,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:82:19
+  --> $DIR/ptr_arg.rs:88:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -96,7 +102,7 @@ LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:91:44
+  --> $DIR/ptr_arg.rs:97:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -111,19 +117,19 @@ LL ~     let c = y;
    |
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:106:25
+  --> $DIR/ptr_arg.rs:112:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:136:66
+  --> $DIR/ptr_arg.rs:142:66
    |
 LL |     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
    |                                                                  ^^^^^^^ help: change this to: `&str`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:166:21
+  --> $DIR/ptr_arg.rs:172:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -137,7 +143,7 @@ LL ~         let _ = vec.to_owned().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:172:23
+  --> $DIR/ptr_arg.rs:178:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -151,7 +157,7 @@ LL ~         let _ = path.to_path_buf().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:178:21
+  --> $DIR/ptr_arg.rs:184:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
@@ -165,46 +171,46 @@ LL ~         let _ = str.to_path_buf().clone();
    |
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:185:29
+  --> $DIR/ptr_arg.rs:191:29
    |
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:17
+  --> $DIR/ptr_arg.rs:254:17
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                 ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:35
+  --> $DIR/ptr_arg.rs:254:35
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                   ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:51
+  --> $DIR/ptr_arg.rs:254:51
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:274:39
+  --> $DIR/ptr_arg.rs:280:39
    |
 LL |     fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
    |                                       ^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:280:36
+  --> $DIR/ptr_arg.rs:286:36
    |
 LL |     fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
    |                                    ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:284:40
+  --> $DIR/ptr_arg.rs:290:40
    |
 LL |     fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
    |                                        ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
-error: aborting due to 23 previous errors
+error: aborting due to 24 previous errors
 

Original file line number	Diff line number	Diff line change
@@ -13,38 +13,44 @@ error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a sl
`13`	`13`	`LL \| fn do_vec_mut(x: &mut Vec<i64>) {`
`14`	`14`	\| ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
`15`	`15`
	`16`	+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
	`17`	`+ --> $DIR/ptr_arg.rs:25:19`
	`18`	`+ \|`
	`19`	`+LL \| fn do_vec_mut2(x: &mut Vec<i64>) {`
	`20`	+ \| ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
	`21`	`+`
`16`	`22`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`17`		`- --> $DIR/ptr_arg.rs:25:14`
	`23`	`+ --> $DIR/ptr_arg.rs:31:14`
`18`	`24`	`\|`
`19`	`25`	`LL \| fn do_str(x: &String) {`
`20`	`26`	\| ^^^^^^^ help: change this to: `&str`
`21`	`27`
`22`	`28`	error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
`23`		`- --> $DIR/ptr_arg.rs:30:18`
	`29`	`+ --> $DIR/ptr_arg.rs:36:18`
`24`	`30`	`\|`
`25`	`31`	`LL \| fn do_str_mut(x: &mut String) {`
`26`	`32`	\| ^^^^^^^^^^^ help: change this to: `&mut str`
`27`	`33`
`28`	`34`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`29`		`- --> $DIR/ptr_arg.rs:35:15`
	`35`	`+ --> $DIR/ptr_arg.rs:41:15`
`30`	`36`	`\|`
`31`	`37`	`LL \| fn do_path(x: &PathBuf) {`
`32`	`38`	\| ^^^^^^^^ help: change this to: `&Path`
`33`	`39`
`34`	`40`	error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
`35`		`- --> $DIR/ptr_arg.rs:40:19`
	`41`	`+ --> $DIR/ptr_arg.rs:46:19`
`36`	`42`	`\|`
`37`	`43`	`LL \| fn do_path_mut(x: &mut PathBuf) {`
`38`	`44`	\| ^^^^^^^^^^^^ help: change this to: `&mut Path`
`39`	`45`
`40`	`46`	error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
`41`		`- --> $DIR/ptr_arg.rs:49:18`
	`47`	`+ --> $DIR/ptr_arg.rs:55:18`
`42`	`48`	`\|`
`43`	`49`	`LL \| fn do_vec(x: &Vec<i64>);`
`44`	`50`	\| ^^^^^^^^^ help: change this to: `&[i64]`
`45`	`51`
`46`	`52`	error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
`47`		`- --> $DIR/ptr_arg.rs:63:14`
	`53`	`+ --> $DIR/ptr_arg.rs:69:14`
`48`	`54`	`\|`
`49`	`55`	`LL \| fn cloned(x: &Vec<u8>) -> Vec<u8> {`
`50`	`56`	`\| ^^^^^^^^`
`@@ -62,7 +68,7 @@ LL ~ x.to_owned()`
`62`	`68`	`\|`
`63`	`69`
`64`	`70`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`65`		`- --> $DIR/ptr_arg.rs:73:18`
	`71`	`+ --> $DIR/ptr_arg.rs:79:18`
`66`	`72`	`\|`
`67`	`73`	`LL \| fn str_cloned(x: &String) -> String {`
`68`	`74`	`\| ^^^^^^^`
`@@ -79,7 +85,7 @@ LL ~ x.to_owned()`
`79`	`85`	`\|`
`80`	`86`
`81`	`87`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`82`		`- --> $DIR/ptr_arg.rs:82:19`
	`88`	`+ --> $DIR/ptr_arg.rs:88:19`
`83`	`89`	`\|`
`84`	`90`	`LL \| fn path_cloned(x: &PathBuf) -> PathBuf {`
`85`	`91`	`\| ^^^^^^^^`
`@@ -96,7 +102,7 @@ LL ~ x.to_path_buf()`
`96`	`102`	`\|`
`97`	`103`
`98`	`104`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`99`		`- --> $DIR/ptr_arg.rs:91:44`
	`105`	`+ --> $DIR/ptr_arg.rs:97:44`
`100`	`106`	`\|`
`101`	`107`	`LL \| fn false_positive_capacity(x: &Vec<u8>, y: &String) {`
`102`	`108`	`\| ^^^^^^^`
`@@ -111,19 +117,19 @@ LL ~ let c = y;`
`111`	`117`	`\|`
`112`	`118`
`113`	`119`	error: using a reference to `Cow` is not recommended
`114`		`- --> $DIR/ptr_arg.rs:106:25`
	`120`	`+ --> $DIR/ptr_arg.rs:112:25`
`115`	`121`	`\|`
`116`	`122`	`LL \| fn test_cow_with_ref(c: &Cow<[i32]>) {}`
`117`	`123`	\| ^^^^^^^^^^^ help: change this to: `&[i32]`
`118`	`124`
`119`	`125`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`120`		`- --> $DIR/ptr_arg.rs:136:66`
	`126`	`+ --> $DIR/ptr_arg.rs:142:66`
`121`	`127`	`\|`
`122`	`128`	`LL \| fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}`
`123`	`129`	\| ^^^^^^^ help: change this to: `&str`
`124`	`130`
`125`	`131`	error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
`126`		`- --> $DIR/ptr_arg.rs:166:21`
	`132`	`+ --> $DIR/ptr_arg.rs:172:21`
`127`	`133`	`\|`
`128`	`134`	`LL \| fn foo_vec(vec: &Vec<u8>) {`
`129`	`135`	`\| ^^^^^^^^`
`@@ -137,7 +143,7 @@ LL ~ let _ = vec.to_owned().clone();`
`137`	`143`	`\|`
`138`	`144`
`139`	`145`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`140`		`- --> $DIR/ptr_arg.rs:172:23`
	`146`	`+ --> $DIR/ptr_arg.rs:178:23`
`141`	`147`	`\|`
`142`	`148`	`LL \| fn foo_path(path: &PathBuf) {`
`143`	`149`	`\| ^^^^^^^^`
`@@ -151,7 +157,7 @@ LL ~ let _ = path.to_path_buf().clone();`
`151`	`157`	`\|`
`152`	`158`
`153`	`159`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`154`		`- --> $DIR/ptr_arg.rs:178:21`
	`160`	`+ --> $DIR/ptr_arg.rs:184:21`
`155`	`161`	`\|`
`156`	`162`	`LL \| fn foo_str(str: &PathBuf) {`
`157`	`163`	`\| ^^^^^^^^`
`@@ -165,46 +171,46 @@ LL ~ let _ = str.to_path_buf().clone();`
`165`	`171`	`\|`
`166`	`172`
`167`	`173`	error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
`168`		`- --> $DIR/ptr_arg.rs:185:29`
	`174`	`+ --> $DIR/ptr_arg.rs:191:29`
`169`	`175`	`\|`
`170`	`176`	`LL \| fn mut_vec_slice_methods(v: &mut Vec<u32>) {`
`171`	`177`	\| ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
`172`	`178`
`173`	`179`	error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
`174`		`- --> $DIR/ptr_arg.rs:248:17`
	`180`	`+ --> $DIR/ptr_arg.rs:254:17`
`175`	`181`	`\|`
`176`	`182`	`LL \| fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {`
`177`	`183`	\| ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
`178`	`184`
`179`	`185`	error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
`180`		`- --> $DIR/ptr_arg.rs:248:35`
	`186`	`+ --> $DIR/ptr_arg.rs:254:35`
`181`	`187`	`\|`
`182`	`188`	`LL \| fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {`
`183`	`189`	\| ^^^^^^^^^^^ help: change this to: `&mut str`
`184`	`190`
`185`	`191`	error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
`186`		`- --> $DIR/ptr_arg.rs:248:51`
	`192`	`+ --> $DIR/ptr_arg.rs:254:51`
`187`	`193`	`\|`
`188`	`194`	`LL \| fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {`
`189`	`195`	\| ^^^^^^^^^^^^ help: change this to: `&mut Path`
`190`	`196`
`191`	`197`	error: using a reference to `Cow` is not recommended
`192`		`- --> $DIR/ptr_arg.rs:274:39`
	`198`	`+ --> $DIR/ptr_arg.rs:280:39`
`193`	`199`	`\|`
`194`	`200`	`LL \| fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {`
`195`	`201`	\| ^^^^^^^^^^^^ help: change this to: `&str`
`196`	`202`
`197`	`203`	error: using a reference to `Cow` is not recommended
`198`		`- --> $DIR/ptr_arg.rs:280:36`
	`204`	`+ --> $DIR/ptr_arg.rs:286:36`
`199`	`205`	`\|`
`200`	`206`	`LL \| fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {`
`201`	`207`	\| ^^^^^^^^^^^^^^^^ help: change this to: `&str`
`202`	`208`
`203`	`209`	error: using a reference to `Cow` is not recommended
`204`		`- --> $DIR/ptr_arg.rs:284:40`
	`210`	`+ --> $DIR/ptr_arg.rs:290:40`
`205`	`211`	`\|`
`206`	`212`	`LL \| fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {`
`207`	`213`	\| ^^^^^^^^^^^^^^^^ help: change this to: `&str`
`208`	`214`
`209`		`-error: aborting due to 23 previous errors`
	`215`	`+error: aborting due to 24 previous errors`
`210`	`216`