fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
3.8 KiB202 linesraw
1//@aux-build: macro_rules.rs
2
3#![warn(clippy::all)]
4#![allow(
5    clippy::disallowed_names,
6    clippy::no_effect,
7    clippy::redundant_clone,
8    redundant_semicolons,
9    dead_code,
10    unused_assignments,
11    unused_variables,
12    clippy::let_and_return,
13    clippy::useless_vec,
14    clippy::redundant_locals
15)]
16
17struct Foo(u32);
18
19#[derive(Clone)]
20struct Bar {
21    a: u32,
22    b: u32,
23}
24
25fn field() {
26    let mut bar = Bar { a: 1, b: 2 };
27
28    std::mem::swap(&mut bar.a, &mut bar.b);
29
30    let mut baz = vec![bar.clone(), bar.clone()];
31    let temp = baz[0].a;
32    baz[0].a = baz[1].a;
33    baz[1].a = temp;
34}
35
36fn array() {
37    let mut foo = [1, 2];
38    foo.swap(0, 1);
39
40    foo.swap(0, 1);
41}
42
43fn slice() {
44    let foo = &mut [1, 2];
45    foo.swap(0, 1);
46
47    foo.swap(0, 1);
48}
49
50fn unswappable_slice() {
51    let foo = &mut [vec![1, 2], vec![3, 4]];
52    let temp = foo[0][1];
53    foo[0][1] = foo[1][0];
54    foo[1][0] = temp;
55
56    // swap(foo[0][1], foo[1][0]) would fail
57    // this could use split_at_mut and mem::swap, but that is not much simpler.
58}
59
60fn vec() {
61    let mut foo = vec![1, 2];
62    foo.swap(0, 1);
63
64    foo.swap(0, 1);
65}
66
67fn xor_swap_locals() {
68    // This is an xor-based swap of local variables.
69    let mut a = 0;
70    let mut b = 1;
71    std::mem::swap(&mut a, &mut b);
72}
73
74fn xor_field_swap() {
75    // This is an xor-based swap of fields in a struct.
76    let mut bar = Bar { a: 0, b: 1 };
77    std::mem::swap(&mut bar.a, &mut bar.b);
78}
79
80fn xor_slice_swap() {
81    // This is an xor-based swap of a slice
82    let foo = &mut [1, 2];
83    foo.swap(0, 1);
84}
85
86fn xor_no_swap() {
87    // This is a sequence of xor-assignment statements that doesn't result in a swap.
88    let mut a = 0;
89    let mut b = 1;
90    let mut c = 2;
91    a ^= b;
92    b ^= c;
93    a ^= c;
94    c ^= a;
95}
96
97fn xor_unswappable_slice() {
98    let foo = &mut [vec![1, 2], vec![3, 4]];
99    foo[0][1] ^= foo[1][0];
100    foo[1][0] ^= foo[0][0];
101    foo[0][1] ^= foo[1][0];
102
103    // swap(foo[0][1], foo[1][0]) would fail
104    // this could use split_at_mut and mem::swap, but that is not much simpler.
105}
106
107fn distinct_slice() {
108    let foo = &mut [vec![1, 2], vec![3, 4]];
109    let bar = &mut [vec![1, 2], vec![3, 4]];
110    std::mem::swap(&mut foo[0][1], &mut bar[1][0]);
111}
112
113#[rustfmt::skip]
114fn main() {
115
116    let mut a = 42;
117    let mut b = 1337;
118
119    std::mem::swap(&mut a, &mut b);
120
121    ; std::mem::swap(&mut a, &mut b);
122
123    let mut c = Foo(42);
124
125    std::mem::swap(&mut c.0, &mut a);
126
127    ; std::mem::swap(&mut c.0, &mut a);
128
129    std::mem::swap(&mut a, &mut b);
130
131    let mut c = 1;
132    let mut d = 2;
133    std::mem::swap(&mut d, &mut c);
134
135    let mut b = 1;
136    std::mem::swap(&mut a, &mut b);
137
138    let b = 1;
139    let a = 2;
140
141    let t = b;
142    let b = a;
143    let a = t;
144
145    let mut b = 1;
146    let mut a = 2;
147
148    std::mem::swap(&mut b, &mut a);
149}
150
151fn issue_8154() {
152    struct S1 {
153        x: i32,
154        y: i32,
155    }
156    struct S2(S1);
157    struct S3<'a, 'b>(&'a mut &'b mut S1);
158
159    impl std::ops::Deref for S2 {
160        type Target = S1;
161        fn deref(&self) -> &Self::Target {
162            &self.0
163        }
164    }
165    impl std::ops::DerefMut for S2 {
166        fn deref_mut(&mut self) -> &mut Self::Target {
167            &mut self.0
168        }
169    }
170
171    // Don't lint. `s.0` is mutably borrowed by `s.x` and `s.y` via the deref impl.
172    let mut s = S2(S1 { x: 0, y: 0 });
173    let t = s.x;
174    s.x = s.y;
175    s.y = t;
176
177    // Accessing through a mutable reference is fine
178    let mut s = S1 { x: 0, y: 0 };
179    let mut s = &mut s;
180    let s = S3(&mut s);
181    std::mem::swap(&mut s.0.x, &mut s.0.y);
182}
183
184const fn issue_9864(mut u: u32) -> u32 {
185    let mut v = 10;
186
187    let temp = u;
188    u = v;
189    v = temp;
190    u + v
191}
192
193#[macro_use]
194extern crate macro_rules;
195
196const fn issue_10421(x: u32) -> u32 {
197    issue_10421!();
198    let a = x;
199    let a = a;
200    let a = a;
201    a
202}