rust/tests/ui/swap.fixed

189 lines
3.5 KiB
Rust
Raw Normal View History

2019-12-03 06:42:05 -06:00
// run-rustfix
#![warn(clippy::all)]
#![allow(
2022-06-08 14:08:37 -05:00
clippy::disallowed_names,
2019-12-03 06:42:05 -06:00
clippy::no_effect,
clippy::redundant_clone,
2020-03-03 17:54:27 -06:00
redundant_semicolons,
2021-07-29 07:08:17 -05:00
dead_code,
unused_assignments,
unused_variables
2019-12-03 06:42:05 -06:00
)]
struct Foo(u32);
#[derive(Clone)]
struct Bar {
a: u32,
b: u32,
}
fn field() {
let mut bar = Bar { a: 1, b: 2 };
2021-07-29 07:08:17 -05:00
std::mem::swap(&mut bar.a, &mut bar.b);
2019-12-03 06:42:05 -06:00
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];
foo.swap(0, 1);
foo.swap(0, 1);
}
fn slice() {
let foo = &mut [1, 2];
foo.swap(0, 1);
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
2021-07-29 07:08:17 -05:00
// this could use split_at_mut and mem::swap, but that is not much simpler.
2019-12-03 06:42:05 -06:00
}
fn vec() {
let mut foo = vec![1, 2];
foo.swap(0, 1);
foo.swap(0, 1);
}
2021-05-02 11:42:28 -05:00
fn xor_swap_locals() {
// This is an xor-based swap of local variables.
let mut a = 0;
let mut b = 1;
2023-03-02 13:29:45 -06:00
std::mem::swap(&mut a, &mut b);
2021-05-02 11:42:28 -05:00
}
fn xor_field_swap() {
// This is an xor-based swap of fields in a struct.
let mut bar = Bar { a: 0, b: 1 };
2023-03-02 13:29:45 -06:00
std::mem::swap(&mut bar.a, &mut bar.b);
2021-05-02 11:42:28 -05:00
}
fn xor_slice_swap() {
// This is an xor-based swap of a slice
let foo = &mut [1, 2];
2023-03-02 13:29:45 -06:00
foo.swap(0, 1);
2021-05-02 11:42:28 -05:00
}
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];
2021-07-29 07:08:17 -05:00
// 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]];
std::mem::swap(&mut foo[0][1], &mut bar[1][0]);
2021-05-02 11:42:28 -05:00
}
2019-12-03 06:42:05 -06:00
#[rustfmt::skip]
fn main() {
let mut a = 42;
let mut b = 1337;
std::mem::swap(&mut a, &mut b);
; std::mem::swap(&mut a, &mut b);
let mut c = Foo(42);
std::mem::swap(&mut c.0, &mut a);
; std::mem::swap(&mut c.0, &mut a);
std::mem::swap(&mut a, &mut b);
let mut c = 1;
let mut d = 2;
std::mem::swap(&mut d, &mut c);
let mut b = 1;
std::mem::swap(&mut a, &mut b);
let b = 1;
let a = 2;
let t = b;
let b = a;
let a = t;
let mut b = 1;
let mut a = 2;
std::mem::swap(&mut b, &mut a);
2019-12-03 06:42:05 -06:00
}
fn issue_8154() {
struct S1 {
x: i32,
y: i32,
}
struct S2(S1);
struct S3<'a, 'b>(&'a mut &'b mut S1);
impl std::ops::Deref for S2 {
type Target = S1;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::ops::DerefMut for S2 {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
// Don't lint. `s.0` is mutably borrowed by `s.x` and `s.y` via the deref impl.
let mut s = S2(S1 { x: 0, y: 0 });
let t = s.x;
s.x = s.y;
s.y = t;
// Accessing through a mutable reference is fine
let mut s = S1 { x: 0, y: 0 };
let mut s = &mut s;
let s = S3(&mut s);
std::mem::swap(&mut s.0.x, &mut s.0.y);
}
2022-11-18 06:51:43 -06:00
const fn issue_9864(mut u: u32) -> u32 {
let mut v = 10;
let temp = u;
u = v;
v = temp;
u + v
}