---

yaml
---
r: 209495
b: refs/heads/try
c: 0afdab1
h: refs/heads/master
i:
  209493: 4045308
  209491: bb4e45d
  209487: 47ce95d
v: v3

Author: mvdnes

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 7fbedc58e3b0e102ece926a7f99041fc3ad3037a
+refs/heads/try: 0afdab11ec42ccf5dbe12cd37f71f30cca581f14
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/libcore/num/mod.rs

@@ -1219,66 +1219,6 @@ macro_rules! int_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `floor(self / other)`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// The only case where such wrapping can occur is when one
-        /// divides `MIN / -1` on a signed type (where `MIN` is the
-        /// negative minimal value for the type); this is equivalent
-        /// to `-MIN`, a positive value that is too large to represent
-        /// in the type. In such a case, this function returns `MIN`
-        /// itself..
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_div(self, rhs: $T) -> $T {
-            self.overflowing_div(rhs).0
-        }
-
-        /// Wrapping (modular) remainder. Computes `self % other`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// Such wrap-around never actually occurs mathematically;
-        /// implementation artifacts make `x % y` illegal for `MIN /
-        /// -1` on a signed type illegal (where `MIN` is the negative
-        /// minimal value). In such a case, this function returns `0`.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_rem(self, rhs: $T) -> $T {
-            self.overflowing_rem(rhs).0
-        }
-
-        /// Wrapping (modular) negation. Computes `-self`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// The only case where such wrapping can occur is when one
-        /// negates `MIN` on a signed type (where `MIN` is the
-        /// negative minimal value for the type); this is a positive
-        /// value that is too large to represent in the type. In such
-        /// a case, this function returns `MIN` itself.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_neg(self) -> $T {
-            self.overflowing_neg().0
-        }
-
-        /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
-        /// where `mask` removes any high-order bits of `rhs` that
-        /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_shl(self, rhs: u32) -> $T {
-            self.overflowing_shl(rhs).0
-        }
-
-        /// Panic-free bitwise shift-left; yields `self >> mask(rhs)`,
-        /// where `mask` removes any high-order bits of `rhs` that
-        /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_shr(self, rhs: u32) -> $T {
-            self.overflowing_shr(rhs).0
-        }
-
         /// Raises self to the power of `exp`, using exponentiation by squaring.
         ///
         /// # Examples
@@ -1799,66 +1739,6 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `floor(self / other)`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// The only case where such wrapping can occur is when one
-        /// divides `MIN / -1` on a signed type (where `MIN` is the
-        /// negative minimal value for the type); this is equivalent
-        /// to `-MIN`, a positive value that is too large to represent
-        /// in the type. In such a case, this function returns `MIN`
-        /// itself..
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_div(self, rhs: $T) -> $T {
-            self.overflowing_div(rhs).0
-        }
-
-        /// Wrapping (modular) remainder. Computes `self % other`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// Such wrap-around never actually occurs mathematically;
-        /// implementation artifacts make `x % y` illegal for `MIN /
-        /// -1` on a signed type illegal (where `MIN` is the negative
-        /// minimal value). In such a case, this function returns `0`.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_rem(self, rhs: $T) -> $T {
-            self.overflowing_rem(rhs).0
-        }
-
-        /// Wrapping (modular) negation. Computes `-self`,
-        /// wrapping around at the boundary of the type.
-        ///
-        /// The only case where such wrapping can occur is when one
-        /// negates `MIN` on a signed type (where `MIN` is the
-        /// negative minimal value for the type); this is a positive
-        /// value that is too large to represent in the type. In such
-        /// a case, this function returns `MIN` itself.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_neg(self) -> $T {
-            self.overflowing_neg().0
-        }
-
-        /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
-        /// where `mask` removes any high-order bits of `rhs` that
-        /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_shl(self, rhs: u32) -> $T {
-            self.overflowing_shl(rhs).0
-        }
-
-        /// Panic-free bitwise shift-left; yields `self >> mask(rhs)`,
-        /// where `mask` removes any high-order bits of `rhs` that
-        /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
-        #[inline(always)]
-        pub fn wrapping_shr(self, rhs: u32) -> $T {
-            self.overflowing_shr(rhs).0
-        }
-
         /// Raises self to the power of `exp`, using exponentiation by squaring.
         ///
         /// # Examples

