wrong_self_convention: Enhance lint message

mgacek8 · mgacek8 · commit 1f2d01641d6e · 2021-03-19T20:29:55.000+01:00
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -2348,10 +2348,10 @@ impl SelfKind {
     #[must_use]
     fn description(self) -> &'static str {
         match self {
-            Self::Value => "self by value",
-            Self::Ref => "self by reference",
-            Self::RefMut => "self by mutable reference",
-            Self::No => "no self",
+            Self::Value => "`self` by value",
+            Self::Ref => "`self` by reference",
+            Self::RefMut => "`self` by mutable reference",
+            Self::No => "no `self`",
         }
     }
 }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -51,13 +51,16 @@ impl Convention {
 impl fmt::Display for Convention {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            Self::Eq(this) => this.fmt(f),
-            Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
-            Self::EndsWith(this) => '*'.fmt(f).and_then(|_| this.fmt(f)),
-            Self::NotEndsWith(this) => '~'.fmt(f).and_then(|_| this.fmt(f)),
-            Self::IsSelfTypeCopy(is_true) => format!("self type is {} Copy", if is_true { "" } else { "not" }).fmt(f),
+            Self::Eq(this) => format!("`{}`", this).fmt(f),
+            Self::StartsWith(this) => format!("`{}*`", this).fmt(f),
+            Self::EndsWith(this) => format!("`*{}`", this).fmt(f),
+            Self::NotEndsWith(this) => format!("`~{}`", this).fmt(f),
+            Self::IsSelfTypeCopy(is_true) => {
+                format!("`self` type is{} `Copy`", if is_true { "" } else { " not" }).fmt(f)
+            },
             Self::ImplementsTrait(is_true) => {
-                format!("Method {} implement a trait", if is_true { "" } else { "do not" }).fmt(f)
+                let (negation, s_suffix) = if is_true { ("", "s") } else { (" does not", "") };
+                format!("Method{} implement{} a trait", negation, s_suffix).fmt(f)
             },
         }
     }
@@ -99,15 +102,15 @@ pub(super) fn check<'tcx>(
                             {
                                 None
                             } else {
-                                Some(format!("`{}`", &conv.to_string()))
+                                Some(conv.to_string())
                             }
                         })
                         .collect::<Vec<_>>()
                         .join(" and ");
 
                     format!("methods with the following characteristics: ({})", &s)
                 } else {
-                    format!("methods called `{}`", &conventions[0])
+                    format!("methods called {}", &conventions[0])
                 }
             };
 
diff --git a/tests/ui/def_id_nocore.stderr b/tests/ui/def_id_nocore.stderr
@@ -1,4 +1,4 @@
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/def_id_nocore.rs:26:19
    |
 LL |     pub fn as_ref(self) -> &'static str {
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
@@ -1,4 +1,4 @@
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:18:17
    |
 LL |     fn from_i32(self) {}
