bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #115477 - kellerkindt:stabilized_int_impl, r=dtolnay

Browse source 
Stabilize the `Saturating` type

Closes #87920
Closes #92354

Stabilization report https://github.com/rust-lang/rust/issues/87920#issuecomment-1652346124
FCP https://github.com/rust-lang/rust/issues/87920#issuecomment-1676438885
This commit is contained in:
Dylan DPC 2023-09-17 11:23:24 +00:00 • committed by GitHub
commit 6011fd4655
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 220 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

1
library/alloc/src/lib.rs
View file

@ -144,7 +144,6 @@
#![feature(ptr_metadata)] #![feature(ptr_metadata)]
#![feature(ptr_sub_ptr)] #![feature(ptr_sub_ptr)]
#![feature(receiver_trait)] #![feature(receiver_trait)]
#![feature(saturating_int_impl)]
#![feature(set_ptr_value)] #![feature(set_ptr_value)]
#![feature(sized_type_properties)] #![feature(sized_type_properties)]
#![feature(slice_from_ptr_range)] #![feature(slice_from_ptr_range)]

3
library/core/src/num/mod.rs
View file

@ -44,11 +44,10 @@ mod uint_macros; // import uint_impl!
mod error; mod error;
mod int_log10; mod int_log10;
mod nonzero; mod nonzero;
#[unstable(feature = "saturating_int_impl", issue = "87920")]
mod saturating; mod saturating;
mod wrapping; mod wrapping;
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub use saturating::Saturating; pub use saturating::Saturating;
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub use wrapping::Wrapping; pub use wrapping::Wrapping;

437
library/core/src/num/saturating.rs
View file

