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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
#![warn(clippy::needless_borrowed_reference)]
#![allow(
unused,
irrefutable_let_patterns,
non_shorthand_field_patterns,
clippy::needless_borrow,
clippy::needless_if
)]
fn main() {}
struct Struct {
a: usize,
b: usize,
c: usize,
}
struct TupleStruct(u8, u8, u8);
fn should_lint(
array: [u8; 4],
slice: &[u8],
slice_of_refs: &[&u8],
vec: Vec<u8>,
tuple: (u8, u8, u8),
tuple_struct: TupleStruct,
s: Struct,
) {
let mut v = Vec::<String>::new();
let _ = v.iter_mut().filter(|&ref a| a.is_empty());
//~^ needless_borrowed_reference
let var = 3;
let thingy = Some(&var);
if let Some(&ref v) = thingy {}
//~^ needless_borrowed_reference
if let &[&ref a, ref b] = slice_of_refs {}
//~^ needless_borrowed_reference
let &[ref a, ..] = &array;
//~^ needless_borrowed_reference
let &[ref a, ref b, ..] = &array;
//~^ needless_borrowed_reference
if let &[ref a, ref b] = slice {}
//~^ needless_borrowed_reference
if let &[ref a, ref b] = &vec[..] {}
//~^ needless_borrowed_reference
if let &[ref a, ref b, ..] = slice {}
//~^ needless_borrowed_reference
if let &[ref a, .., ref b] = slice {}
//~^ needless_borrowed_reference
if let &[.., ref a, ref b] = slice {}
//~^ needless_borrowed_reference
if let &[ref a, _] = slice {}
//~^ needless_borrowed_reference
if let &(ref a, ref b, ref c) = &tuple {}
//~^ needless_borrowed_reference
if let &(ref a, _, ref c) = &tuple {}
//~^ needless_borrowed_reference
if let &(ref a, ..) = &tuple {}
//~^ needless_borrowed_reference
if let &TupleStruct(ref a, ..) = &tuple_struct {}
//~^ needless_borrowed_reference
if let &Struct {
//~^ needless_borrowed_reference
ref a,
b: ref b,
c: ref renamed,
} = &s
{}
if let &Struct { ref a, b: _, .. } = &s {}
//~^ needless_borrowed_reference
}
fn should_not_lint(
array: [u8; 4],
slice: &[u8],
slice_of_refs: &[&u8],
vec: Vec<u8>,
tuple: (u8, u8, u8),
tuple_struct: TupleStruct,
s: Struct,
) {
if let [a] = slice {}
if let &[ref a, b] = slice {}
if let &[ref a, .., b] = slice {}
if let &(ref a, b, ..) = &tuple {}
if let &TupleStruct(ref a, b, ..) = &tuple_struct {}
if let &Struct { ref a, b, .. } = &s {}
// must not be removed as variables must be bound consistently across | patterns
if let (&[ref a], _) | ([], ref a) = (slice_of_refs, &1u8) {}
// the `&`s here technically could be removed, but it'd be noisy and without a `ref` doesn't match
// the lint name
if let &[] = slice {}
if let &[_] = slice {}
if let &[..] = slice {}
if let &(..) = &tuple {}
if let &TupleStruct(..) = &tuple_struct {}
if let &Struct { .. } = &s {}
let mut var2 = 5;
let thingy2 = Some(&mut var2);
if let Some(&mut ref mut v) = thingy2 {
// ^ should **not** be linted
// v is borrowed as mutable.
*v = 10;
}
if let Some(&mut ref v) = thingy2 {
// ^ should **not** be linted
// here, v is borrowed as immutable.
// can't do that:
//*v = 15;
}
}
enum Animal {
Cat(u64),
Dog(u64),
}
fn foo(a: &Animal, b: &Animal) {
match (a, b) {
// lifetime mismatch error if there is no '&ref' before `feature(nll)` stabilization in 1.63
(&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (),
// ^ and ^ should **not** be linted
(Animal::Dog(a), &Animal::Dog(_)) => (),
}
}
|
