src/test/run-pass/augmented-assignments.rs

   1 #![allow(unused_imports)]
   2 #![deny(unused_assignments)]
   3
   4 use std::mem;
   5 use std::ops::{
   6     AddAssign, BitAndAssign, BitOrAssign, BitXorAssign, DivAssign, Index, MulAssign, RemAssign,
   7     ShlAssign, ShrAssign, SubAssign,
   8 };
   9
  10 #[derive(Debug, PartialEq)]
  11 struct Int(i32);
  12
  13 struct Slice([i32]);
  14
  15 impl Slice {
  16     fn new(slice: &mut [i32]) -> &mut Slice {
  17         unsafe {
  18             mem::transmute(slice)
  19         }
  20     }
  21 }
  22
  23 struct View<'a>(&'a mut [i32]);
  24
  25 fn main() {
  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     let mut v = vec![Int(1), Int(2)];
  67     v[0] += Int(2);
  68     assert_eq!(v[0], Int(3));
  69
  70     // unsized RHS
  71     let mut array = [0, 1, 2];
  72     *Slice::new(&mut array) += 1;
  73     assert_eq!(array[0], 1);
  74     assert_eq!(array[1], 2);
  75     assert_eq!(array[2], 3);
  76
  77     // sized indirection
  78     // check that this does *not* trigger the unused_assignments lint
  79     let mut array = [0, 1, 2];
  80     let mut view = View(&mut array);
  81     view += 1;
  82 }
  83
  84 impl AddAssign for Int {
  85     fn add_assign(&mut self, rhs: Int) {
  86         self.0 += rhs.0;
  87     }
  88 }
  89
  90 impl BitAndAssign for Int {
  91     fn bitand_assign(&mut self, rhs: Int) {
  92         self.0 &= rhs.0;
  93     }
  94 }
  95
  96 impl BitOrAssign for Int {
  97     fn bitor_assign(&mut self, rhs: Int) {
  98         self.0 |= rhs.0;
  99     }
 100 }
 101
 102 impl BitXorAssign for Int {
 103     fn bitxor_assign(&mut self, rhs: Int) {
 104         self.0 ^= rhs.0;
 105     }
 106 }
 107
 108 impl DivAssign for Int {
 109     fn div_assign(&mut self, rhs: Int) {
 110         self.0 /= rhs.0;
 111     }
 112 }
 113
 114 impl MulAssign for Int {
 115     fn mul_assign(&mut self, rhs: Int) {
 116         self.0 *= rhs.0;
 117     }
 118 }
 119
 120 impl RemAssign for Int {
 121     fn rem_assign(&mut self, rhs: Int) {
 122         self.0 %= rhs.0;
 123     }
 124 }
 125
 126 impl ShlAssign<u8> for Int {
 127     fn shl_assign(&mut self, rhs: u8) {
 128         self.0 <<= rhs;
 129     }
 130 }
 131
 132 impl ShlAssign<u16> for Int {
 133     fn shl_assign(&mut self, rhs: u16) {
 134         self.0 <<= rhs;
 135     }
 136 }
 137
 138 impl ShrAssign<u8> for Int {
 139     fn shr_assign(&mut self, rhs: u8) {
 140         self.0 >>= rhs;
 141     }
 142 }
 143
 144 impl ShrAssign<u16> for Int {
 145     fn shr_assign(&mut self, rhs: u16) {
 146         self.0 >>= rhs;
 147     }
 148 }
 149
 150 impl SubAssign for Int {
 151     fn sub_assign(&mut self, rhs: Int) {
 152         self.0 -= rhs.0;
 153     }
 154 }
 155
 156 impl AddAssign<i32> for Slice {
 157     fn add_assign(&mut self, rhs: i32) {
 158         for lhs in &mut self.0 {
 159             *lhs += rhs;
 160         }
 161     }
 162 }
 163
 164 impl<'a> AddAssign<i32> for View<'a> {
 165     fn add_assign(&mut self, rhs: i32) {
 166         for lhs in self.0.iter_mut() {
 167             *lhs += rhs;
 168         }
 169     }
 170 }