mirror of
https://github.com/rust-lang/rust-clippy
synced 2024-12-02 17:40:13 +00:00
124 lines
2.3 KiB
Rust
124 lines
2.3 KiB
Rust
// 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 };
|
|
|
|
std::mem::swap(&mut bar.a, &mut bar.b);
|
|
|
|
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
|
|
// this could use split_at_mut and mem::swap, but that is not much simpler.
|
|
}
|
|
|
|
fn vec() {
|
|
let mut foo = vec![1, 2];
|
|
foo.swap(0, 1);
|
|
|
|
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;
|
|
std::mem::swap(&mut a, &mut b)
|
|
}
|
|
|
|
fn xor_field_swap() {
|
|
// This is an xor-based swap of fields in a struct.
|
|
let mut bar = Bar { a: 0, b: 1 };
|
|
std::mem::swap(&mut bar.a, &mut bar.b)
|
|
}
|
|
|
|
fn xor_slice_swap() {
|
|
// This is an xor-based swap of a slice
|
|
let foo = &mut [1, 2];
|
|
foo.swap(0, 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]];
|
|
std::mem::swap(&mut foo[0][1], &mut bar[1][0]);
|
|
}
|
|
|
|
#[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);
|
|
}
|