Use #[non_exhaustive] when possible.

This gets rid of the `future_atomic_orderings` and `io_error_internals`
feature gates, as they are no longer needed.

Author: Clar Charr

src/doc/unstable-book/src/library-features/future-atomic-orderings.md

@@ -91,17 +91,16 @@ use str::from_boxed_utf8_unchecked;
 #[unstable(feature = "box_heap",
            reason = "may be renamed; uncertain about custom allocator design",
            issue = "27779")]
-pub const HEAP: ExchangeHeapSingleton = ExchangeHeapSingleton { _force_singleton: () };
+pub const HEAP: ExchangeHeapSingleton = ExchangeHeapSingleton { };
 
 /// This the singleton type used solely for `boxed::HEAP`.
 #[unstable(feature = "box_heap",
            reason = "may be renamed; uncertain about custom allocator design",
            issue = "27779")]
 #[allow(missing_debug_implementations)]
 #[derive(Copy, Clone)]
-pub struct ExchangeHeapSingleton {
-    _force_singleton: (),
-}
+#[non_exhaustive]
+pub struct ExchangeHeapSingleton { }
 
 /// A pointer type for heap allocation.
 ///

src/doc/unstable-book/src/library-features/io-error-internals.md

@@ -104,6 +104,7 @@
 #![feature(lang_items)]
 #![feature(needs_allocator)]
 #![feature(nonzero)]
+#![feature(non_exhaustive)]
 #![feature(offset_to)]
 #![feature(optin_builtin_traits)]
 #![feature(pattern)]

src/liballoc/boxed.rs

@@ -357,7 +357,8 @@ pub struct FromUtf8Error {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Debug)]
-pub struct FromUtf16Error(());
+#[non_exhaustive]
+pub struct FromUtf16Error { }
 
 impl String {
     /// Creates a new empty `String`.
@@ -616,7 +617,7 @@ impl String {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {
-        decode_utf16(v.iter().cloned()).collect::<Result<_, _>>().map_err(|_| FromUtf16Error(()))
+        decode_utf16(v.iter().cloned()).collect::<Result<_, _>>().map_err(|_| FromUtf16Error { })
     }
 
     /// Decode a UTF-16 encoded slice `v` into a `String`, replacing

src/liballoc/lib.rs

@@ -61,7 +61,8 @@ unsafe impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {
 /// The error type returned when a conversion from a slice to an array fails.
 #[unstable(feature = "try_from", issue = "33417")]
 #[derive(Debug, Copy, Clone)]
-pub struct TryFromSliceError(());
+#[non_exhaustive]
+pub struct TryFromSliceError { }
 
 impl fmt::Display for TryFromSliceError {
     #[inline]
@@ -157,7 +158,7 @@ macro_rules! array_impls {
                         let ptr = slice.as_ptr() as *const [T; $N];
                         unsafe { Ok(&*ptr) }
                     } else {
-                        Err(TryFromSliceError(()))
+                        Err(TryFromSliceError { })
                     }
                 }
             }
@@ -171,7 +172,7 @@ macro_rules! array_impls {
                         let ptr = slice.as_mut_ptr() as *mut [T; $N];
                         unsafe { Ok(&mut *ptr) }
                     } else {
-                        Err(TryFromSliceError(()))
+                        Err(TryFromSliceError { })
                     }
                 }
             }

src/liballoc/string.rs

