Add const to nonzero get method

Author: JamesHinshelwood

src/libcore/num/mod.rs

@@ -86,8 +86,9 @@ assert_eq!(size_of::<Option<std::num::", stringify!($Ty), ">>(), size_of::<", st
 
                 /// Returns the value as a primitive type.
                 #[stable(feature = "nonzero", since = "1.28.0")]
+                #[rustc_const_unstable(feature = "const_nonzero_methods")]
                 #[inline]
-                pub fn get(self) -> $Int {
+                pub const fn get(self) -> $Int {
                     self.0 .0
                 }
 

src/librustc/hir/def_id.rs

@@ -48,7 +48,7 @@ impl ::std::fmt::Debug for CrateNum {
 
 /// Item definitions in the currently-compiled crate would have the CrateNum
 /// LOCAL_CRATE in their DefId.
-pub const LOCAL_CRATE: CrateNum = CrateNum::Index(CrateId::from_u32_const(0));
+pub const LOCAL_CRATE: CrateNum = CrateNum::Index(CrateId::from_u32(0));
 
 
 impl Idx for CrateNum {

src/librustc/lib.rs

@@ -70,6 +70,8 @@
 #![feature(macro_at_most_once_rep)]
 #![feature(crate_visibility_modifier)]
 #![feature(transpose_result)]
+#![feature(const_fn)]
+#![feature(const_nonzero_methods)]
 
 #![recursion_limit="512"]
 

src/librustc/ty/sty.rs

@@ -1325,7 +1325,7 @@ impl DebruijnIndex {
     ///
     /// you would need to shift the index for `'a` into 1 new binder.
     #[must_use]
-    pub fn shifted_in(self, amount: u32) -> DebruijnIndex {
+    pub const fn shifted_in(self, amount: u32) -> DebruijnIndex {
         DebruijnIndex::from_u32(self.as_u32() + amount)
     }
 
@@ -1338,7 +1338,7 @@ impl DebruijnIndex {
     /// Returns the resulting index when this value is moved out from
     /// `amount` number of new binders.
     #[must_use]
-    pub fn shifted_out(self, amount: u32) -> DebruijnIndex {
+    pub const fn shifted_out(self, amount: u32) -> DebruijnIndex {
         DebruijnIndex::from_u32(self.as_u32() - amount)
     }
 

src/librustc_data_structures/indexed_vec.rs

@@ -101,13 +101,13 @@ macro_rules! newtype_index {
         #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, $($derives),*)]
         #[rustc_layout_scalar_valid_range_end($max)]
         $v struct $type {
-            private: u32
+            private: ::std::num::NonZeroU32
         }
 
         impl $type {
             $v const MAX_AS_U32: u32 = $max;
 
-            $v const MAX: $type = $type::from_u32_const($max);
+            $v const MAX: $type = $type::from_u32($max);
 
             #[inline]
             $v fn from_usize(value: usize) -> Self {
@@ -118,18 +118,7 @@ macro_rules! newtype_index {
             }
 
             #[inline]
-            $v fn from_u32(value: u32) -> Self {
-                assert!(value <= $max);
-                unsafe {
-                    $type::from_u32_unchecked(value)
-                }
-            }
-
-            /// Hacky variant of `from_u32` for use in constants.
-            /// This version checks the "max" constraint by using an
-            /// invalid array dereference.
-            #[inline]
-            $v const fn from_u32_const(value: u32) -> Self {
+            $v const fn from_u32(value: u32) -> Self {
                 // This will fail at const eval time unless `value <=
                 // max` is true (in which case we get the index 0).
                 // It will also fail at runtime, of course, but in a
@@ -139,13 +128,13 @@ macro_rules! newtype_index {
                 ];
 
                 unsafe {
-                    $type { private: value }
+                    $type::from_u32_unchecked(value)
                 }
             }
 
             #[inline]
             $v const unsafe fn from_u32_unchecked(value: u32) -> Self {
-                $type { private: value }
+                $type { private: ::std::num::NonZeroU32::new_unchecked(value + 1) }
             }
 
             /// Extract value of this index as an integer.
@@ -156,8 +145,8 @@ macro_rules! newtype_index {
 
             /// Extract value of this index as a usize.
             #[inline]
-            $v fn as_u32(self) -> u32 {
-                self.private
+            $v const fn as_u32(self) -> u32 {
+                self.private.get() - 1
             }
 
             /// Extract value of this index as a u32.
@@ -445,7 +434,7 @@ macro_rules! newtype_index {
                    const $name:ident = $constant:expr,
                    $($tokens:tt)*) => (
         $(#[doc = $doc])*
-        pub const $name: $type = $type::from_u32_const($constant);
+        pub const $name: $type = $type::from_u32($constant);
         newtype_index!(
             @derives      [$($derives,)*]
             @type         [$type]

src/librustc_data_structures/lib.rs

@@ -29,6 +29,7 @@
 #![feature(nll)]
 #![feature(allow_internal_unstable)]
 #![feature(vec_resize_with)]
+#![feature(const_nonzero_methods)]
 
 #![cfg_attr(unix, feature(libc))]
 #![cfg_attr(test, feature(test))]

src/librustc_driver/test.rs

@@ -199,13 +199,8 @@ fn test_env_with_pool<F>(
     );
 }
 
-fn d1() -> ty::DebruijnIndex {
-    ty::INNERMOST
-}
-
-fn d2() -> ty::DebruijnIndex {
-    d1().shifted_in(1)
-}
+const D1: ty::DebruijnIndex = ty::INNERMOST;
+const D2: ty::DebruijnIndex = D1.shifted_in(1);
 
 impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> {
     pub fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {
@@ -385,7 +380,7 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> {
     }
 
     pub fn t_rptr_late_bound(&self, id: u32) -> Ty<'tcx> {
-        let r = self.re_late_bound_with_debruijn(id, d1());
+        let r = self.re_late_bound_with_debruijn(id, D1);
         self.infcx.tcx.mk_imm_ref(r, self.tcx().types.isize)
     }
 
@@ -559,7 +554,7 @@ fn subst_ty_renumber_bound() {
 
         // t_expected = fn(&'a isize)
         let t_expected = {
-            let t_ptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, d2());
+            let t_ptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, D2);
             env.t_fn(&[t_ptr_bound2], env.t_nil())
         };
 
@@ -595,7 +590,7 @@ fn subst_ty_renumber_some_bounds() {
         //
         // but not that the Debruijn index is different in the different cases.
         let t_expected = {
-            let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, d2());
+            let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, D2);
             env.t_pair(t_rptr_bound1, env.t_fn(&[t_rptr_bound2], env.t_nil()))
         };
 
@@ -621,11 +616,11 @@ fn escaping() {
         let t_rptr_free1 = env.t_rptr_free(1);
         assert!(!t_rptr_free1.has_escaping_bound_vars());
 
-        let t_rptr_bound1 = env.t_rptr_late_bound_with_debruijn(1, d1());
-        assert!(t_rptr_bound1.has_escaping_bound_vars());
+        let t_rptr_bound1 = env.t_rptr_late_bound_with_debruijn(1, D1);
+        assert!(t_rptr_bound1.has_escaping_regions());
 
-        let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, d2());
-        assert!(t_rptr_bound2.has_escaping_bound_vars());
+        let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, D2);
+        assert!(t_rptr_bound2.has_escaping_regions());
 
         // t_fn = fn(A)
         let t_param = env.t_param(0);
@@ -640,7 +635,7 @@ fn escaping() {
 #[test]
 fn subst_region_renumber_region() {
     test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
-        let re_bound1 = env.re_late_bound_with_debruijn(1, d1());
+        let re_bound1 = env.re_late_bound_with_debruijn(1, D1);
 
         // type t_source<'a> = fn(&'a isize)
         let t_source = {
@@ -655,7 +650,7 @@ fn subst_region_renumber_region() {
         //
         // but not that the Debruijn index is different in the different cases.
         let t_expected = {
-            let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, d2());
+            let t_rptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, D2);
             env.t_fn(&[t_rptr_bound2], env.t_nil())
         };
 

src/librustc_mir/lib.rs

@@ -38,6 +38,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
 #![feature(try_from)]
 #![feature(reverse_bits)]
 #![feature(underscore_imports)]
+#![feature(const_nonzero_methods)]
 
 #![recursion_limit="256"]
 

src/test/ui/consts/const-nonzero.rs

@@ -0,0 +1,11 @@
+// compile-pass
+
+#![feature(const_nonzero_methods)]
+
+use std::num::NonZeroU8;
+
+const X: NonZeroU8 = unsafe { NonZeroU8::new_unchecked(5) };
+const Y: u8 = X.get();
+
+fn main() {
+}