branches/try/src/libcore/num/wrapping.rs

@@ -48,7 +48,6 @@ pub trait OverflowingOps {
 
     fn overflowing_div(self, rhs: Self) -> (Self, bool);
     fn overflowing_rem(self, rhs: Self) -> (Self, bool);
-    fn overflowing_neg(self) -> (Self, bool);
 
     fn overflowing_shl(self, rhs: u32) -> (Self, bool);
     fn overflowing_shr(self, rhs: u32) -> (Self, bool);
@@ -232,7 +231,7 @@ macro_rules! signed_overflowing_impl {
             #[inline(always)]
             fn overflowing_div(self, rhs: $t) -> ($t, bool) {
                 if self == $t::MIN && rhs == -1 {
-                    (self, true)
+                    (1, true)
                 } else {
                     (self/rhs, false)
                 }
@@ -256,15 +255,6 @@ macro_rules! signed_overflowing_impl {
                 (self >> (rhs & self::shift_max::$t),
                  (rhs > self::shift_max::$t))
             }
-
-            #[inline(always)]
-            fn overflowing_neg(self) -> ($t, bool) {
-                if self == $t::MIN {
-                    ($t::MIN, true)
-                } else {
-                    (-self, false)
-                }
-            }
         }
     )*)
 }
@@ -310,11 +300,6 @@ macro_rules! unsigned_overflowing_impl {
                 (self >> (rhs & self::shift_max::$t),
                  (rhs > self::shift_max::$t))
             }
-
-            #[inline(always)]
-            fn overflowing_neg(self) -> ($t, bool) {
-                ((!self).wrapping_add(1), true)
-            }
         }
     )*)
 }
@@ -356,11 +341,6 @@ impl OverflowingOps for usize {
         (r as usize, f)
     }
     #[inline(always)]
-    fn overflowing_neg(self) -> (usize, bool) {
-        let (r, f) = (self as u64).overflowing_neg();
-        (r as usize, f)
-    }
-    #[inline(always)]
     fn overflowing_shl(self, rhs: u32) -> (usize, bool) {
         let (r, f) = (self as u64).overflowing_shl(rhs);
         (r as usize, f)
@@ -406,11 +386,6 @@ impl OverflowingOps for usize {
         (r as usize, f)
     }
     #[inline(always)]
-    fn overflowing_neg(self) -> (usize, bool) {
-        let (r, f) = (self as u32).overflowing_neg();
-        (r as usize, f)
-    }
-    #[inline(always)]
     fn overflowing_shl(self, rhs: u32) -> (usize, bool) {
         let (r, f) = (self as u32).overflowing_shl(rhs);
         (r as usize, f)
@@ -456,11 +431,6 @@ impl OverflowingOps for isize {
         (r as isize, f)
     }
     #[inline(always)]
-    fn overflowing_neg(self) -> (isize, bool) {
-        let (r, f) = (self as i64).overflowing_neg();
-        (r as isize, f)
-    }
-    #[inline(always)]
     fn overflowing_shl(self, rhs: u32) -> (isize, bool) {
         let (r, f) = (self as i64).overflowing_shl(rhs);
         (r as isize, f)
@@ -506,11 +476,6 @@ impl OverflowingOps for isize {
         (r as isize, f)
     }
     #[inline(always)]
-    fn overflowing_neg(self) -> (isize, bool) {
-        let (r, f) = (self as i32).overflowing_neg();
-        (r as isize, f)
-    }
-    #[inline(always)]
     fn overflowing_shl(self, rhs: u32) -> (isize, bool) {
         let (r, f) = (self as i32).overflowing_shl(rhs);
         (r as isize, f)