@@ -488,9 +488,8 @@ pub struct RefCell<T: ?Sized> {
 
 /// An error returned by [`RefCell::try_borrow`](struct.RefCell.html#method.try_borrow).
 #[stable(feature = "try_borrow", since = "1.13.0")]
-pub struct BorrowError {
-    _private: (),
-}
+#[non_exhaustive]
+pub struct BorrowError { }
 
 #[stable(feature = "try_borrow", since = "1.13.0")]
 impl Debug for BorrowError {
@@ -508,9 +507,8 @@ impl Display for BorrowError {
 
 /// An error returned by [`RefCell::try_borrow_mut`](struct.RefCell.html#method.try_borrow_mut).
 #[stable(feature = "try_borrow", since = "1.13.0")]
-pub struct BorrowMutError {
-    _private: (),
-}
+#[non_exhaustive]
+pub struct BorrowMutError { }
 
 #[stable(feature = "try_borrow", since = "1.13.0")]
 impl Debug for BorrowMutError {
@@ -725,7 +723,7 @@ impl<T: ?Sized> RefCell<T> {
                 value: unsafe { &*self.value.get() },
                 borrow: b,
             }),
-            None => Err(BorrowError { _private: () }),
+            None => Err(BorrowError { }),
         }
     }
 
@@ -801,7 +799,7 @@ impl<T: ?Sized> RefCell<T> {
                 value: unsafe { &mut *self.value.get() },
                 borrow: b,
             }),
-            None => Err(BorrowMutError { _private: () }),
+            None => Err(BorrowMutError { }),
         }
     }
 

src/libcore/array.rs

@@ -272,7 +272,7 @@ impl TryFrom<u32> for char {
     #[inline]
     fn try_from(i: u32) -> Result<Self, Self::Error> {
         if (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) {
-            Err(CharTryFromError(()))
+            Err(CharTryFromError { })
         } else {
             Ok(unsafe { from_u32_unchecked(i) })
         }
@@ -282,7 +282,8 @@ impl TryFrom<u32> for char {
 /// The error type returned when a conversion from u32 to char fails.
 #[unstable(feature = "try_from", issue = "33417")]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct CharTryFromError(());
+#[non_exhaustive]
+pub struct CharTryFromError { }
 
 #[unstable(feature = "try_from", issue = "33417")]
 impl fmt::Display for CharTryFromError {
@@ -818,7 +819,8 @@ pub fn decode_utf8<I: IntoIterator<Item = u8>>(i: I) -> DecodeUtf8<I::IntoIter>
 /// `<DecodeUtf8 as Iterator>::next` returns this for an invalid input sequence.
 #[unstable(feature = "decode_utf8", issue = "33906")]
 #[derive(PartialEq, Eq, Debug)]
-pub struct InvalidSequence(());
+#[non_exhaustive]
+pub struct InvalidSequence { }
 
 #[unstable(feature = "decode_utf8", issue = "33906")]
 impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
@@ -849,7 +851,7 @@ impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
                             code_point = (code_point << 6) | u32::from(byte & 0b0011_1111);
                             self.0.next();
                         }
-                        _ => return Err(InvalidSequence(()))
+                        _ => return Err(InvalidSequence { })
                     }
                 }
             }
@@ -895,7 +897,7 @@ impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
                     continuation_byte!();
                     continuation_byte!();
                 }
