1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
// run-rustfix
#![warn(clippy::explicit_deref_methods)]
#![allow(unused_variables)]
#![allow(
clippy::borrow_deref_ref,
clippy::clone_double_ref,
clippy::explicit_auto_deref,
clippy::needless_borrow,
clippy::uninlined_format_args
)]
use std::ops::{Deref, DerefMut};
fn concat(deref_str: &str) -> String {
format!("{}bar", deref_str)
}
fn just_return(deref_str: &str) -> &str {
deref_str
}
struct CustomVec(Vec<u8>);
impl Deref for CustomVec {
type Target = Vec<u8>;
fn deref(&self) -> &Vec<u8> {
&self.0
}
}
fn main() {
let a: &mut String = &mut String::from("foo");
// these should require linting
let b: &str = a.deref();
let b: &mut str = a.deref_mut();
// both derefs should get linted here
let b: String = format!("{}, {}", a.deref(), a.deref());
println!("{}", a.deref());
#[allow(clippy::match_single_binding)]
match a.deref() {
_ => (),
}
let b: String = concat(a.deref());
let b = just_return(a).deref();
let b: String = concat(just_return(a).deref());
let b: &str = a.deref().deref();
let opt_a = Some(a.clone());
let b = opt_a.unwrap().deref();
// following should not require linting
let cv = CustomVec(vec![0, 42]);
let c = cv.deref()[0];
let b: &str = &*a.deref();
let b: String = a.deref().clone();
let b: usize = a.deref_mut().len();
let b: &usize = &a.deref().len();
let b: &str = &*a;
let b: &mut str = &mut *a;
macro_rules! expr_deref {
($body:expr) => {
$body.deref()
};
}
let b: &str = expr_deref!(a);
let b: &str = expr_deref!(a.deref());
// The struct does not implement Deref trait
#[derive(Copy, Clone)]
struct NoLint(u32);
impl NoLint {
pub fn deref(self) -> u32 {
self.0
}
pub fn deref_mut(self) -> u32 {
self.0
}
}
let no_lint = NoLint(42);
let b = no_lint.deref();
let b = no_lint.deref_mut();
}
|