now that some intrisics are safe, use that fact.

Centril · Centril · commit 50152d24ca09 · 2018-12-31T04:11:46.000+01:00
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
@@ -997,9 +997,12 @@ $EndFeature, "
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
             #[inline]
             pub const fn wrapping_add(self, rhs: Self) -> Self {
+                #[cfg(stage0)]
                 unsafe {
                     intrinsics::overflowing_add(self, rhs)
                 }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_add(self, rhs)
             }
         }
 
@@ -1021,9 +1024,12 @@ $EndFeature, "
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
             #[inline]
             pub const fn wrapping_sub(self, rhs: Self) -> Self {
+                #[cfg(stage0)]
                 unsafe {
                     intrinsics::overflowing_sub(self, rhs)
                 }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_sub(self, rhs)
             }
         }
 
@@ -1044,9 +1050,12 @@ $EndFeature, "
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
             #[inline]
             pub const fn wrapping_mul(self, rhs: Self) -> Self {
+                #[cfg(stage0)]
                 unsafe {
                     intrinsics::overflowing_mul(self, rhs)
                 }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_mul(self, rhs)
             }
         }
 
@@ -2311,7 +2320,10 @@ assert_eq!(n.rotate_left(", $rot, "), m);
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_rotate"))]
             #[inline]
             pub const fn rotate_left(self, n: u32) -> Self {
+                #[cfg(stage0)]
                 unsafe { intrinsics::rotate_left(self, n as $SelfT) }
+                #[cfg(not(stage0))]
+                intrinsics::rotate_left(self, n as $SelfT)
             }
         }
 
@@ -2336,7 +2348,10 @@ assert_eq!(n.rotate_right(", $rot, "), m);
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_rotate"))]
             #[inline]
             pub const fn rotate_right(self, n: u32) -> Self {
+                #[cfg(stage0)]
                 unsafe { intrinsics::rotate_right(self, n as $SelfT) }
+                #[cfg(not(stage0))]
+                intrinsics::rotate_right(self, n as $SelfT)
             }
         }
 
@@ -2885,9 +2900,12 @@ $EndFeature, "
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
             #[inline]
             pub const fn wrapping_add(self, rhs: Self) -> Self {
+                #[cfg(stage0)]
                 unsafe {
                     intrinsics::overflowing_add(self, rhs)
                 }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_add(self, rhs)
             }
         }
 
@@ -2908,9 +2926,12 @@ $EndFeature, "
             #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
             #[inline]
             pub const fn wrapping_sub(self, rhs: Self) -> Self {
+                #[cfg(stage0)]
                 unsafe {
                     intrinsics::overflowing_sub(self, rhs)
                 }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_sub(self, rhs)
             }
         }
 