-                _ => return Err(InvalidSequence(()))  // Illegal first byte, overlong, or beyond MAX
+                _ => return Err(InvalidSequence { })  // Illegal first byte, overlong, or beyond MAX
             }
             unsafe {
                 Ok(from_u32_unchecked(code_point))

src/libcore/cell.rs

@@ -260,7 +260,6 @@ pub struct Formatter<'a> {
 // equivalent to `exists T.(&T, fn(&T, &mut Formatter) -> Result`.
 
 struct Void {
-    _priv: (),
     /// Erases all oibits, because `Void` erases the type of the object that
     /// will be used to produce formatted output. Since we do not know what
     /// oibits the real types have (and they can have any or none), we need to

src/libcore/char.rs

@@ -80,6 +80,7 @@
 #![feature(lang_items)]
 #![feature(never_type)]
 #![feature(no_core)]
+#![feature(non_exhaustive)]
 #![feature(on_unimplemented)]
 #![feature(optin_builtin_traits)]
 #![feature(prelude_import)]

src/libcore/fmt/mod.rs

@@ -2959,7 +2959,8 @@ from_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }
 /// The error type returned when a checked integral type conversion fails.
 #[unstable(feature = "try_from", issue = "33417")]
 #[derive(Debug, Copy, Clone)]
-pub struct TryFromIntError(());
+#[non_exhaustive]
+pub struct TryFromIntError { }
 
 impl TryFromIntError {
     #[unstable(feature = "int_error_internals",
@@ -3014,7 +3015,7 @@ macro_rules! try_from_lower_bounded {
                 if u >= 0 {
                     Ok(u as $target)
                 } else {
-                    Err(TryFromIntError(()))
+                    Err(TryFromIntError { })
                 }
             }
         }
@@ -3031,7 +3032,7 @@ macro_rules! try_from_upper_bounded {
             #[inline]
             fn try_from(u: $source) -> Result<$target, TryFromIntError> {
                 if u > (<$target>::max_value() as $source) {
-                    Err(TryFromIntError(()))
+                    Err(TryFromIntError { })
                 } else {
                     Ok(u as $target)
                 }
@@ -3052,7 +3053,7 @@ macro_rules! try_from_both_bounded {
                 let min = <$target>::min_value() as $source;
                 let max = <$target>::max_value() as $source;
                 if u < min || u > max {
-                    Err(TryFromIntError(()))
+                    Err(TryFromIntError { })
                 } else {
                     Ok(u as $target)
                 }

src/libcore/lib.rs

@@ -132,7 +132,7 @@ impl FromStr for bool {
         match s {
             "true"  => Ok(true),
             "false" => Ok(false),
-            _       => Err(ParseBoolError { _priv: () }),
+            _       => Err(ParseBoolError { }),
         }
     }
 }
@@ -142,7 +142,8 @@ impl FromStr for bool {
 /// [`from_str`]: ../../std/primitive.bool.html#method.from_str
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct ParseBoolError { _priv: () }
+#[non_exhaustive]
+pub struct ParseBoolError { }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Display for ParseBoolError {

src/libcore/num/mod.rs

@@ -182,6 +182,7 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
 /// [nomicon]: ../../../nomicon/atomics.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Copy, Clone, Debug)]
+#[non_exhaustive]
 pub enum Ordering {
     /// No ordering constraints, only atomic operations.
     ///
@@ -215,10 +216,6 @@ pub enum Ordering {
     /// sequentially consistent operations in the same order.
     #[stable(feature = "rust1", since = "1.0.0")]
     SeqCst,
-    // Prevent exhaustive matching to allow for future extension
-    #[doc(hidden)]
-    #[unstable(feature = "future_atomic_orderings", issue = "0")]
-    __Nonexhaustive,
 }
 
 /// An [`AtomicBool`] initialized to `false`.
@@ -1468,7 +1465,6 @@ fn strongest_failure_ordering(order: Ordering) -> Ordering {
         SeqCst => SeqCst,
         Acquire => Acquire,
         AcqRel => Acquire,
-        __Nonexhaustive => __Nonexhaustive,
     }
 }
 
@@ -1480,7 +1476,6 @@ unsafe fn atomic_store<T>(dst: *mut T, val: T, order: Ordering) {
         SeqCst => intrinsics::atomic_store(dst, val),
         Acquire => panic!("there is no such thing as an acquire store"),
         AcqRel => panic!("there is no such thing as an acquire/release store"),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1492,7 +1487,6 @@ unsafe fn atomic_load<T>(dst: *const T, order: Ordering) -> T {
         SeqCst => intrinsics::atomic_load(dst),
         Release => panic!("there is no such thing as a release load"),
         AcqRel => panic!("there is no such thing as an acquire/release load"),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1504,7 +1498,6 @@ unsafe fn atomic_swap<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_xchg_acqrel(dst, val),
         Relaxed => intrinsics::atomic_xchg_relaxed(dst, val),
         SeqCst => intrinsics::atomic_xchg(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1517,7 +1510,6 @@ unsafe fn atomic_add<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_xadd_acqrel(dst, val),
         Relaxed => intrinsics::atomic_xadd_relaxed(dst, val),
         SeqCst => intrinsics::atomic_xadd(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1530,7 +1522,6 @@ unsafe fn atomic_sub<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_xsub_acqrel(dst, val),
         Relaxed => intrinsics::atomic_xsub_relaxed(dst, val),
         SeqCst => intrinsics::atomic_xsub(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1551,8 +1542,6 @@ unsafe fn atomic_compare_exchange<T>(dst: *mut T,
         (AcqRel, Relaxed) => intrinsics::atomic_cxchg_acqrel_failrelaxed(dst, old, new),
         (SeqCst, Relaxed) => intrinsics::atomic_cxchg_failrelaxed(dst, old, new),
         (SeqCst, Acquire) => intrinsics::atomic_cxchg_failacq(dst, old, new),
-        (__Nonexhaustive, _) => panic!("invalid memory ordering"),
-        (_, __Nonexhaustive) => panic!("invalid memory ordering"),
         (_, AcqRel) => panic!("there is no such thing as an acquire/release failure ordering"),
         (_, Release) => panic!("there is no such thing as a release failure ordering"),
         _ => panic!("a failure ordering can't be stronger than a success ordering"),
@@ -1577,8 +1566,6 @@ unsafe fn atomic_compare_exchange_weak<T>(dst: *mut T,
         (AcqRel, Relaxed) => intrinsics::atomic_cxchgweak_acqrel_failrelaxed(dst, old, new),
         (SeqCst, Relaxed) => intrinsics::atomic_cxchgweak_failrelaxed(dst, old, new),
         (SeqCst, Acquire) => intrinsics::atomic_cxchgweak_failacq(dst, old, new),
-        (__Nonexhaustive, _) => panic!("invalid memory ordering"),
-        (_, __Nonexhaustive) => panic!("invalid memory ordering"),
         (_, AcqRel) => panic!("there is no such thing as an acquire/release failure ordering"),
         (_, Release) => panic!("there is no such thing as a release failure ordering"),
         _ => panic!("a failure ordering can't be stronger than a success ordering"),
@@ -1594,7 +1581,6 @@ unsafe fn atomic_and<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_and_acqrel(dst, val),
         Relaxed => intrinsics::atomic_and_relaxed(dst, val),
         SeqCst => intrinsics::atomic_and(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1606,7 +1592,6 @@ unsafe fn atomic_or<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_or_acqrel(dst, val),
         Relaxed => intrinsics::atomic_or_relaxed(dst, val),
         SeqCst => intrinsics::atomic_or(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1618,7 +1603,6 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
         AcqRel => intrinsics::atomic_xor_acqrel(dst, val),
         Relaxed => intrinsics::atomic_xor_relaxed(dst, val),
         SeqCst => intrinsics::atomic_xor(dst, val),
-        __Nonexhaustive => panic!("invalid memory ordering"),
     }
 }
 
@@ -1708,7 +1692,6 @@ pub fn fence(order: Ordering) {
             AcqRel => intrinsics::atomic_fence_acqrel(),
             SeqCst => intrinsics::atomic_fence(),
             Relaxed => panic!("there is no such thing as a relaxed fence"),
-            __Nonexhaustive => panic!("invalid memory ordering"),
         }
     }
 }
@@ -1798,7 +1781,6 @@ pub fn compiler_fence(order: Ordering) {
             AcqRel => intrinsics::atomic_singlethreadfence_acqrel(),
             SeqCst => intrinsics::atomic_singlethreadfence(),
             Relaxed => panic!("there is no such thing as a relaxed compiler fence"),
-            __Nonexhaustive => panic!("invalid memory ordering"),
         }
     }
 }

src/libcore/str/mod.rs

@@ -15,6 +15,7 @@ use rustc_errors as rustc;
 /// An enum representing a diagnostic level.
 #[unstable(feature = "proc_macro", issue = "38356")]
 #[derive(Copy, Clone, Debug)]
+#[non_exhaustive]
 pub enum Level {
     /// An error.
     Error,
@@ -24,8 +25,6 @@ pub enum Level {
     Note,
     /// A help message.
     Help,
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
 /// A structure representing a diagnostic message and associated children
@@ -128,7 +127,6 @@ pub mod __internal {
             Level::Warning => rustc::Level::Warning,
             Level::Note => rustc::Level::Note,
             Level::Help => rustc::Level::Help,
-            Level::__Nonexhaustive => unreachable!("Level::__Nonexhaustive")
         }
     }
 }