2018-07-28 15:34:52 +00:00
|
|
|
#![warn(clippy::wrong_self_convention)]
|
2020-04-03 01:46:01 +00:00
|
|
|
#![allow(dead_code)]
|
2016-01-03 13:22:27 +00:00
|
|
|
|
|
|
|
fn main() {}
|
|
|
|
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
struct Foo;
|
|
|
|
|
|
|
|
impl Foo {
|
|
|
|
fn as_i32(self) {}
|
2017-01-05 02:01:53 +00:00
|
|
|
fn as_u32(&self) {}
|
2016-01-03 13:22:27 +00:00
|
|
|
fn into_i32(self) {}
|
|
|
|
fn is_i32(self) {}
|
2017-01-05 02:01:53 +00:00
|
|
|
fn is_u32(&self) {}
|
2016-01-03 13:22:27 +00:00
|
|
|
fn to_i32(self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
fn from_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2016-01-03 13:22:27 +00:00
|
|
|
|
|
|
|
pub fn as_i64(self) {}
|
|
|
|
pub fn into_i64(self) {}
|
|
|
|
pub fn is_i64(self) {}
|
|
|
|
pub fn to_i64(self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn from_i64(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2016-08-08 15:09:36 +00:00
|
|
|
// check whether the lint can be allowed at the function level
|
2018-07-28 15:34:52 +00:00
|
|
|
#[allow(clippy::wrong_self_convention)]
|
2016-08-08 15:09:36 +00:00
|
|
|
pub fn from_cake(self) {}
|
2016-01-03 13:22:27 +00:00
|
|
|
|
2018-12-09 22:26:16 +00:00
|
|
|
fn as_x<F: AsRef<Self>>(_: F) {}
|
|
|
|
fn as_y<F: AsRef<Foo>>(_: F) {}
|
2016-01-03 13:22:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct Bar;
|
|
|
|
|
|
|
|
impl Bar {
|
2017-02-08 13:58:07 +00:00
|
|
|
fn as_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mutabl
|
2017-01-05 02:01:53 +00:00
|
|
|
fn as_u32(&self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
fn into_i32(&self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `into_*` usually take `self` by value
|
2017-01-05 02:01:53 +00:00
|
|
|
fn into_u32(self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
fn is_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `self` b
|
2017-01-05 02:01:53 +00:00
|
|
|
fn is_u32(&self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
fn to_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is not
|
2017-01-05 02:01:53 +00:00
|
|
|
fn to_u32(&self) {}
|
2017-02-08 13:58:07 +00:00
|
|
|
fn from_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2016-01-03 13:22:27 +00:00
|
|
|
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn as_i64(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mutabl
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn into_i64(&self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `into_*` usually take `self` by value
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn is_i64(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `self` b
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn to_i64(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is not
|
2017-02-08 13:58:07 +00:00
|
|
|
pub fn from_i64(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2016-01-03 13:22:27 +00:00
|
|
|
|
2016-10-27 08:11:34 +00:00
|
|
|
// test for false positives
|
|
|
|
fn as_(self) {}
|
|
|
|
fn into_(&self) {}
|
|
|
|
fn is_(self) {}
|
|
|
|
fn to_(self) {}
|
|
|
|
fn from_(self) {}
|
2018-10-01 11:47:06 +00:00
|
|
|
fn to_mut(&mut self) {}
|
2016-01-03 13:22:27 +00:00
|
|
|
}
|
2019-08-10 04:01:15 +00:00
|
|
|
|
|
|
|
// Allow Box<Self>, Rc<Self>, Arc<Self> for methods that take conventionally take Self by value
|
|
|
|
#[allow(clippy::boxed_local)]
|
|
|
|
mod issue4293 {
|
|
|
|
use std::rc::Rc;
|
|
|
|
use std::sync::Arc;
|
|
|
|
|
|
|
|
struct T;
|
|
|
|
|
|
|
|
impl T {
|
|
|
|
fn into_s1(self: Box<Self>) {}
|
|
|
|
fn into_s2(self: Rc<Self>) {}
|
|
|
|
fn into_s3(self: Arc<Self>) {}
|
|
|
|
|
|
|
|
fn into_t1(self: Box<T>) {}
|
|
|
|
fn into_t2(self: Rc<T>) {}
|
|
|
|
fn into_t3(self: Arc<T>) {}
|
|
|
|
}
|
|
|
|
}
|
2020-08-21 06:18:05 +00:00
|
|
|
|
|
|
|
// False positive for async (see #4037)
|
|
|
|
mod issue4037 {
|
|
|
|
pub struct Foo;
|
|
|
|
pub struct Bar;
|
|
|
|
|
|
|
|
impl Foo {
|
|
|
|
pub async fn into_bar(self) -> Bar {
|
|
|
|
Bar
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-09 22:38:08 +00:00
|
|
|
|
|
|
|
// Lint also in trait definition (see #6307)
|
2020-11-10 07:56:17 +00:00
|
|
|
mod issue6307 {
|
2020-11-09 22:38:08 +00:00
|
|
|
trait T: Sized {
|
|
|
|
fn as_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mu
|
2020-11-09 22:38:08 +00:00
|
|
|
fn as_u32(&self) {}
|
2020-12-30 11:02:26 +00:00
|
|
|
fn into_i32(self) {}
|
|
|
|
fn into_i32_ref(&self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `into_*` usually take `self` by value
|
2020-11-09 22:38:08 +00:00
|
|
|
fn into_u32(self) {}
|
|
|
|
fn is_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `sel
|
2020-11-09 22:38:08 +00:00
|
|
|
fn is_u32(&self) {}
|
|
|
|
fn to_i32(self) {}
|
|
|
|
fn to_u32(&self) {}
|
|
|
|
fn from_i32(self) {}
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2020-11-09 22:38:08 +00:00
|
|
|
// check whether the lint can be allowed at the function level
|
2020-11-10 07:56:17 +00:00
|
|
|
#[allow(clippy::wrong_self_convention)]
|
2020-11-09 22:38:08 +00:00
|
|
|
fn from_cake(self) {}
|
|
|
|
|
|
|
|
// test for false positives
|
|
|
|
fn as_(self) {}
|
|
|
|
fn into_(&self) {}
|
|
|
|
fn is_(self) {}
|
|
|
|
fn to_(self) {}
|
|
|
|
fn from_(self) {}
|
|
|
|
fn to_mut(&mut self) {}
|
|
|
|
}
|
2020-12-10 16:00:55 +00:00
|
|
|
|
|
|
|
trait U {
|
|
|
|
fn as_i32(self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mu
|
2020-12-10 16:00:55 +00:00
|
|
|
fn as_u32(&self);
|
2020-12-30 11:02:26 +00:00
|
|
|
fn into_i32(self);
|
|
|
|
fn into_i32_ref(&self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `into_*` usually take `self` by value
|
2020-12-30 11:02:26 +00:00
|
|
|
fn into_u32(self);
|
|
|
|
fn is_i32(self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `sel
|
2020-12-30 11:02:26 +00:00
|
|
|
fn is_u32(&self);
|
|
|
|
fn to_i32(self);
|
|
|
|
fn to_u32(&self);
|
|
|
|
fn from_i32(self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2020-12-30 11:02:26 +00:00
|
|
|
// check whether the lint can be allowed at the function level
|
|
|
|
#[allow(clippy::wrong_self_convention)]
|
|
|
|
fn from_cake(self);
|
|
|
|
|
|
|
|
// test for false positives
|
|
|
|
fn as_(self);
|
|
|
|
fn into_(&self);
|
|
|
|
fn is_(self);
|
|
|
|
fn to_(self);
|
|
|
|
fn from_(self);
|
|
|
|
fn to_mut(&mut self);
|
|
|
|
}
|
|
|
|
|
|
|
|
trait C: Copy {
|
|
|
|
fn as_i32(self);
|
|
|
|
fn as_u32(&self);
|
|
|
|
fn into_i32(self);
|
|
|
|
fn into_i32_ref(&self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `into_*` usually take `self` by value
|
2020-12-10 16:00:55 +00:00
|
|
|
fn into_u32(self);
|
|
|
|
fn is_i32(self);
|
|
|
|
fn is_u32(&self);
|
|
|
|
fn to_i32(self);
|
|
|
|
fn to_u32(&self);
|
|
|
|
fn from_i32(self);
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods called `from_*` usually take no `self`
|
2020-12-10 16:00:55 +00:00
|
|
|
// check whether the lint can be allowed at the function level
|
|
|
|
#[allow(clippy::wrong_self_convention)]
|
|
|
|
fn from_cake(self);
|
|
|
|
|
|
|
|
// test for false positives
|
|
|
|
fn as_(self);
|
|
|
|
fn into_(&self);
|
|
|
|
fn is_(self);
|
|
|
|
fn to_(self);
|
|
|
|
fn from_(self);
|
|
|
|
fn to_mut(&mut self);
|
|
|
|
}
|
2020-11-10 07:56:17 +00:00
|
|
|
}
|
2021-03-17 14:52:14 +00:00
|
|
|
|
|
|
|
mod issue6727 {
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
struct FooCopy;
|
|
|
|
|
2021-03-29 19:51:23 +00:00
|
|
|
impl FooCopy {
|
2021-03-17 14:52:14 +00:00
|
|
|
fn to_u64(self) -> u64 {
|
|
|
|
1
|
|
|
|
}
|
|
|
|
// trigger lint
|
|
|
|
fn to_u64_v2(&self) -> u64 {
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is
|
2021-03-17 14:52:14 +00:00
|
|
|
1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct FooNoCopy;
|
|
|
|
|
2021-03-29 19:51:23 +00:00
|
|
|
impl FooNoCopy {
|
2021-03-17 14:52:14 +00:00
|
|
|
// trigger lint
|
|
|
|
fn to_u64(self) -> u64 {
|
2023-07-28 19:35:48 +00:00
|
|
|
//~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is
|
2021-03-17 14:52:14 +00:00
|
|
|
2
|
|
|
|
}
|
|
|
|
fn to_u64_v2(&self) -> u64 {
|
|
|
|
2
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
wrong_self_convention: Match `SelfKind::No` more restrictively
The `wrong_self_convention` lint uses a `SelfKind` type to decide
whether a method has the right kind of "self" for its name, or whether
the kind of "self" it has makes its name confusable for a method in
a common trait. One possibility is `SelfKind::No`, which is supposed
to mean "No `self`".
Previously, SelfKind::No matched everything _except_ Self, including
references to Self. This patch changes it to match Self, &Self, &mut
Self, Box<Self>, and so on.
For example, this kind of method was allowed before:
```
impl S {
// Should trigger the lint, because
// "methods called `is_*` usually take `self` by reference or no `self`"
fn is_foo(&mut self) -> bool { todo!() }
}
```
But since SelfKind::No matched "&mut self", no lint was triggered
(see #8142).
With this patch, the code above now gives a lint as expected.
Fixes #8142
changelog: [`wrong_self_convention`] rejects `self` references in more cases
2022-01-01 04:39:40 +00:00
|
|
|
|
|
|
|
pub mod issue8142 {
|
|
|
|
struct S;
|
|
|
|
|
|
|
|
impl S {
|
|
|
|
// Should not lint: "no self at all" is allowed.
|
|
|
|
fn is_forty_two(x: u32) -> bool {
|
|
|
|
x == 42
|
|
|
|
}
|
|
|
|
|
|
|
|
// Should not lint: &self is allowed.
|
|
|
|
fn is_test_code(&self) -> bool {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|