/
redundant_clone.fixed
138 lines (106 loc) · 2.6 KB
/
redundant_clone.fixed
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
// run-rustfix
// rustfix-only-machine-applicable
use std::ffi::OsString;
use std::path::Path;
fn main() {
let _s = ["lorem", "ipsum"].join(" ");
let s = String::from("foo");
let _s = s;
let s = String::from("foo");
let _s = s;
let s = String::from("foo");
let _s = s;
let _s = Path::new("/a/b/").join("c");
let _s = Path::new("/a/b/").join("c");
let _s = OsString::new();
let _s = OsString::new();
// Check that lint level works
#[allow(clippy::redundant_clone)]
let _s = String::new().to_string();
let tup = (String::from("foo"),);
let _t = tup.0;
let tup_ref = &(String::from("foo"),);
let _s = tup_ref.0.clone(); // this `.clone()` cannot be removed
{
let x = String::new();
let y = &x;
let _x = x.clone(); // ok; `x` is borrowed by `y`
let _ = y.len();
}
let x = (String::new(),);
let _ = Some(String::new()).unwrap_or_else(|| x.0.clone()); // ok; closure borrows `x`
with_branch(Alpha, true);
cannot_double_move(Alpha);
cannot_move_from_type_with_drop();
borrower_propagation();
}
#[derive(Clone)]
struct Alpha;
fn with_branch(a: Alpha, b: bool) -> (Alpha, Alpha) {
if b {
(a.clone(), a)
} else {
(Alpha, a)
}
}
fn cannot_double_move(a: Alpha) -> (Alpha, Alpha) {
(a.clone(), a)
}
struct TypeWithDrop {
x: String,
}
impl Drop for TypeWithDrop {
fn drop(&mut self) {}
}
fn cannot_move_from_type_with_drop() -> String {
let s = TypeWithDrop { x: String::new() };
s.x.clone() // removing this `clone()` summons E0509
}
fn borrower_propagation() {
let s = String::new();
let t = String::new();
{
fn b() -> bool {
unimplemented!()
}
let _u = if b() { &s } else { &t };
// ok; `s` and `t` are possibly borrowed
let _s = s.clone();
let _t = t.clone();
}
{
let _u = || s.len();
let _v = [&t; 32];
let _s = s.clone(); // ok
let _t = t.clone(); // ok
}
{
let _u = {
let u = Some(&s);
let _ = s.clone(); // ok
u
};
let _s = s.clone(); // ok
}
{
use std::convert::identity as id;
let _u = id(id(&s));
let _s = s.clone(); // ok, `u` borrows `s`
}
let _s = s;
let _t = t;
#[derive(Clone)]
struct Foo {
x: usize,
}
{
let f = Foo { x: 123 };
let _x = Some(f.x);
let _f = f;
}
{
let f = Foo { x: 123 };
let _x = &f.x;
let _f = f.clone(); // ok
}
}