tests/ui/mir/mir_augmented_assignments.rs

   1 // run-pass
   2 use std::mem;
   3 use std::ops::{
   4     AddAssign, BitAndAssign, BitOrAssign, BitXorAssign, DivAssign, MulAssign, RemAssign,
   5     ShlAssign, ShrAssign, SubAssign,
   6 };
   7
   8 #[derive(Debug, PartialEq)]
   9 struct Int(i32);
  10
  11 struct Slice([i32]);
  12
  13 impl Slice {
  14     fn new(slice: &mut [i32]) -> &mut Slice {
  15         unsafe {
  16             mem::transmute(slice)
  17         }
  18     }
  19 }
  20
  21 fn main() {
  22     main_mir();
  23 }
  24
  25 fn main_mir() {
  26     let mut x = Int(1);
  27
  28     x += Int(2);
  29     assert_eq!(x, Int(0b11));
  30
  31     x &= Int(0b01);
  32     assert_eq!(x, Int(0b01));
  33
  34     x |= Int(0b10);
  35     assert_eq!(x, Int(0b11));
  36
  37     x ^= Int(0b01);
  38     assert_eq!(x, Int(0b10));
  39
  40     x /= Int(2);
  41     assert_eq!(x, Int(1));
  42
  43     x *= Int(3);
  44     assert_eq!(x, Int(3));
  45
  46     x %= Int(2);
  47     assert_eq!(x, Int(1));
  48
  49     // overloaded RHS
  50     x <<= 1u8;
  51     assert_eq!(x, Int(2));
  52
  53     x <<= 1u16;
  54     assert_eq!(x, Int(4));
  55
  56     x >>= 1u8;
  57     assert_eq!(x, Int(2));
  58
  59     x >>= 1u16;
  60     assert_eq!(x, Int(1));
  61
  62     x -= Int(1);
  63     assert_eq!(x, Int(0));
  64
  65     // indexed LHS
  66     // FIXME(mir-drop): use the vec![..] macro
  67     let mut v = Vec::new();
  68     v.push(Int(1));
  69     v.push(Int(2));
  70     v[0] += Int(2);
  71     assert_eq!(v[0], Int(3));
  72
  73     // unsized RHS
  74     let mut array = [0, 1, 2];
  75     *Slice::new(&mut array) += 1;
  76     assert_eq!(array[0], 1);
  77     assert_eq!(array[1], 2);
  78     assert_eq!(array[2], 3);
  79
  80 }
  81
  82 impl AddAssign for Int {
  83     fn add_assign(&mut self, rhs: Int) {
  84         self.0 += rhs.0;
  85     }
  86 }
  87
  88 impl BitAndAssign for Int {
  89     fn bitand_assign(&mut self, rhs: Int) {
  90         self.0 &= rhs.0;
  91     }
  92 }
  93
  94 impl BitOrAssign for Int {
  95     fn bitor_assign(&mut self, rhs: Int) {
  96         self.0 |= rhs.0;
  97     }
  98 }
  99
 100 impl BitXorAssign for Int {
 101     fn bitxor_assign(&mut self, rhs: Int) {
 102         self.0 ^= rhs.0;
 103     }
 104 }
 105
 106 impl DivAssign for Int {
 107     fn div_assign(&mut self, rhs: Int) {
 108         self.0 /= rhs.0;
 109     }
 110 }
 111
 112 impl MulAssign for Int {
 113     fn mul_assign(&mut self, rhs: Int) {
 114         self.0 *= rhs.0;
 115     }
 116 }
 117
 118 impl RemAssign for Int {
 119     fn rem_assign(&mut self, rhs: Int) {
 120         self.0 %= rhs.0;
 121     }
 122 }
 123
 124 impl ShlAssign<u8> for Int {
 125     fn shl_assign(&mut self, rhs: u8) {
 126         self.0 <<= rhs;
 127     }
 128 }
 129
 130 impl ShlAssign<u16> for Int {
 131     fn shl_assign(&mut self, rhs: u16) {
 132         self.0 <<= rhs;
 133     }
 134 }
 135
 136 impl ShrAssign<u8> for Int {
 137     fn shr_assign(&mut self, rhs: u8) {
 138         self.0 >>= rhs;
 139     }
 140 }
 141
 142 impl ShrAssign<u16> for Int {
 143     fn shr_assign(&mut self, rhs: u16) {
 144         self.0 >>= rhs;
 145     }
 146 }
 147
 148 impl SubAssign for Int {
 149     fn sub_assign(&mut self, rhs: Int) {
 150         self.0 -= rhs.0;
 151     }
 152 }
 153
 154 impl AddAssign<i32> for Slice {
 155     fn add_assign(&mut self, rhs: i32) {
 156         for lhs in &mut self.0 {
 157             *lhs += rhs;
 158         }
 159     }
 160 }