rust/tests/ui/unused_self.rs

141 lines
2.9 KiB
Rust
Raw Normal View History

2019-10-03 21:09:32 +02:00
#![warn(clippy::unused_self)]
2020-02-02 00:49:52 +01:00
#![allow(clippy::boxed_local, clippy::fn_params_excessive_bools)]
2019-10-03 21:09:32 +02:00
mod unused_self {
use std::pin::Pin;
use std::sync::{Arc, Mutex};
struct A {}
impl A {
fn unused_self_move(self) {}
fn unused_self_ref(&self) {}
fn unused_self_mut_ref(&mut self) {}
fn unused_self_pin_ref(self: Pin<&Self>) {}
fn unused_self_pin_mut_ref(self: Pin<&mut Self>) {}
fn unused_self_pin_nested(self: Pin<Arc<Self>>) {}
fn unused_self_box(self: Box<Self>) {}
fn unused_with_other_used_args(&self, x: u8, y: u8) -> u8 {
x + y
}
fn unused_self_class_method(&self) {
Self::static_method();
}
fn static_method() {}
}
}
mod unused_self_allow {
struct A {}
impl A {
// shouldn't trigger
#[allow(clippy::unused_self)]
fn unused_self_move(self) {}
}
struct B {}
// shouldn't trigger
#[allow(clippy::unused_self)]
impl B {
fn unused_self_move(self) {}
}
2020-03-29 22:22:28 +02:00
struct C {}
#[allow(clippy::unused_self)]
impl C {
#[warn(clippy::unused_self)]
fn some_fn((): ()) {}
// shouldn't trigger
fn unused_self_move(self) {}
}
}
2019-10-03 21:09:32 +02:00
mod used_self {
use std::pin::Pin;
struct A {
x: u8,
}
impl A {
fn used_self_move(self) -> u8 {
self.x
}
fn used_self_ref(&self) -> u8 {
self.x
}
fn used_self_mut_ref(&mut self) {
self.x += 1
}
fn used_self_pin_ref(self: Pin<&Self>) -> u8 {
self.x
}
fn used_self_box(self: Box<Self>) -> u8 {
self.x
}
fn used_self_with_other_unused_args(&self, x: u8, y: u8) -> u8 {
self.x
}
fn used_in_nested_closure(&self) -> u8 {
let mut a = || -> u8 { self.x };
a()
}
#[allow(clippy::collapsible_if)]
fn used_self_method_nested_conditions(&self, a: bool, b: bool, c: bool, d: bool) {
if a {
if b {
if c {
if d {
self.used_self_ref();
}
}
}
}
}
fn foo(&self) -> u32 {
let mut sum = 0u32;
for i in 0..self.x {
sum += i as u32;
}
sum
}
fn bar(&mut self, x: u8) -> u32 {
let mut y = 0u32;
for i in 0..x {
y += self.foo()
}
y
}
}
}
mod not_applicable {
use std::fmt;
struct A {}
impl fmt::Debug for A {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "A")
}
}
impl A {
fn method(x: u8, y: u8) {}
}
2019-10-04 19:18:52 +02:00
trait B {
fn method(&self) {}
}
2019-10-03 21:09:32 +02:00
}
fn main() {}