Move checked arithmetic operators into Int trait

Author: brendanzab

src/etc/vim/syntax/rust.vim

@@ -97,7 +97,7 @@ syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator
-syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul CheckedDiv
+syn keyword rustTrait Num NumCast
 syn keyword rustTrait Signed Unsigned Primitive Int Float
 syn keyword rustTrait FloatMath ToPrimitive FromPrimitive
 syn keyword rustTrait Box

src/libarena/lib.rs

@@ -132,7 +132,7 @@ impl Drop for Arena {
 
 #[inline]
 fn round_up(base: uint, align: uint) -> uint {
-    (base.checked_add(&(align - 1))).unwrap() & !(align - 1)
+    (base.checked_add(align - 1)).unwrap() & !(align - 1)
 }
 
 // Walk down a chunk, running the destructors for any objects stored
@@ -376,8 +376,8 @@ fn calculate_size<T>(capacity: uint) -> uint {
     let mut size = mem::size_of::<TypedArenaChunk<T>>();
     size = round_up(size, mem::min_align_of::<T>());
     let elem_size = mem::size_of::<T>();
-    let elems_size = elem_size.checked_mul(&capacity).unwrap();
-    size = size.checked_add(&elems_size).unwrap();
+    let elems_size = elem_size.checked_mul(capacity).unwrap();
+    size = size.checked_add(elems_size).unwrap();
     size
 }
 
@@ -432,7 +432,7 @@ impl<T> TypedArenaChunk<T> {
     #[inline]
     fn end(&self) -> *const u8 {
         unsafe {
-            let size = mem::size_of::<T>().checked_mul(&self.capacity).unwrap();
+            let size = mem::size_of::<T>().checked_mul(self.capacity).unwrap();
             self.start().offset(size as int)
         }
     }
@@ -481,7 +481,7 @@ impl<T> TypedArena<T> {
     fn grow(&self) {
         unsafe {
             let chunk = *self.first.borrow_mut();
-            let new_capacity = (*chunk).capacity.checked_mul(&2).unwrap();
+            let new_capacity = (*chunk).capacity.checked_mul(2).unwrap();
             let chunk = TypedArenaChunk::<T>::new(chunk, new_capacity);
             self.ptr.set((*chunk).start() as *const T);
             self.end.set((*chunk).end() as *const T);

src/libcollections/vec.rs

@@ -161,7 +161,7 @@ impl<T> Vec<T> {
         } else if capacity == 0 {
             Vec::new()
         } else {
-            let size = capacity.checked_mul(&mem::size_of::<T>())
+            let size = capacity.checked_mul(mem::size_of::<T>())
                                .expect("capacity overflow");
             let ptr = unsafe { allocate(size, mem::min_align_of::<T>()) };
             Vec { ptr: ptr as *mut T, len: 0, cap: capacity }
@@ -601,7 +601,7 @@ impl<T> Vec<T> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn reserve(&mut self, additional: uint) {
         if self.cap - self.len < additional {
-            match self.len.checked_add(&additional) {
+            match self.len.checked_add(additional) {
                 None => panic!("Vec::reserve: `uint` overflow"),
                 // if the checked_add
                 Some(new_cap) => {
@@ -638,7 +638,7 @@ impl<T> Vec<T> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn reserve_exact(&mut self, additional: uint) {
         if self.cap - self.len < additional {
-            match self.len.checked_add(&additional) {
+            match self.len.checked_add(additional) {
                 None => panic!("Vec::reserve: `uint` overflow"),
                 Some(new_cap) => self.grow_capacity(new_cap)
             }
@@ -971,7 +971,7 @@ impl<T> Vec<T> {
     pub fn push(&mut self, value: T) {
         if mem::size_of::<T>() == 0 {
             // zero-size types consume no memory, so we can't rely on the address space running out
-            self.len = self.len.checked_add(&1).expect("length overflow");
+            self.len = self.len.checked_add(1).expect("length overflow");
             unsafe { mem::forget(value); }
             return
         }
@@ -1064,7 +1064,7 @@ impl<T> Vec<T> {
         if mem::size_of::<T>() == 0 { return }
 
         if capacity > self.cap {
-            let size = capacity.checked_mul(&mem::size_of::<T>())
+            let size = capacity.checked_mul(mem::size_of::<T>())
                                .expect("capacity overflow");
             unsafe {
                 self.ptr = alloc_or_realloc(self.ptr, self.cap * mem::size_of::<T>(), size);

src/libcore/iter.rs

@@ -60,9 +60,9 @@ This `for` loop syntax can be applied to any iterator over any type.
 
 use clone::Clone;
 use cmp;
-use cmp::{PartialEq, PartialOrd, Ord};
+use cmp::{PartialOrd, Ord};
 use mem;
-use num::{Zero, One, CheckedAdd, CheckedSub, ToPrimitive, Int};
+use num::{Zero, One, ToPrimitive, Int};
 use ops::{Add, Mul, Sub};
 use option::{Option, Some, None};
 use uint;
@@ -1093,7 +1093,7 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> {
         let lower = a_lower.saturating_add(b_lower);
 
         let upper = match (a_upper, b_upper) {
-            (Some(x), Some(y)) => x.checked_add(&y),
+            (Some(x), Some(y)) => x.checked_add(y),
             _ => None
         };
 
@@ -1415,7 +1415,7 @@ impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> {
         if self.peeked.is_some() {
             let lo = lo.saturating_add(1);
             let hi = match hi {
-                Some(x) => x.checked_add(&1),
+                Some(x) => x.checked_add(1),
                 None => None
             };
             (lo, hi)
@@ -1680,7 +1680,7 @@ impl<'a, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for FlatMap<'a, A, T,
         let (blo, bhi) = self.backiter.as_ref().map_or((0, Some(0)), |it| it.size_hint());
         let lo = flo.saturating_add(blo);
         match (self.iter.size_hint(), fhi, bhi) {
-            ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(&b)),
+            ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(b)),
             _ => (lo, None)
         }
     }
@@ -1946,15 +1946,15 @@ impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for Range<A> {
         // the i64/u64 might lie within their range.
         let bound = match self.state.to_i64() {
             Some(a) => {
-                let sz = self.stop.to_i64().map(|b| b.checked_sub(&a));
+                let sz = self.stop.to_i64().map(|b| b.checked_sub(a));
                 match sz {
                     Some(Some(bound)) => bound.to_uint(),
                     _ => None,
                 }
             },
             None => match self.state.to_u64() {
                 Some(a) => {
-                    let sz = self.stop.to_u64().map(|b| b.checked_sub(&a));
+                    let sz = self.stop.to_u64().map(|b| b.checked_sub(a));
                     match sz {
                         Some(Some(bound)) => bound.to_uint(),
                         _ => None
@@ -2024,7 +2024,7 @@ impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for RangeInclu
         } else {
             let lo = lo.saturating_add(1);
             let hi = match hi {
-                Some(x) => x.checked_add(&1),
+                Some(x) => x.checked_add(1),
                 None => None
             };
             (lo, hi)
@@ -2060,18 +2060,17 @@ pub struct RangeStep<A> {
 
 /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
 #[inline]
-pub fn range_step<A: CheckedAdd + PartialOrd +
-                  Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> {
+pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
     let rev = step < Zero::zero();
     RangeStep{state: start, stop: stop, step: step, rev: rev}
 }
 
-impl<A: CheckedAdd + PartialOrd + Clone> Iterator<A> for RangeStep<A> {
+impl<A: Int> Iterator<A> for RangeStep<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
+            let result = self.state;
+            match self.state.checked_add(self.step) {
                 Some(x) => self.state = x,
                 None => self.state = self.stop.clone()
             }
@@ -2094,19 +2093,18 @@ pub struct RangeStepInclusive<A> {
 
 /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
 #[inline]
-pub fn range_step_inclusive<A: CheckedAdd + PartialOrd + Clone + Zero>(start: A, stop: A,
-                                                                step: A) -> RangeStepInclusive<A> {
+pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> {
     let rev = step < Zero::zero();
     RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false}
 }
 
-impl<A: CheckedAdd + PartialOrd + Clone + PartialEq> Iterator<A> for RangeStepInclusive<A> {
+impl<A: Int> Iterator<A> for RangeStepInclusive<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if !self.done && ((self.rev && self.state >= self.stop) ||
                           (!self.rev && self.state <= self.stop)) {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
+            let result = self.state;
+            match self.state.checked_add(self.step) {
                 Some(x) => self.state = x,
                 None => self.done = true
             }