@@ -2932,9 +2953,12 @@ $EndFeature, "
         #[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]
         #[inline]
         pub const fn wrapping_mul(self, rhs: Self) -> Self {
+            #[cfg(stage0)]
             unsafe {
                 intrinsics::overflowing_mul(self, rhs)
             }
+                #[cfg(not(stage0))]
+                intrinsics::overflowing_mul(self, rhs)
         }
 
         doc_comment! {

Original file line number	Diff line number	Diff line change
`@@ -997,9 +997,12 @@ $EndFeature, "`
`997`	`997`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`998`	`998`	`#[inline]`
`999`	`999`	`pub const fn wrapping_add(self, rhs: Self) -> Self {`
	`1000`	`+ #[cfg(stage0)]`
`1000`	`1001`	`unsafe {`
`1001`	`1002`	`intrinsics::overflowing_add(self, rhs)`
`1002`	`1003`	`}`
	`1004`	`+ #[cfg(not(stage0))]`
	`1005`	`+ intrinsics::overflowing_add(self, rhs)`
`1003`	`1006`	`}`
`1004`	`1007`	`}`
`1005`	`1008`
`@@ -1021,9 +1024,12 @@ $EndFeature, "`
`1021`	`1024`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`1022`	`1025`	`#[inline]`
`1023`	`1026`	`pub const fn wrapping_sub(self, rhs: Self) -> Self {`
	`1027`	`+ #[cfg(stage0)]`
`1024`	`1028`	`unsafe {`
`1025`	`1029`	`intrinsics::overflowing_sub(self, rhs)`
`1026`	`1030`	`}`
	`1031`	`+ #[cfg(not(stage0))]`
	`1032`	`+ intrinsics::overflowing_sub(self, rhs)`
`1027`	`1033`	`}`
`1028`	`1034`	`}`
`1029`	`1035`
`@@ -1044,9 +1050,12 @@ $EndFeature, "`
`1044`	`1050`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`1045`	`1051`	`#[inline]`
`1046`	`1052`	`pub const fn wrapping_mul(self, rhs: Self) -> Self {`
	`1053`	`+ #[cfg(stage0)]`
`1047`	`1054`	`unsafe {`
`1048`	`1055`	`intrinsics::overflowing_mul(self, rhs)`
`1049`	`1056`	`}`
	`1057`	`+ #[cfg(not(stage0))]`
	`1058`	`+ intrinsics::overflowing_mul(self, rhs)`
`1050`	`1059`	`}`
`1051`	`1060`	`}`
`1052`	`1061`
`@@ -2311,7 +2320,10 @@ assert_eq!(n.rotate_left(", $rot, "), m);`
`2311`	`2320`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_rotate"))]`
`2312`	`2321`	`#[inline]`
`2313`	`2322`	`pub const fn rotate_left(self, n: u32) -> Self {`
	`2323`	`+ #[cfg(stage0)]`
`2314`	`2324`	`unsafe { intrinsics::rotate_left(self, n as $SelfT) }`
	`2325`	`+ #[cfg(not(stage0))]`
	`2326`	`+ intrinsics::rotate_left(self, n as $SelfT)`
`2315`	`2327`	`}`
`2316`	`2328`	`}`
`2317`	`2329`
`@@ -2336,7 +2348,10 @@ assert_eq!(n.rotate_right(", $rot, "), m);`
`2336`	`2348`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_rotate"))]`
`2337`	`2349`	`#[inline]`
`2338`	`2350`	`pub const fn rotate_right(self, n: u32) -> Self {`
	`2351`	`+ #[cfg(stage0)]`
`2339`	`2352`	`unsafe { intrinsics::rotate_right(self, n as $SelfT) }`
	`2353`	`+ #[cfg(not(stage0))]`
	`2354`	`+ intrinsics::rotate_right(self, n as $SelfT)`
`2340`	`2355`	`}`
`2341`	`2356`	`}`
`2342`	`2357`
`@@ -2885,9 +2900,12 @@ $EndFeature, "`
`2885`	`2900`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`2886`	`2901`	`#[inline]`
`2887`	`2902`	`pub const fn wrapping_add(self, rhs: Self) -> Self {`
	`2903`	`+ #[cfg(stage0)]`
`2888`	`2904`	`unsafe {`
`2889`	`2905`	`intrinsics::overflowing_add(self, rhs)`
`2890`	`2906`	`}`
	`2907`	`+ #[cfg(not(stage0))]`
	`2908`	`+ intrinsics::overflowing_add(self, rhs)`
`2891`	`2909`	`}`
`2892`	`2910`	`}`
`2893`	`2911`
`@@ -2908,9 +2926,12 @@ $EndFeature, "`
`2908`	`2926`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`2909`	`2927`	`#[inline]`
`2910`	`2928`	`pub const fn wrapping_sub(self, rhs: Self) -> Self {`
	`2929`	`+ #[cfg(stage0)]`
`2911`	`2930`	`unsafe {`
`2912`	`2931`	`intrinsics::overflowing_sub(self, rhs)`
`2913`	`2932`	`}`
	`2933`	`+ #[cfg(not(stage0))]`
	`2934`	`+ intrinsics::overflowing_sub(self, rhs)`
`2914`	`2935`	`}`
`2915`	`2936`	`}`
`2916`	`2937`
`@@ -2932,9 +2953,12 @@ $EndFeature, "`
`2932`	`2953`	`#[cfg_attr(stage0, rustc_const_unstable(feature = "const_int_wrapping"))]`
`2933`	`2954`	`#[inline]`
`2934`	`2955`	`pub const fn wrapping_mul(self, rhs: Self) -> Self {`
	`2956`	`+ #[cfg(stage0)]`
`2935`	`2957`	`unsafe {`
`2936`	`2958`	`intrinsics::overflowing_mul(self, rhs)`
`2937`	`2959`	`}`
	`2960`	`+ #[cfg(not(stage0))]`
	`2961`	`+ intrinsics::overflowing_mul(self, rhs)`
`2938`	`2962`	`}`
`2939`	`2963`
`2940`	`2964`	`doc_comment! {`