Restore unstable module level constants to avoid ICE #28586

Author: petrochenkov

src/libcollections/enum_set.rs

@@ -89,7 +89,6 @@ pub trait CLike {
 }
 
 fn bit<E:CLike>(e: &E) -> usize {
-    use core::usize;
     let value = e.to_usize();
     assert!(value < usize::BITS,
             "EnumSet only supports up to {} variants.", usize::BITS - 1);

src/libcollections/vec_deque.rs

@@ -25,7 +25,6 @@ use core::mem;
 use core::ops::{Index, IndexMut};
 use core::ptr;
 use core::slice;
-use core::usize;
 
 use core::hash::{Hash, Hasher};
 use core::cmp;

src/libcore/num/int_macros.rs

@@ -12,6 +12,21 @@
 
 macro_rules! int_module { ($T:ty, $bits:expr) => (
 
+// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
+// calling the `mem::size_of` function.
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function",
+           issue = "27753")]
+#[allow(missing_docs)]
+pub const BITS : usize = $bits;
+// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
+// calling the `mem::size_of` function.
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function",
+           issue = "27753")]
+#[allow(missing_docs)]
+pub const BYTES : usize = ($bits / 8);
+
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
 // calling the `Bounded::min_value` function.
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcore/num/mod.rs

@@ -115,7 +115,7 @@ unsafe fn bswap8(x: u8) -> u8 { x }
 
 // `Int` + `SignedInt` implemented for signed integers
 macro_rules! int_impl {
-    ($ActualT:ty, $UnsignedT:ty, $BITS:expr,
+    ($SelfT:ty, $ActualT:ty, $UnsignedT:ty, $BITS:expr,
      $add_with_overflow:path,
      $sub_with_overflow:path,
      $mul_with_overflow:path) => {
@@ -139,13 +139,13 @@ macro_rules! int_impl {
         // calling the `Bounded::min_value` function.
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(missing_docs)]
-        pub const MIN: $ActualT = (-1 as $ActualT) << ($BITS - 1);
+        pub const MIN: $SelfT = (-1 as $SelfT) << ($BITS - 1);
         // FIXME(#9837): Compute MIN like this so the high bits that shouldn't exist are 0.
         // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
         // calling the `Bounded::max_value` function.
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(missing_docs)]
-        pub const MAX: $ActualT = !<$ActualT>::MIN;
+        pub const MAX: $SelfT = !<$SelfT>::MIN;
 
         /// Returns the smallest value that can be represented by this integer type.
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -639,31 +639,31 @@ macro_rules! int_impl {
 
 #[lang = "i8"]
 impl i8 {
-    int_impl! { i8, u8, 8,
+    int_impl! { i8, i8, u8, 8,
         intrinsics::i8_add_with_overflow,
         intrinsics::i8_sub_with_overflow,
         intrinsics::i8_mul_with_overflow }
 }
 
 #[lang = "i16"]
 impl i16 {
-    int_impl! { i16, u16, 16,
+    int_impl! { i16, i16, u16, 16,
         intrinsics::i16_add_with_overflow,
         intrinsics::i16_sub_with_overflow,
         intrinsics::i16_mul_with_overflow }
 }
 
 #[lang = "i32"]
 impl i32 {
-    int_impl! { i32, u32, 32,
+    int_impl! { i32, i32, u32, 32,
         intrinsics::i32_add_with_overflow,
         intrinsics::i32_sub_with_overflow,
         intrinsics::i32_mul_with_overflow }
 }
 
 #[lang = "i64"]
 impl i64 {
-    int_impl! { i64, u64, 64,
+    int_impl! { i64, i64, u64, 64,
         intrinsics::i64_add_with_overflow,
         intrinsics::i64_sub_with_overflow,
         intrinsics::i64_mul_with_overflow }
@@ -672,7 +672,7 @@ impl i64 {
 #[cfg(target_pointer_width = "32")]
 #[lang = "isize"]
 impl isize {
-    int_impl! { i32, u32, 32,
+    int_impl! { isize, i32, u32, 32,
         intrinsics::i32_add_with_overflow,
         intrinsics::i32_sub_with_overflow,
         intrinsics::i32_mul_with_overflow }
@@ -681,15 +681,15 @@ impl isize {
 #[cfg(target_pointer_width = "64")]
 #[lang = "isize"]
 impl isize {
-    int_impl! { i64, u64, 64,
+    int_impl! { isize, i64, u64, 64,
         intrinsics::i64_add_with_overflow,
         intrinsics::i64_sub_with_overflow,
         intrinsics::i64_mul_with_overflow }
 }
 
 // `Int` + `UnsignedInt` implemented for signed integers
 macro_rules! uint_impl {
-    ($ActualT:ty, $BITS:expr,
+    ($SelfT:ty, $ActualT:ty, $BITS:expr,
      $ctpop:path,
      $ctlz:path,
      $cttz:path,
@@ -711,10 +711,10 @@ macro_rules! uint_impl {
 
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(missing_docs)]
-        pub const MIN: $ActualT = 0 as $ActualT;
+        pub const MIN: $SelfT = 0 as $SelfT;
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(missing_docs)]
-        pub const MAX: $ActualT = !0 as $ActualT;
+        pub const MAX: $SelfT = !0 as $SelfT;
 
         /// Returns the smallest value that can be represented by this integer type.
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -1210,7 +1210,7 @@ macro_rules! uint_impl {
 
 #[lang = "u8"]
 impl u8 {
-    uint_impl! { u8, 8,
+    uint_impl! { u8, u8, 8,
         intrinsics::ctpop8,
         intrinsics::ctlz8,
         intrinsics::cttz8,
@@ -1222,7 +1222,7 @@ impl u8 {
 
 #[lang = "u16"]
 impl u16 {
-    uint_impl! { u16, 16,
+    uint_impl! { u16, u16, 16,
         intrinsics::ctpop16,
         intrinsics::ctlz16,
         intrinsics::cttz16,
@@ -1234,7 +1234,7 @@ impl u16 {
 
 #[lang = "u32"]
 impl u32 {
-    uint_impl! { u32, 32,
+    uint_impl! { u32, u32, 32,
         intrinsics::ctpop32,
         intrinsics::ctlz32,
         intrinsics::cttz32,
@@ -1247,7 +1247,7 @@ impl u32 {
 
 #[lang = "u64"]
 impl u64 {
-    uint_impl! { u64, 64,
+    uint_impl! { u64, u64, 64,
         intrinsics::ctpop64,
         intrinsics::ctlz64,
         intrinsics::cttz64,
@@ -1260,7 +1260,7 @@ impl u64 {
 #[cfg(target_pointer_width = "32")]
 #[lang = "usize"]
 impl usize {
-    uint_impl! { u32, 32,
+    uint_impl! { usize, u32, 32,
         intrinsics::ctpop32,
         intrinsics::ctlz32,
         intrinsics::cttz32,
@@ -1273,7 +1273,7 @@ impl usize {
 #[cfg(target_pointer_width = "64")]
 #[lang = "usize"]
 impl usize {
-    uint_impl! { u64, 64,
+    uint_impl! { usize, u64, 64,
         intrinsics::ctpop64,
         intrinsics::ctlz64,
         intrinsics::cttz64,

src/libcore/num/uint_macros.rs

@@ -12,6 +12,17 @@
 
 macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
 
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function",
+           issue = "27753")]
+#[allow(missing_docs)]
+pub const BITS : usize = $bits;
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function",
+           issue = "27753")]
+#[allow(missing_docs)]
+pub const BYTES : usize = ($bits / 8);
+
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(missing_docs)]
 pub const MIN: $T = 0 as $T;

src/libcore/num/usize.rs

@@ -14,4 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-uint_module! { usize, isize, ::isize::BITS }
+uint_module! { usize, isize, isize::BITS }

src/librustc/middle/dataflow.rs

@@ -20,7 +20,6 @@ use middle::cfg;
 use middle::cfg::CFGIndex;
 use middle::ty;
 use std::io;
-use std::usize;
 use syntax::ast;
 use syntax::ast_util::IdRange;
 use syntax::print::pp;

src/librustc_lint/types.rs

@@ -19,7 +19,7 @@ use lint::{LateContext, LintContext, LintArray};
 use lint::{LintPass, LateLintPass};
 
 use std::cmp;
-use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
+use std::{f32, f64};
 
 use syntax::{abi, ast};
 use syntax::attr::{self, AttrMetaMethods};

src/libserialize/collection_impls.rs

@@ -10,7 +10,6 @@
 
 //! Implementations of serialization for structures found in libcollections
 
-use std::usize;
 use std::default::Default;
 use std::hash::Hash;
 use std::collections::hash_state::HashState;