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
140
141
142
143
144
145
146
|
// run-rustfix
#![warn(clippy::all)]
#![allow(
clippy::blacklisted_name,
clippy::no_effect,
clippy::redundant_clone,
redundant_semicolons,
dead_code,
unused_assignments
)]
struct Foo(u32);
#[derive(Clone)]
struct Bar {
a: u32,
b: u32,
}
fn field() {
let mut bar = Bar { a: 1, b: 2 };
let temp = bar.a;
bar.a = bar.b;
bar.b = temp;
let mut baz = vec![bar.clone(), bar.clone()];
let temp = baz[0].a;
baz[0].a = baz[1].a;
baz[1].a = temp;
}
fn array() {
let mut foo = [1, 2];
let temp = foo[0];
foo[0] = foo[1];
foo[1] = temp;
foo.swap(0, 1);
}
fn slice() {
let foo = &mut [1, 2];
let temp = foo[0];
foo[0] = foo[1];
foo[1] = temp;
foo.swap(0, 1);
}
fn unswappable_slice() {
let foo = &mut [vec![1, 2], vec![3, 4]];
let temp = foo[0][1];
foo[0][1] = foo[1][0];
foo[1][0] = temp;
// swap(foo[0][1], foo[1][0]) would fail
// this could use split_at_mut and mem::swap, but that is not much simpler.
}
fn vec() {
let mut foo = vec![1, 2];
let temp = foo[0];
foo[0] = foo[1];
foo[1] = temp;
foo.swap(0, 1);
}
fn xor_swap_locals() {
// This is an xor-based swap of local variables.
let mut a = 0;
let mut b = 1;
a ^= b;
b ^= a;
a ^= b;
}
fn xor_field_swap() {
// This is an xor-based swap of fields in a struct.
let mut bar = Bar { a: 0, b: 1 };
bar.a ^= bar.b;
bar.b ^= bar.a;
bar.a ^= bar.b;
}
fn xor_slice_swap() {
// This is an xor-based swap of a slice
let foo = &mut [1, 2];
foo[0] ^= foo[1];
foo[1] ^= foo[0];
foo[0] ^= foo[1];
}
fn xor_no_swap() {
// This is a sequence of xor-assignment statements that doesn't result in a swap.
let mut a = 0;
let mut b = 1;
let mut c = 2;
a ^= b;
b ^= c;
a ^= c;
c ^= a;
}
fn xor_unswappable_slice() {
let foo = &mut [vec![1, 2], vec![3, 4]];
foo[0][1] ^= foo[1][0];
foo[1][0] ^= foo[0][0];
foo[0][1] ^= foo[1][0];
// swap(foo[0][1], foo[1][0]) would fail
// this could use split_at_mut and mem::swap, but that is not much simpler.
}
fn distinct_slice() {
let foo = &mut [vec![1, 2], vec![3, 4]];
let bar = &mut [vec![1, 2], vec![3, 4]];
let temp = foo[0][1];
foo[0][1] = bar[1][0];
bar[1][0] = temp;
}
#[rustfmt::skip]
fn main() {
let mut a = 42;
let mut b = 1337;
a = b;
b = a;
; let t = a;
a = b;
b = t;
let mut c = Foo(42);
c.0 = a;
a = c.0;
; let t = c.0;
c.0 = a;
a = t;
}
|
