fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
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}