@@ -7,183 +7,183 @@ LL |     fn from_i32(self) {}
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:24:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:36:15
    |
 LL |     fn as_i32(self) {}
    |               ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:38:17
    |
 LL |     fn into_i32(&self) {}
    |                 ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:40:15
    |
 LL |     fn is_i32(self) {}
    |               ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:42:15
    |
 LL |     fn to_i32(self) {}
    |               ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:44:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:46:19
    |
 LL |     pub fn as_i64(self) {}
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:47:21
    |
 LL |     pub fn into_i64(&self) {}
    |                     ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:48:19
    |
 LL |     pub fn is_i64(self) {}
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:49:19
    |
 LL |     pub fn to_i64(self) {}
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:50:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:95:19
    |
 LL |         fn as_i32(self) {}
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:98:25
    |
 LL |         fn into_i32_ref(&self) {}
    |                         ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:100:19
    |
 LL |         fn is_i32(self) {}
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:104:21
    |
 LL |         fn from_i32(self) {}
    |                     ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:119:19
    |
 LL |         fn as_i32(self);
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:122:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:124:19
    |
 LL |         fn is_i32(self);
    |                   ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:128:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:146:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:152:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is  Copy`) usually take self by value
+error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
   --> $DIR/wrong_self_convention.rs:181:22
    |
 LL |         fn to_u64_v2(&self) -> u64 {
    |                      ^^^^^
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:190:19
    |
 LL |         fn to_u64(self) -> u64 {
diff --git a/tests/ui/wrong_self_conventions_mut.stderr b/tests/ui/wrong_self_conventions_mut.stderr
@@ -1,4 +1,4 @@
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_conventions_mut.rs:15:24
    |
 LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
@@ -7,7 +7,7 @@ LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `*_mut`) usually take self by mutable reference
+error: methods with the following characteristics: (`to_*` and `*_mut`) usually take `self` by mutable reference
   --> $DIR/wrong_self_conventions_mut.rs:23:28
    |
 LL |         pub fn to_many_mut(&self) -> Option<&[T]> {

Original file line number	Diff line number	Diff line change
`@@ -2348,10 +2348,10 @@ impl SelfKind {`
`2348`	`2348`	`#[must_use]`
`2349`	`2349`	`fn description(self) -> &'static str {`
`2350`	`2350`	`match self {`
`2351`		`- Self::Value => "self by value",`
`2352`		`- Self::Ref => "self by reference",`
`2353`		`- Self::RefMut => "self by mutable reference",`
`2354`		`- Self::No => "no self",`
	`2351`	+ Self::Value => "`self` by value",
	`2352`	+ Self::Ref => "`self` by reference",
	`2353`	+ Self::RefMut => "`self` by mutable reference",
	`2354`	+ Self::No => "no `self`",
`2355`	`2355`	`}`
`2356`	`2356`	`}`
`2357`	`2357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		-error: methods called `as_*` usually take self by reference or self by mutable reference
	`1`	+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
`2`	`2`	`--> $DIR/def_id_nocore.rs:26:19`
`3`	`3`	`\|`
`4`	`4`	`LL \| pub fn as_ref(self) -> &'static str {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		-error: methods called `from_*` usually take no self
	`1`	+error: methods called `from_*` usually take no `self`
`2`	`2`	`--> $DIR/wrong_self_convention.rs:18:17`
`3`	`3`	`\|`
`4`	`4`	`LL \| fn from_i32(self) {}`
`@@ -7,183 +7,183 @@ LL \| fn from_i32(self) {}`
`7`	`7`	= note: `-D clippy::wrong-self-convention` implied by `-D warnings`
`8`	`8`	`= help: consider choosing a less ambiguous name`
`9`	`9`
`10`		-error: methods called `from_*` usually take no self
	`10`	+error: methods called `from_*` usually take no `self`
`11`	`11`	`--> $DIR/wrong_self_convention.rs:24:21`
`12`	`12`	`\|`
`13`	`13`	`LL \| pub fn from_i64(self) {}`
`14`	`14`	`\| ^^^^`
`15`	`15`	`\|`
`16`	`16`	`= help: consider choosing a less ambiguous name`
`17`	`17`
`18`		-error: methods called `as_*` usually take self by reference or self by mutable reference
	`18`	+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
`19`	`19`	`--> $DIR/wrong_self_convention.rs:36:15`
`20`	`20`	`\|`
`21`	`21`	`LL \| fn as_i32(self) {}`
`22`	`22`	`\| ^^^^`
`23`	`23`	`\|`
`24`	`24`	`= help: consider choosing a less ambiguous name`
`25`	`25`
`26`		-error: methods called `into_*` usually take self by value
	`26`	+error: methods called `into_*` usually take `self` by value
`27`	`27`	`--> $DIR/wrong_self_convention.rs:38:17`
`28`	`28`	`\|`
`29`	`29`	`LL \| fn into_i32(&self) {}`
`30`	`30`	`\| ^^^^^`
`31`	`31`	`\|`
`32`	`32`	`= help: consider choosing a less ambiguous name`
`33`	`33`
`34`		-error: methods called `is_*` usually take self by reference or no self
	`34`	+error: methods called `is_*` usually take `self` by reference or no `self`
`35`	`35`	`--> $DIR/wrong_self_convention.rs:40:15`
`36`	`36`	`\|`
`37`	`37`	`LL \| fn is_i32(self) {}`
`38`	`38`	`\| ^^^^`
`39`	`39`	`\|`
`40`	`40`	`= help: consider choosing a less ambiguous name`
`41`	`41`
`42`		-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
	`42`	+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
`43`	`43`	`--> $DIR/wrong_self_convention.rs:42:15`
`44`	`44`	`\|`
`45`	`45`	`LL \| fn to_i32(self) {}`
`46`	`46`	`\| ^^^^`
`47`	`47`	`\|`
`48`	`48`	`= help: consider choosing a less ambiguous name`
`49`	`49`
`50`		-error: methods called `from_*` usually take no self
	`50`	+error: methods called `from_*` usually take no `self`
`51`	`51`	`--> $DIR/wrong_self_convention.rs:44:17`
`52`	`52`	`\|`
`53`	`53`	`LL \| fn from_i32(self) {}`
`54`	`54`	`\| ^^^^`
`55`	`55`	`\|`
`56`	`56`	`= help: consider choosing a less ambiguous name`
`57`	`57`
`58`		-error: methods called `as_*` usually take self by reference or self by mutable reference
	`58`	+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
`59`	`59`	`--> $DIR/wrong_self_convention.rs:46:19`
`60`	`60`	`\|`
`61`	`61`	`LL \| pub fn as_i64(self) {}`
`62`	`62`	`\| ^^^^`
`63`	`63`	`\|`
`64`	`64`	`= help: consider choosing a less ambiguous name`
`65`	`65`
`66`		-error: methods called `into_*` usually take self by value
	`66`	+error: methods called `into_*` usually take `self` by value
`67`	`67`	`--> $DIR/wrong_self_convention.rs:47:21`
`68`	`68`	`\|`
`69`	`69`	`LL \| pub fn into_i64(&self) {}`
`70`	`70`	`\| ^^^^^`
`71`	`71`	`\|`
`72`	`72`	`= help: consider choosing a less ambiguous name`
`73`	`73`
`74`		-error: methods called `is_*` usually take self by reference or no self
	`74`	+error: methods called `is_*` usually take `self` by reference or no `self`
`75`	`75`	`--> $DIR/wrong_self_convention.rs:48:19`
`76`	`76`	`\|`
`77`	`77`	`LL \| pub fn is_i64(self) {}`
`78`	`78`	`\| ^^^^`
`79`	`79`	`\|`
`80`	`80`	`= help: consider choosing a less ambiguous name`
`81`	`81`
`82`		-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
	`82`	+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
`83`	`83`	`--> $DIR/wrong_self_convention.rs:49:19`
`84`	`84`	`\|`
`85`	`85`	`LL \| pub fn to_i64(self) {}`
`86`	`86`	`\| ^^^^`
`87`	`87`	`\|`
`88`	`88`	`= help: consider choosing a less ambiguous name`
`89`	`89`
`90`		-error: methods called `from_*` usually take no self
	`90`	+error: methods called `from_*` usually take no `self`
`91`	`91`	`--> $DIR/wrong_self_convention.rs:50:21`
`92`	`92`	`\|`
`93`	`93`	`LL \| pub fn from_i64(self) {}`
`94`	`94`	`\| ^^^^`
`95`	`95`	`\|`
`96`	`96`	`= help: consider choosing a less ambiguous name`
`97`	`97`
`98`		-error: methods called `as_*` usually take self by reference or self by mutable reference
	`98`	+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
`99`	`99`	`--> $DIR/wrong_self_convention.rs:95:19`
`100`	`100`	`\|`
`101`	`101`	`LL \| fn as_i32(self) {}`
`102`	`102`	`\| ^^^^`
`103`	`103`	`\|`
`104`	`104`	`= help: consider choosing a less ambiguous name`
`105`	`105`
`106`		-error: methods called `into_*` usually take self by value
	`106`	+error: methods called `into_*` usually take `self` by value
`107`	`107`	`--> $DIR/wrong_self_convention.rs:98:25`
`108`	`108`	`\|`
`109`	`109`	`LL \| fn into_i32_ref(&self) {}`
`110`	`110`	`\| ^^^^^`
`111`	`111`	`\|`
`112`	`112`	`= help: consider choosing a less ambiguous name`
`113`	`113`
`114`		-error: methods called `is_*` usually take self by reference or no self
	`114`	+error: methods called `is_*` usually take `self` by reference or no `self`
`115`	`115`	`--> $DIR/wrong_self_convention.rs:100:19`
`116`	`116`	`\|`
`117`	`117`	`LL \| fn is_i32(self) {}`
`118`	`118`	`\| ^^^^`
`119`	`119`	`\|`
`120`	`120`	`= help: consider choosing a less ambiguous name`
`121`	`121`
`122`		-error: methods called `from_*` usually take no self
	`122`	+error: methods called `from_*` usually take no `self`
`123`	`123`	`--> $DIR/wrong_self_convention.rs:104:21`
`124`	`124`	`\|`
`125`	`125`	`LL \| fn from_i32(self) {}`
`126`	`126`	`\| ^^^^`
`127`	`127`	`\|`
`128`	`128`	`= help: consider choosing a less ambiguous name`
`129`	`129`
`130`		-error: methods called `as_*` usually take self by reference or self by mutable reference
	`130`	+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
`131`	`131`	`--> $DIR/wrong_self_convention.rs:119:19`
`132`	`132`	`\|`
`133`	`133`	`LL \| fn as_i32(self);`
`134`	`134`	`\| ^^^^`
`135`	`135`	`\|`
`136`	`136`	`= help: consider choosing a less ambiguous name`
`137`	`137`
`138`		-error: methods called `into_*` usually take self by value
	`138`	+error: methods called `into_*` usually take `self` by value
`139`	`139`	`--> $DIR/wrong_self_convention.rs:122:25`
`140`	`140`	`\|`
`141`	`141`	`LL \| fn into_i32_ref(&self);`
`142`	`142`	`\| ^^^^^`
`143`	`143`	`\|`
`144`	`144`	`= help: consider choosing a less ambiguous name`
`145`	`145`
`146`		-error: methods called `is_*` usually take self by reference or no self
	`146`	+error: methods called `is_*` usually take `self` by reference or no `self`
`147`	`147`	`--> $DIR/wrong_self_convention.rs:124:19`
`148`	`148`	`\|`
`149`	`149`	`LL \| fn is_i32(self);`
`150`	`150`	`\| ^^^^`
`151`	`151`	`\|`
`152`	`152`	`= help: consider choosing a less ambiguous name`
`153`	`153`
`154`		-error: methods called `from_*` usually take no self
	`154`	+error: methods called `from_*` usually take no `self`
`155`	`155`	`--> $DIR/wrong_self_convention.rs:128:21`
`156`	`156`	`\|`
`157`	`157`	`LL \| fn from_i32(self);`
`158`	`158`	`\| ^^^^`
`159`	`159`	`\|`
`160`	`160`	`= help: consider choosing a less ambiguous name`
`161`	`161`
`162`		-error: methods called `into_*` usually take self by value
	`162`	+error: methods called `into_*` usually take `self` by value
`163`	`163`	`--> $DIR/wrong_self_convention.rs:146:25`
`164`	`164`	`\|`
`165`	`165`	`LL \| fn into_i32_ref(&self);`
`166`	`166`	`\| ^^^^^`
`167`	`167`	`\|`
`168`	`168`	`= help: consider choosing a less ambiguous name`
`169`	`169`
`170`		-error: methods called `from_*` usually take no self
	`170`	+error: methods called `from_*` usually take no `self`
`171`	`171`	`--> $DIR/wrong_self_convention.rs:152:21`
`172`	`172`	`\|`
`173`	`173`	`LL \| fn from_i32(self);`
`174`	`174`	`\| ^^^^`
`175`	`175`	`\|`
`176`	`176`	`= help: consider choosing a less ambiguous name`
`177`	`177`
`178`		-error: methods with the following characteristics: (`to_*` and `self type is Copy`) usually take self by value
	`178`	+error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
`179`	`179`	`--> $DIR/wrong_self_convention.rs:181:22`
`180`	`180`	`\|`
`181`	`181`	`LL \| fn to_u64_v2(&self) -> u64 {`
`182`	`182`	`\| ^^^^^`
`183`	`183`	`\|`
`184`	`184`	`= help: consider choosing a less ambiguous name`
`185`	`185`
`186`		-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
	`186`	+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
`187`	`187`	`--> $DIR/wrong_self_convention.rs:190:19`
`188`	`188`	`\|`
`189`	`189`	`LL \| fn to_u64(self) -> u64 {`