@ -4,7 +4,7 @@ use crate::fmt;
use crate::ops::{Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign}; use crate::ops::{Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign};
use crate::ops::{BitXor, BitXorAssign, Div, DivAssign}; use crate::ops::{BitXor, BitXorAssign, Div, DivAssign};
use crate::ops::{Mul, MulAssign, Neg, Not, Rem, RemAssign}; use crate::ops::{Mul, MulAssign, Neg, Not, Rem, RemAssign};
use crate::ops::{Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign}; use crate::ops::{Sub, SubAssign};
/// Provides intentionally-saturating arithmetic on `T`. /// Provides intentionally-saturating arithmetic on `T`.
/// ///
@ -24,7 +24,6 @@ use crate::ops::{Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign};
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// let max = Saturating(u32::MAX); /// let max = Saturating(u32::MAX);
@ -32,181 +31,186 @@ use crate::ops::{Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign};
/// ///
/// assert_eq!(u32::MAX, (max + one).0); /// assert_eq!(u32::MAX, (max + one).0);
/// ``` /// ```
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)] #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]
#[repr(transparent)] #[repr(transparent)]
#[rustc_diagnostic_item = "Saturating"] #[rustc_diagnostic_item = "Saturating"]
pub struct Saturating<T>(#[unstable(feature = "saturating_int_impl", issue = "87920")] pub T); pub struct Saturating<T>(
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] pub T,
);
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::Debug> fmt::Debug for Saturating<T> { impl<T: fmt::Debug> fmt::Debug for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::Display> fmt::Display for Saturating<T> { impl<T: fmt::Display> fmt::Display for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::Binary> fmt::Binary for Saturating<T> { impl<T: fmt::Binary> fmt::Binary for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::Octal> fmt::Octal for Saturating<T> { impl<T: fmt::Octal> fmt::Octal for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::LowerHex> fmt::LowerHex for Saturating<T> { impl<T: fmt::LowerHex> fmt::LowerHex for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl<T: fmt::UpperHex> fmt::UpperHex for Saturating<T> { impl<T: fmt::UpperHex> fmt::UpperHex for Saturating<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f) self.0.fmt(f)
} }
} }
#[allow(unused_macros)]
macro_rules! sh_impl_signed {
($t:ident, $f:ident) => {
// FIXME what is the correct implementation here? see discussion https://github.com/rust-lang/rust/pull/87921#discussion_r695870065
//
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
// impl Shl<$f> for Saturating<$t> {
// type Output = Saturating<$t>;
//
// #[inline]
// fn shl(self, other: $f) -> Saturating<$t> {
// if other < 0 {
// Saturating(self.0.shr((-other & self::shift_max::$t as $f) as u32))
// } else {
// Saturating(self.0.shl((other & self::shift_max::$t as $f) as u32))
// }
// }
// }
// forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f,
// #[unstable(feature = "saturating_int_impl", issue = "87920")] }
//
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
// impl ShlAssign<$f> for Saturating<$t> {
// #[inline]
// fn shl_assign(&mut self, other: $f) {
// *self = *self << other;
// }
// }
// forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f }
#[unstable(feature = "saturating_int_impl", issue = "87920")] // FIXME the correct implementation is not clear. Waiting for a real world use case at https://github.com/rust-lang/libs-team/issues/230
impl Shr<$f> for Saturating<$t> { //
type Output = Saturating<$t>; // #[allow(unused_macros)]
// macro_rules! sh_impl_signed {
#[inline] // ($t:ident, $f:ident) => {
fn shr(self, other: $f) -> Saturating<$t> { // // FIXME what is the correct implementation here? see discussion https://github.com/rust-lang/rust/pull/87921#discussion_r695870065
if other < 0 { // //
Saturating(self.0.shl((-other & self::shift_max::$t as $f) as u32)) // // #[unstable(feature = "saturating_int_impl", issue = "87920")]
} else { // // impl Shl<$f> for Saturating<$t> {
Saturating(self.0.shr((other & self::shift_max::$t as $f) as u32)) // // type Output = Saturating<$t>;
} // //
} // // #[inline]
} // // fn shl(self, other: $f) -> Saturating<$t> {
forward_ref_binop! { impl Shr, shr for Saturating<$t>, $f, // // if other < 0 {
#[unstable(feature = "saturating_int_impl", issue = "87920")] } // // Saturating(self.0.shr((-other & self::shift_max::$t as $f) as u32))
// // } else {
#[unstable(feature = "saturating_int_impl", issue = "87920")] // // Saturating(self.0.shl((other & self::shift_max::$t as $f) as u32))
impl ShrAssign<$f> for Saturating<$t> { // // }
#[inline] // // }
fn shr_assign(&mut self, other: $f) { // // }
*self = *self >> other; // // forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f,
} // // #[unstable(feature = "saturating_int_impl", issue = "87920")] }
} // //
forward_ref_op_assign! { impl ShrAssign, shr_assign for Saturating<$t>, $f } // // #[unstable(feature = "saturating_int_impl", issue = "87920")]
}; // // impl ShlAssign<$f> for Saturating<$t> {
} // // #[inline]
// // fn shl_assign(&mut self, other: $f) {
macro_rules! sh_impl_unsigned { // // *self = *self << other;
($t:ident, $f:ident) => { // // }
#[unstable(feature = "saturating_int_impl", issue = "87920")] // // }
impl Shl<$f> for Saturating<$t> { // // forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f }
type Output = Saturating<$t>; //
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
#[inline] // impl Shr<$f> for Saturating<$t> {
fn shl(self, other: $f) -> Saturating<$t> { // type Output = Saturating<$t>;
Saturating(self.0.wrapping_shl(other as u32)) //
} // #[inline]
} // fn shr(self, other: $f) -> Saturating<$t> {
forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f, // if other < 0 {
#[unstable(feature = "saturating_int_impl", issue = "87920")] } // Saturating(self.0.shl((-other & self::shift_max::$t as $f) as u32))
// } else {
#[unstable(feature = "saturating_int_impl", issue = "87920")] // Saturating(self.0.shr((other & self::shift_max::$t as $f) as u32))
impl ShlAssign<$f> for Saturating<$t> { // }
#[inline] // }
fn shl_assign(&mut self, other: $f) { // }
*self = *self << other; // forward_ref_binop! { impl Shr, shr for Saturating<$t>, $f,
} // #[unstable(feature = "saturating_int_impl", issue = "87920")] }
} //
forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f } // #[unstable(feature = "saturating_int_impl", issue = "87920")]
// impl ShrAssign<$f> for Saturating<$t> {
#[unstable(feature = "saturating_int_impl", issue = "87920")] // #[inline]
impl Shr<$f> for Saturating<$t> { // fn shr_assign(&mut self, other: $f) {
type Output = Saturating<$t>; // *self = *self >> other;
// }
#[inline] // }
fn shr(self, other: $f) -> Saturating<$t> { // forward_ref_op_assign! { impl ShrAssign, shr_assign for Saturating<$t>, $f }
Saturating(self.0.wrapping_shr(other as u32)) // };
} // }
} //
forward_ref_binop! { impl Shr, shr for Saturating<$t>, $f, // macro_rules! sh_impl_unsigned {
#[unstable(feature = "saturating_int_impl", issue = "87920")] } // ($t:ident, $f:ident) => {
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
#[unstable(feature = "saturating_int_impl", issue = "87920")] // impl Shl<$f> for Saturating<$t> {
impl ShrAssign<$f> for Saturating<$t> { // type Output = Saturating<$t>;
#[inline] //
fn shr_assign(&mut self, other: $f) { // #[inline]
*self = *self >> other; // fn shl(self, other: $f) -> Saturating<$t> {
} // Saturating(self.0.wrapping_shl(other as u32))
} // }
forward_ref_op_assign! { impl ShrAssign, shr_assign for Saturating<$t>, $f } // }
}; // forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f,
} // #[unstable(feature = "saturating_int_impl", issue = "87920")] }
//
// FIXME (#23545): uncomment the remaining impls // #[unstable(feature = "saturating_int_impl", issue = "87920")]
macro_rules! sh_impl_all { // impl ShlAssign<$f> for Saturating<$t> {
($($t:ident)*) => ($( // #[inline]
//sh_impl_unsigned! { $t, u8 } // fn shl_assign(&mut self, other: $f) {
//sh_impl_unsigned! { $t, u16 } // *self = *self << other;
//sh_impl_unsigned! { $t, u32 } // }
//sh_impl_unsigned! { $t, u64 } // }
//sh_impl_unsigned! { $t, u128 } // forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f }
sh_impl_unsigned! { $t, usize } //
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
//sh_impl_signed! { $t, i8 } // impl Shr<$f> for Saturating<$t> {
//sh_impl_signed! { $t, i16 } // type Output = Saturating<$t>;
//sh_impl_signed! { $t, i32 } //
//sh_impl_signed! { $t, i64 } // #[inline]
//sh_impl_signed! { $t, i128 } // fn shr(self, other: $f) -> Saturating<$t> {
//sh_impl_signed! { $t, isize } // Saturating(self.0.wrapping_shr(other as u32))
)*) // }
} // }
// forward_ref_binop! { impl Shr, shr for Saturating<$t>, $f,
sh_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize } // #[unstable(feature = "saturating_int_impl", issue = "87920")] }
//
// #[unstable(feature = "saturating_int_impl", issue = "87920")]
// impl ShrAssign<$f> for Saturating<$t> {
// #[inline]
// fn shr_assign(&mut self, other: $f) {
// *self = *self >> other;
// }
// }
// forward_ref_op_assign! { impl ShrAssign, shr_assign for Saturating<$t>, $f }
// };
// }
//
// // FIXME (#23545): uncomment the remaining impls
// macro_rules! sh_impl_all {
// ($($t:ident)*) => ($(
// //sh_impl_unsigned! { $t, u8 }
// //sh_impl_unsigned! { $t, u16 }
// //sh_impl_unsigned! { $t, u32 }
// //sh_impl_unsigned! { $t, u64 }
// //sh_impl_unsigned! { $t, u128 }
// sh_impl_unsigned! { $t, usize }
//
// //sh_impl_signed! { $t, i8 }
// //sh_impl_signed! { $t, i16 }
// //sh_impl_signed! { $t, i32 }
// //sh_impl_signed! { $t, i64 }
// //sh_impl_signed! { $t, i128 }
// //sh_impl_signed! { $t, isize }
// )*)
// }
//
// sh_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
// FIXME(30524): impl Op<T> for Saturating<T>, impl OpAssign<T> for Saturating<T> // FIXME(30524): impl Op<T> for Saturating<T>, impl OpAssign<T> for Saturating<T>
macro_rules! saturating_impl { macro_rules! saturating_impl {
($($t:ty)*) => ($( ($($t:ty)*) => ($(
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Add for Saturating<$t> { impl Add for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -216,9 +220,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl Add, add for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl Add, add for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl AddAssign for Saturating<$t> { impl AddAssign for Saturating<$t> {
#[inline] #[inline]
fn add_assign(&mut self, other: Saturating<$t>) { fn add_assign(&mut self, other: Saturating<$t>) {
@ -227,7 +231,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl AddAssign, add_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl AddAssign, add_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl AddAssign<$t> for Saturating<$t> { impl AddAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn add_assign(&mut self, other: $t) { fn add_assign(&mut self, other: $t) {
@ -236,7 +240,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl AddAssign, add_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl AddAssign, add_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Sub for Saturating<$t> { impl Sub for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -246,9 +250,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl Sub, sub for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl Sub, sub for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl SubAssign for Saturating<$t> { impl SubAssign for Saturating<$t> {
#[inline] #[inline]
fn sub_assign(&mut self, other: Saturating<$t>) { fn sub_assign(&mut self, other: Saturating<$t>) {
@ -257,7 +261,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl SubAssign, sub_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl SubAssign, sub_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl SubAssign<$t> for Saturating<$t> { impl SubAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn sub_assign(&mut self, other: $t) { fn sub_assign(&mut self, other: $t) {
@ -266,7 +270,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl SubAssign, sub_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl SubAssign, sub_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Mul for Saturating<$t> { impl Mul for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -276,9 +280,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl Mul, mul for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl Mul, mul for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl MulAssign for Saturating<$t> { impl MulAssign for Saturating<$t> {
#[inline] #[inline]
fn mul_assign(&mut self, other: Saturating<$t>) { fn mul_assign(&mut self, other: Saturating<$t>) {
@ -287,7 +291,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl MulAssign, mul_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl MulAssign, mul_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl MulAssign<$t> for Saturating<$t> { impl MulAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn mul_assign(&mut self, other: $t) { fn mul_assign(&mut self, other: $t) {
@ -301,7 +305,6 @@ macro_rules! saturating_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(Saturating(2", stringify!($t), "), Saturating(5", stringify!($t), ") / Saturating(2));")] #[doc = concat!("assert_eq!(Saturating(2", stringify!($t), "), Saturating(5", stringify!($t), ") / Saturating(2));")]
@ -310,12 +313,11 @@ macro_rules! saturating_impl {
/// ``` /// ```
/// ///
/// ```should_panic /// ```should_panic
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let _ = Saturating(0", stringify!($t), ") / Saturating(0);")] #[doc = concat!("let _ = Saturating(0", stringify!($t), ") / Saturating(0);")]
/// ``` /// ```
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Div for Saturating<$t> { impl Div for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -325,10 +327,10 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl Div, div for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl Div, div for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl DivAssign for Saturating<$t> { impl DivAssign for Saturating<$t> {
#[inline] #[inline]
fn div_assign(&mut self, other: Saturating<$t>) { fn div_assign(&mut self, other: Saturating<$t>) {
@ -337,7 +339,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl DivAssign, div_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl DivAssign, div_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl DivAssign<$t> for Saturating<$t> { impl DivAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn div_assign(&mut self, other: $t) { fn div_assign(&mut self, other: $t) {
@ -346,7 +348,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl DivAssign, div_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl DivAssign, div_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Rem for Saturating<$t> { impl Rem for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -356,9 +358,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl Rem, rem for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl Rem, rem for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl RemAssign for Saturating<$t> { impl RemAssign for Saturating<$t> {
#[inline] #[inline]
fn rem_assign(&mut self, other: Saturating<$t>) { fn rem_assign(&mut self, other: Saturating<$t>) {
@ -367,7 +369,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl RemAssign, rem_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl RemAssign, rem_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl RemAssign<$t> for Saturating<$t> { impl RemAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn rem_assign(&mut self, other: $t) { fn rem_assign(&mut self, other: $t) {
@ -376,7 +378,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl RemAssign, rem_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl RemAssign, rem_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Not for Saturating<$t> { impl Not for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -386,9 +388,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_unop! { impl Not, not for Saturating<$t>, forward_ref_unop! { impl Not, not for Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitXor for Saturating<$t> { impl BitXor for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -398,9 +400,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl BitXor, bitxor for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl BitXor, bitxor for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitXorAssign for Saturating<$t> { impl BitXorAssign for Saturating<$t> {
#[inline] #[inline]
fn bitxor_assign(&mut self, other: Saturating<$t>) { fn bitxor_assign(&mut self, other: Saturating<$t>) {
@ -409,7 +411,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl BitXorAssign, bitxor_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl BitXorAssign, bitxor_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitXorAssign<$t> for Saturating<$t> { impl BitXorAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn bitxor_assign(&mut self, other: $t) { fn bitxor_assign(&mut self, other: $t) {
@ -418,7 +420,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl BitXorAssign, bitxor_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl BitXorAssign, bitxor_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitOr for Saturating<$t> { impl BitOr for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -428,9 +430,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl BitOr, bitor for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl BitOr, bitor for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitOrAssign for Saturating<$t> { impl BitOrAssign for Saturating<$t> {
#[inline] #[inline]
fn bitor_assign(&mut self, other: Saturating<$t>) { fn bitor_assign(&mut self, other: Saturating<$t>) {
@ -439,7 +441,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl BitOrAssign, bitor_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl BitOrAssign, bitor_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitOrAssign<$t> for Saturating<$t> { impl BitOrAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn bitor_assign(&mut self, other: $t) { fn bitor_assign(&mut self, other: $t) {
@ -448,7 +450,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl BitOrAssign, bitor_assign for Saturating<$t>, $t } forward_ref_op_assign! { impl BitOrAssign, bitor_assign for Saturating<$t>, $t }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitAnd for Saturating<$t> { impl BitAnd for Saturating<$t> {
type Output = Saturating<$t>; type Output = Saturating<$t>;
@ -458,9 +460,9 @@ macro_rules! saturating_impl {
} }
} }
forward_ref_binop! { impl BitAnd, bitand for Saturating<$t>, Saturating<$t>, forward_ref_binop! { impl BitAnd, bitand for Saturating<$t>, Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitAndAssign for Saturating<$t> { impl BitAndAssign for Saturating<$t> {
#[inline] #[inline]
fn bitand_assign(&mut self, other: Saturating<$t>) { fn bitand_assign(&mut self, other: Saturating<$t>) {
@ -469,7 +471,7 @@ macro_rules! saturating_impl {
} }
forward_ref_op_assign! { impl BitAndAssign, bitand_assign for Saturating<$t>, Saturating<$t> } forward_ref_op_assign! { impl BitAndAssign, bitand_assign for Saturating<$t>, Saturating<$t> }
#[unstable(feature = "saturating_int_assign_impl", issue = "92354")] #[stable(feature = "saturating_int_assign_impl", since = "CURRENT_RUSTC_VERSION")]
impl BitAndAssign<$t> for Saturating<$t> { impl BitAndAssign<$t> for Saturating<$t> {
#[inline] #[inline]
fn bitand_assign(&mut self, other: $t) { fn bitand_assign(&mut self, other: $t) {
@ -493,12 +495,11 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::MIN, Saturating(", stringify!($t), "::MIN));")] #[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::MIN, Saturating(", stringify!($t), "::MIN));")]
/// ``` /// ```
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const MIN: Self = Self(<$t>::MIN); pub const MIN: Self = Self(<$t>::MIN);
/// Returns the largest value that can be represented by this integer type. /// Returns the largest value that can be represented by this integer type.
@ -508,12 +509,11 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::MAX, Saturating(", stringify!($t), "::MAX));")] #[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::MAX, Saturating(", stringify!($t), "::MAX));")]
/// ``` /// ```
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const MAX: Self = Self(<$t>::MAX); pub const MAX: Self = Self(<$t>::MAX);
/// Returns the size of this integer type in bits. /// Returns the size of this integer type in bits.
@ -523,12 +523,11 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::BITS, ", stringify!($t), "::BITS);")] #[doc = concat!("assert_eq!(<Saturating<", stringify!($t), ">>::BITS, ", stringify!($t), "::BITS);")]
/// ``` /// ```
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const BITS: u32 = <$t>::BITS; pub const BITS: u32 = <$t>::BITS;
/// Returns the number of ones in the binary representation of `self`. /// Returns the number of ones in the binary representation of `self`.
@ -538,7 +537,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0b01001100", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0b01001100", stringify!($t), ");")]
@ -550,7 +548,8 @@ macro_rules! saturating_int_impl {
#[doc(alias = "popcnt")] #[doc(alias = "popcnt")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn count_ones(self) -> u32 { pub const fn count_ones(self) -> u32 {
self.0.count_ones() self.0.count_ones()
} }
@ -562,7 +561,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(Saturating(!0", stringify!($t), ").count_zeros(), 0);")] #[doc = concat!("assert_eq!(Saturating(!0", stringify!($t), ").count_zeros(), 0);")]
@ -570,7 +568,8 @@ macro_rules! saturating_int_impl {
#[inline] #[inline]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn count_zeros(self) -> u32 { pub const fn count_zeros(self) -> u32 {
self.0.count_zeros() self.0.count_zeros()
} }
@ -582,7 +581,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0b0101000", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0b0101000", stringify!($t), ");")]
@ -592,7 +590,8 @@ macro_rules! saturating_int_impl {
#[inline] #[inline]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn trailing_zeros(self) -> u32 { pub const fn trailing_zeros(self) -> u32 {
self.0.trailing_zeros() self.0.trailing_zeros()
} }
@ -609,7 +608,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// let n: Saturating<i64> = Saturating(0x0123456789ABCDEF); /// let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
@ -620,7 +618,8 @@ macro_rules! saturating_int_impl {
#[inline] #[inline]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn rotate_left(self, n: u32) -> Self { pub const fn rotate_left(self, n: u32) -> Self {
Saturating(self.0.rotate_left(n)) Saturating(self.0.rotate_left(n))
} }
@ -637,7 +636,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// let n: Saturating<i64> = Saturating(0x0123456789ABCDEF); /// let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
@ -648,7 +646,8 @@ macro_rules! saturating_int_impl {
#[inline] #[inline]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn rotate_right(self, n: u32) -> Self { pub const fn rotate_right(self, n: u32) -> Self {
Saturating(self.0.rotate_right(n)) Saturating(self.0.rotate_right(n))
} }
@ -660,7 +659,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// let n: Saturating<i16> = Saturating(0b0000000_01010101); /// let n: Saturating<i16> = Saturating(0b0000000_01010101);
@ -674,7 +672,8 @@ macro_rules! saturating_int_impl {
#[inline] #[inline]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn swap_bytes(self) -> Self { pub const fn swap_bytes(self) -> Self {
Saturating(self.0.swap_bytes()) Saturating(self.0.swap_bytes())
} }
@ -689,7 +688,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// let n = Saturating(0b0000000_01010101i16); /// let n = Saturating(0b0000000_01010101i16);
@ -701,8 +699,8 @@ macro_rules! saturating_int_impl {
/// assert_eq!(m, Saturating(-22016)); /// assert_eq!(m, Saturating(-22016));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[rustc_const_unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub const fn reverse_bits(self) -> Self { pub const fn reverse_bits(self) -> Self {
@ -719,7 +717,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")]
@ -732,7 +729,8 @@ macro_rules! saturating_int_impl {
/// ``` /// ```
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn from_be(x: Self) -> Self { pub const fn from_be(x: Self) -> Self {
Saturating(<$t>::from_be(x.0)) Saturating(<$t>::from_be(x.0))
} }
@ -747,7 +745,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")]
@ -760,7 +757,8 @@ macro_rules! saturating_int_impl {
/// ``` /// ```
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn from_le(x: Self) -> Self { pub const fn from_le(x: Self) -> Self {
Saturating(<$t>::from_le(x.0)) Saturating(<$t>::from_le(x.0))
} }
@ -775,7 +773,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")]
@ -787,7 +784,8 @@ macro_rules! saturating_int_impl {
/// } /// }
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub const fn to_be(self) -> Self { pub const fn to_be(self) -> Self {
@ -804,7 +802,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")] #[doc = concat!("let n = Saturating(0x1A", stringify!($t), ");")]
@ -816,7 +813,8 @@ macro_rules! saturating_int_impl {
/// } /// }
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub const fn to_le(self) -> Self { pub const fn to_le(self) -> Self {
@ -830,7 +828,6 @@ macro_rules! saturating_int_impl {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(Saturating(3", stringify!($t), ").pow(4), Saturating(81));")] #[doc = concat!("assert_eq!(Saturating(3", stringify!($t), ").pow(4), Saturating(81));")]
@ -839,17 +836,17 @@ macro_rules! saturating_int_impl {
/// Results that are too large are saturated: /// Results that are too large are saturated:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
/// assert_eq!(Saturating(3i8).pow(5), Saturating(127)); /// assert_eq!(Saturating(3i8).pow(5), Saturating(127));
/// assert_eq!(Saturating(3i8).pow(6), Saturating(127)); /// assert_eq!(Saturating(3i8).pow(6), Saturating(127));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub fn pow(self, exp: u32) -> Self { pub const fn pow(self, exp: u32) -> Self {
Saturating(self.0.saturating_pow(exp)) Saturating(self.0.saturating_pow(exp))
} }
} }
@ -868,7 +865,6 @@ macro_rules! saturating_int_impl_signed {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(", stringify!($t), "::MAX >> 2);")] #[doc = concat!("let n = Saturating(", stringify!($t), "::MAX >> 2);")]
@ -876,7 +872,8 @@ macro_rules! saturating_int_impl_signed {
/// assert_eq!(n.leading_zeros(), 3); /// assert_eq!(n.leading_zeros(), 3);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub const fn leading_zeros(self) -> u32 { pub const fn leading_zeros(self) -> u32 {
@ -891,7 +888,6 @@ macro_rules! saturating_int_impl_signed {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(Saturating(100", stringify!($t), ").abs(), Saturating(100));")] #[doc = concat!("assert_eq!(Saturating(100", stringify!($t), ").abs(), Saturating(100));")]
@ -901,10 +897,11 @@ macro_rules! saturating_int_impl_signed {
#[doc = concat!("assert_eq!(Saturating(", stringify!($t), "::MIN).abs(), Saturating(", stringify!($t), "::MAX));")] #[doc = concat!("assert_eq!(Saturating(", stringify!($t), "::MIN).abs(), Saturating(", stringify!($t), "::MAX));")]
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub fn abs(self) -> Saturating<$t> { pub const fn abs(self) -> Saturating<$t> {
Saturating(self.0.saturating_abs()) Saturating(self.0.saturating_abs())
} }
@ -919,7 +916,6 @@ macro_rules! saturating_int_impl_signed {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert_eq!(Saturating(10", stringify!($t), ").signum(), Saturating(1));")] #[doc = concat!("assert_eq!(Saturating(10", stringify!($t), ").signum(), Saturating(1));")]
@ -927,10 +923,11 @@ macro_rules! saturating_int_impl_signed {
#[doc = concat!("assert_eq!(Saturating(-10", stringify!($t), ").signum(), Saturating(-1));")] #[doc = concat!("assert_eq!(Saturating(-10", stringify!($t), ").signum(), Saturating(-1));")]
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub fn signum(self) -> Saturating<$t> { pub const fn signum(self) -> Saturating<$t> {
Saturating(self.0.signum()) Saturating(self.0.signum())
} }
@ -942,7 +939,6 @@ macro_rules! saturating_int_impl_signed {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert!(Saturating(10", stringify!($t), ").is_positive());")] #[doc = concat!("assert!(Saturating(10", stringify!($t), ").is_positive());")]
@ -950,7 +946,8 @@ macro_rules! saturating_int_impl_signed {
/// ``` /// ```
#[must_use] #[must_use]
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn is_positive(self) -> bool { pub const fn is_positive(self) -> bool {
self.0.is_positive() self.0.is_positive()
} }
@ -963,7 +960,6 @@ macro_rules! saturating_int_impl_signed {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert!(Saturating(-10", stringify!($t), ").is_negative());")] #[doc = concat!("assert!(Saturating(-10", stringify!($t), ").is_negative());")]
@ -971,13 +967,14 @@ macro_rules! saturating_int_impl_signed {
/// ``` /// ```
#[must_use] #[must_use]
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn is_negative(self) -> bool { pub const fn is_negative(self) -> bool {
self.0.is_negative() self.0.is_negative()
} }
} }
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
impl Neg for Saturating<$t> { impl Neg for Saturating<$t> {
type Output = Self; type Output = Self;
#[inline] #[inline]
@ -986,7 +983,7 @@ macro_rules! saturating_int_impl_signed {
} }
} }
forward_ref_unop! { impl Neg, neg for Saturating<$t>, forward_ref_unop! { impl Neg, neg for Saturating<$t>,
#[unstable(feature = "saturating_int_impl", issue = "87920")] } #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")] }
)*) )*)
} }
@ -1002,7 +999,6 @@ macro_rules! saturating_int_impl_unsigned {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("let n = Saturating(", stringify!($t), "::MAX >> 2);")] #[doc = concat!("let n = Saturating(", stringify!($t), "::MAX >> 2);")]
@ -1010,7 +1006,8 @@ macro_rules! saturating_int_impl_unsigned {
/// assert_eq!(n.leading_zeros(), 2); /// assert_eq!(n.leading_zeros(), 2);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
pub const fn leading_zeros(self) -> u32 { pub const fn leading_zeros(self) -> u32 {
@ -1024,7 +1021,6 @@ macro_rules! saturating_int_impl_unsigned {
/// Basic usage: /// Basic usage:
/// ///
/// ``` /// ```
/// #![feature(saturating_int_impl)]
/// use std::num::Saturating; /// use std::num::Saturating;
/// ///
#[doc = concat!("assert!(Saturating(16", stringify!($t), ").is_power_of_two());")] #[doc = concat!("assert!(Saturating(16", stringify!($t), ").is_power_of_two());")]
@ -1032,8 +1028,9 @@ macro_rules! saturating_int_impl_unsigned {
/// ``` /// ```
#[must_use] #[must_use]
#[inline] #[inline]
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[rustc_const_stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub fn is_power_of_two(self) -> bool { #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub const fn is_power_of_two(self) -> bool {
self.0.is_power_of_two() self.0.is_power_of_two()
} }

1
library/std/src/lib.rs
View file

@ -375,7 +375,6 @@
#![feature(get_many_mut)] #![feature(get_many_mut)]
#![feature(lazy_cell)] #![feature(lazy_cell)]
#![feature(log_syntax)] #![feature(log_syntax)]
#![feature(saturating_int_impl)]
#![feature(stdsimd)] #![feature(stdsimd)]
#![feature(test)] #![feature(test)]
#![feature(trace_macros)] #![feature(trace_macros)]

2
library/std/src/num.rs
View file

@ -12,7 +12,7 @@ mod tests;
#[cfg(test)] #[cfg(test)]
mod benches; mod benches;
#[unstable(feature = "saturating_int_impl", issue = "87920")] #[stable(feature = "saturating_int_impl", since = "CURRENT_RUSTC_VERSION")]
pub use core::num::Saturating; pub use core::num::Saturating;
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub use core::num::Wrapping; pub use core::num::Wrapping;

2
src/tools/clippy/tests/ui/arithmetic_side_effects.rs
View file

@ -10,7 +10,7 @@
arithmetic_overflow, arithmetic_overflow,
unconditional_panic unconditional_panic
)] )]
#![feature(const_mut_refs, inline_const, saturating_int_impl)] #![feature(const_mut_refs, inline_const)]
#![warn(clippy::arithmetic_side_effects)] #![warn(clippy::arithmetic_side_effects)]
extern crate proc_macro_derive; extern crate proc_macro_derive;