src/tools/clippy/tests/ui/swap.fixed

   1 // run-rustfix
   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 )]
  12
  13 struct Foo(u32);
  14
  15 #[derive(Clone)]
  16 struct Bar {
  17     a: u32,
  18     b: u32,
  19 }
  20
  21 fn field() {
  22     let mut bar = Bar { a: 1, b: 2 };
  23
  24     std::mem::swap(&mut bar.a, &mut bar.b);
  25
  26     let mut baz = vec![bar.clone(), bar.clone()];
  27     let temp = baz[0].a;
  28     baz[0].a = baz[1].a;
  29     baz[1].a = temp;
  30 }
  31
  32 fn array() {
  33     let mut foo = [1, 2];
  34     foo.swap(0, 1);
  35
  36     foo.swap(0, 1);
  37 }
  38
  39 fn slice() {
  40     let foo = &mut [1, 2];
  41     foo.swap(0, 1);
  42
  43     foo.swap(0, 1);
  44 }
  45
  46 fn unswappable_slice() {
  47     let foo = &mut [vec![1, 2], vec![3, 4]];
  48     let temp = foo[0][1];
  49     foo[0][1] = foo[1][0];
  50     foo[1][0] = temp;
  51
  52     // swap(foo[0][1], foo[1][0]) would fail
  53     // this could use split_at_mut and mem::swap, but that is not much simpler.
  54 }
  55
  56 fn vec() {
  57     let mut foo = vec![1, 2];
  58     foo.swap(0, 1);
  59
  60     foo.swap(0, 1);
  61 }
  62
  63 fn xor_swap_locals() {
  64     // This is an xor-based swap of local variables.
  65     let mut a = 0;
  66     let mut b = 1;
  67     std::mem::swap(&mut a, &mut b)
  68 }
  69
  70 fn xor_field_swap() {
  71     // This is an xor-based swap of fields in a struct.
  72     let mut bar = Bar { a: 0, b: 1 };
  73     std::mem::swap(&mut bar.a, &mut bar.b)
  74 }
  75
  76 fn xor_slice_swap() {
  77     // This is an xor-based swap of a slice
  78     let foo = &mut [1, 2];
  79     foo.swap(0, 1)
  80 }
  81
  82 fn xor_no_swap() {
  83     // This is a sequence of xor-assignment statements that doesn't result in a swap.
  84     let mut a = 0;
  85     let mut b = 1;
  86     let mut c = 2;
  87     a ^= b;
  88     b ^= c;
  89     a ^= c;
  90     c ^= a;
  91 }
  92
  93 fn xor_unswappable_slice() {
  94     let foo = &mut [vec![1, 2], vec![3, 4]];
  95     foo[0][1] ^= foo[1][0];
  96     foo[1][0] ^= foo[0][0];
  97     foo[0][1] ^= foo[1][0];
  98
  99     // swap(foo[0][1], foo[1][0]) would fail
 100     // this could use split_at_mut and mem::swap, but that is not much simpler.
 101 }
 102
 103 fn distinct_slice() {
 104     let foo = &mut [vec![1, 2], vec![3, 4]];
 105     let bar = &mut [vec![1, 2], vec![3, 4]];
 106     std::mem::swap(&mut foo[0][1], &mut bar[1][0]);
 107 }
 108
 109 #[rustfmt::skip]
 110 fn main() {
 111
 112     let mut a = 42;
 113     let mut b = 1337;
 114
 115     std::mem::swap(&mut a, &mut b);
 116
 117     ; std::mem::swap(&mut a, &mut b);
 118
 119     let mut c = Foo(42);
 120
 121     std::mem::swap(&mut c.0, &mut a);
 122
 123     ; std::mem::swap(&mut c.0, &mut a);
 124 }
 125
 126 fn issue_8154() {
 127     struct S1 {
 128         x: i32,
 129         y: i32,
 130     }
 131     struct S2(S1);
 132     struct S3<'a, 'b>(&'a mut &'b mut S1);
 133
 134     impl std::ops::Deref for S2 {
 135         type Target = S1;
 136         fn deref(&self) -> &Self::Target {
 137             &self.0
 138         }
 139     }
 140     impl std::ops::DerefMut for S2 {
 141         fn deref_mut(&mut self) -> &mut Self::Target {
 142             &mut self.0
 143         }
 144     }
 145
 146     // Don't lint. `s.0` is mutably borrowed by `s.x` and `s.y` via the deref impl.
 147     let mut s = S2(S1 { x: 0, y: 0 });
 148     let t = s.x;
 149     s.x = s.y;
 150     s.y = t;
 151
 152     // Accessing through a mutable reference is fine
 153     let mut s = S1 { x: 0, y: 0 };
 154     let mut s = &mut s;
 155     let s = S3(&mut s);
 156     std::mem::swap(&mut s.0.x, &mut s.0.y);
 157 }
 158
 159 const fn issue_9864(mut u: u32) -> u32 {
 160     let mut v = 10;
 161
 162     let temp = u;
 163     u = v;
 164     v = temp;
 165     u + v
 166 }