#![feature(lang_items)]
#![feature(libc)]
#![feature(needs_allocator)]
-#![feature(nonzero)]
#![feature(optin_builtin_traits)]
#![feature(pattern)]
#![feature(pin)]
pub mod intrinsics;
pub mod mem;
-pub mod nonzero;
pub mod ptr;
pub mod hint;
// note: does not need to be public
mod iter_private;
+mod nonzero;
mod tuple;
mod unit;
// except according to those terms.
//! Exposes the NonZero lang item which provides optimization hints.
-#![unstable(feature = "nonzero", reason = "deprecated", issue = "49137")]
-#![rustc_deprecated(reason = "use `std::ptr::NonNull` or `std::num::NonZero*` instead",
- since = "1.26.0")]
-#![allow(deprecated)]
use ops::CoerceUnsized;
-/// Unsafe trait to indicate what types are usable with the NonZero struct
-pub unsafe trait Zeroable {
- /// Whether this value is zero
- fn is_zero(&self) -> bool;
-}
-
-macro_rules! impl_zeroable_for_pointer_types {
- ( $( $Ptr: ty )+ ) => {
- $(
- /// For fat pointers to be considered "zero", only the "data" part needs to be null.
- unsafe impl<T: ?Sized> Zeroable for $Ptr {
- #[inline]
- fn is_zero(&self) -> bool {
- (*self).is_null()
- }
- }
- )+
- }
-}
-
-macro_rules! impl_zeroable_for_integer_types {
- ( $( $Int: ty )+ ) => {
- $(
- unsafe impl Zeroable for $Int {
- #[inline]
- fn is_zero(&self) -> bool {
- *self == 0
- }
- }
- )+
- }
-}
-
-impl_zeroable_for_pointer_types! {
- *const T
- *mut T
-}
-
-impl_zeroable_for_integer_types! {
- usize u8 u16 u32 u64 u128
- isize i8 i16 i32 i64 i128
-}
-
/// A wrapper type for raw pointers and integers that will never be
/// NULL or 0 that might allow certain optimizations.
#[lang = "non_zero"]
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
-pub struct NonZero<T: Zeroable>(pub(crate) T);
-
-impl<T: Zeroable> NonZero<T> {
- /// Creates an instance of NonZero with the provided value.
- /// You must indeed ensure that the value is actually "non-zero".
- #[inline]
- pub const unsafe fn new_unchecked(inner: T) -> Self {
- NonZero(inner)
- }
-
- /// Creates an instance of NonZero with the provided value.
- #[inline]
- pub fn new(inner: T) -> Option<Self> {
- if inner.is_zero() {
- None
- } else {
- Some(NonZero(inner))
- }
- }
-
- /// Gets the inner value.
- pub fn get(self) -> T {
- self.0
- }
-}
-
-impl<T: Zeroable+CoerceUnsized<U>, U: Zeroable> CoerceUnsized<NonZero<U>> for NonZero<T> {}
-
-impl<'a, T: ?Sized> From<&'a mut T> for NonZero<*mut T> {
- fn from(reference: &'a mut T) -> Self {
- NonZero(reference)
- }
-}
-
-impl<'a, T: ?Sized> From<&'a mut T> for NonZero<*const T> {
- fn from(reference: &'a mut T) -> Self {
- let ptr: *mut T = reference;
- NonZero(ptr)
- }
-}
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub(crate) struct NonZero<T>(pub(crate) T);
-impl<'a, T: ?Sized> From<&'a T> for NonZero<*const T> {
- fn from(reference: &'a T) -> Self {
- NonZero(reference)
- }
-}
+impl<T: CoerceUnsized<U>, U> CoerceUnsized<NonZero<U>> for NonZero<T> {}
use fmt;
use intrinsics;
use mem;
-#[allow(deprecated)] use nonzero::NonZero;
+use nonzero::NonZero;
use ops;
use str::FromStr;
macro_rules! impl_nonzero_fmt {
- ( #[$stability: meta] ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
+ ( ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
$(
- #[$stability]
- #[allow(deprecated)]
+ #[stable(feature = "nonzero", since = "1.28.0")]
impl fmt::$Trait for $Ty {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
}
macro_rules! nonzero_integers {
- ( #[$stability: meta] #[$deprecation: meta] $( $Ty: ident($Int: ty); )+ ) => {
+ ( $( $Ty: ident($Int: ty); )+ ) => {
$(
/// An integer that is known not to equal zero.
///
/// use std::mem::size_of;
/// assert_eq!(size_of::<Option<std::num::NonZeroU32>>(), size_of::<u32>());
/// ```
- #[$stability]
- #[$deprecation]
- #[allow(deprecated)]
+ #[stable(feature = "nonzero", since = "1.28.0")]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct $Ty(NonZero<$Int>);
- #[allow(deprecated)]
impl $Ty {
/// Create a non-zero without checking the value.
///
/// # Safety
///
/// The value must not be zero.
- #[$stability]
+ #[stable(feature = "nonzero", since = "1.28.0")]
#[inline]
pub const unsafe fn new_unchecked(n: $Int) -> Self {
$Ty(NonZero(n))
}
/// Create a non-zero if the given value is not zero.
- #[$stability]
+ #[stable(feature = "nonzero", since = "1.28.0")]
#[inline]
pub fn new(n: $Int) -> Option<Self> {
if n != 0 {
}
/// Returns the value as a primitive type.
- #[$stability]
+ #[stable(feature = "nonzero", since = "1.28.0")]
#[inline]
pub fn get(self) -> $Int {
self.0 .0
}
impl_nonzero_fmt! {
- #[$stability]
(Debug, Display, Binary, Octal, LowerHex, UpperHex) for $Ty
}
)+
}
nonzero_integers! {
- #[unstable(feature = "nonzero", issue = "49137")]
- #[allow(deprecated)] // Redundant, works around "error: inconsistent lockstep iteration"
NonZeroU8(u8);
NonZeroU16(u16);
NonZeroU32(u32);
NonZeroUsize(usize);
}
-nonzero_integers! {
- #[unstable(feature = "nonzero", issue = "49137")]
- #[rustc_deprecated(since = "1.26.0", reason = "\
- signed non-zero integers are considered for removal due to lack of known use cases. \
- If you’re using them, please comment on https://github.com/rust-lang/rust/issues/49137")]
- NonZeroI8(i8);
- NonZeroI16(i16);
- NonZeroI32(i32);
- NonZeroI64(i64);
- NonZeroI128(i128);
- NonZeroIsize(isize);
-}
-
/// Provides intentionally-wrapped arithmetic on `T`.
///
/// Operations like `+` on `u32` values is intended to never overflow,
use hash;
use marker::{PhantomData, Unsize};
use mem;
-#[allow(deprecated)] use nonzero::NonZero;
+use nonzero::NonZero;
use cmp::Ordering::{self, Less, Equal, Greater};
#[unstable(feature = "ptr_internals", issue = "0",
reason = "use NonNull instead and consider PhantomData<T> \
(if you also use #[may_dangle]), Send, and/or Sync")]
-#[allow(deprecated)]
#[doc(hidden)]
pub struct Unique<T: ?Sized> {
pointer: NonZero<*const T>,
}
#[unstable(feature = "ptr_internals", issue = "0")]
-#[allow(deprecated)]
impl<T: ?Sized> Unique<T> {
/// Creates a new `Unique`.
///
}
#[unstable(feature = "ptr_internals", issue = "0")]
-#[allow(deprecated)]
impl<'a, T: ?Sized> From<&'a mut T> for Unique<T> {
fn from(reference: &'a mut T) -> Self {
Unique { pointer: NonZero(reference as _), _marker: PhantomData }
}
#[unstable(feature = "ptr_internals", issue = "0")]
-#[allow(deprecated)]
impl<'a, T: ?Sized> From<&'a T> for Unique<T> {
fn from(reference: &'a T) -> Self {
Unique { pointer: NonZero(reference as _), _marker: PhantomData }
/// provide a public API that follows the normal shared XOR mutable rules of Rust.
#[stable(feature = "nonnull", since = "1.25.0")]
pub struct NonNull<T: ?Sized> {
- #[allow(deprecated)] pointer: NonZero<*const T>,
+ pointer: NonZero<*const T>,
}
/// `NonNull` pointers are not `Send` because the data they reference may be aliased.
}
}
-#[allow(deprecated)]
impl<T: ?Sized> NonNull<T> {
/// Creates a new `NonNull`.
///
}
#[stable(feature = "nonnull", since = "1.25.0")]
-#[allow(deprecated)]
impl<'a, T: ?Sized> From<&'a mut T> for NonNull<T> {
fn from(reference: &'a mut T) -> Self {
NonNull { pointer: NonZero(reference as _) }
}
#[stable(feature = "nonnull", since = "1.25.0")]
-#[allow(deprecated)]
impl<'a, T: ?Sized> From<&'a T> for NonNull<T> {
fn from(reference: &'a T) -> Self {
NonNull { pointer: NonZero(reference as _) }
#![feature(iterator_step_by)]
#![feature(iterator_flatten)]
#![feature(iterator_repeat_with)]
-#![feature(nonzero)]
#![feature(pattern)]
#![feature(range_is_empty)]
#![feature(raw)]
#![feature(never_type)]
#![feature(exhaustive_patterns)]
#![feature(non_exhaustive)]
-#![feature(nonzero)]
#![feature(proc_macro_internals)]
#![feature(quote)]
#![feature(optin_builtin_traits)]
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(collections_range)]
-#![feature(nonzero)]
#![feature(unboxed_closures)]
#![feature(fn_traits)]
#![feature(unsize)]
#![feature(exhaustive_patterns)]
#![feature(range_contains)]
#![feature(rustc_diagnostic_macros)]
-#![feature(nonzero)]
#![feature(inclusive_range_methods)]
#![feature(crate_visibility_modifier)]
#![feature(never_type)]
#![feature(needs_panic_runtime)]
#![feature(never_type)]
#![feature(exhaustive_patterns)]
-#![feature(nonzero)]
#![feature(num_bits_bytes)]
#![feature(old_wrapping)]
#![feature(on_unimplemented)]
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::num::Wrapping;
-#[unstable(feature = "nonzero", issue = "49137")]
-#[allow(deprecated)]
-pub use core::num::{
- NonZeroU8, NonZeroI8, NonZeroU16, NonZeroI16, NonZeroU32, NonZeroI32,
- NonZeroU64, NonZeroI64, NonZeroU128, NonZeroI128, NonZeroUsize, NonZeroIsize,
-};
+#[stable(feature = "nonzero", since = "1.28.0")]
+pub use core::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroUsize};
#[cfg(test)] use fmt;
#[cfg(test)] use ops::{Add, Sub, Mul, Div, Rem};
// https://github.com/rust-lang/rust/issues/41898
-#![feature(nonzero, const_fn)]
-extern crate core;
-use core::nonzero::NonZero;
+use std::num::NonZeroU64;
fn main() {
- const FOO: NonZero<u64> = unsafe { NonZero::new_unchecked(2) };
+ const FOO: NonZeroU64 = unsafe { NonZeroU64::new_unchecked(2) };
if let FOO = FOO {}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(nonzero, core)]
-
use std::mem::size_of;
use std::num::NonZeroUsize;
use std::ptr::NonNull;
// padding and overall computed sizes can be quite different.
#![feature(start)]
-#![feature(nonzero)]
#![allow(dead_code)]
use std::num::NonZeroU32;
projects / rust.git / commitdiff