diff --git a/src/libcore/ascii.rs b/src/libcore/ascii.rs index 9b588525bd698..e78dfd1ed4abf 100644 --- a/src/libcore/ascii.rs +++ b/src/libcore/ascii.rs @@ -12,8 +12,8 @@ #![stable(feature = "core_ascii", since = "1.26.0")] use crate::fmt; -use crate::ops::Range; use crate::iter::FusedIterator; +use crate::ops::Range; use crate::str::from_utf8_unchecked; /// An iterator over the escaped version of a byte. @@ -100,7 +100,7 @@ pub fn escape_default(c: u8) -> EscapeDefault { b'\\' => ([b'\\', b'\\', 0, 0], 2), b'\'' => ([b'\\', b'\'', 0, 0], 2), b'"' => ([b'\\', b'"', 0, 0], 2), - b'\x20' ..= b'\x7e' => ([c, 0, 0, 0], 1), + b'\x20'..=b'\x7e' => ([c, 0, 0, 0], 1), _ => ([b'\\', b'x', hexify(c >> 4), hexify(c & 0xf)], 4), }; @@ -108,7 +108,7 @@ pub fn escape_default(c: u8) -> EscapeDefault { fn hexify(b: u8) -> u8 { match b { - 0 ..= 9 => b'0' + b, + 0..=9 => b'0' + b, _ => b'a' + b - 10, } } @@ -117,9 +117,15 @@ pub fn escape_default(c: u8) -> EscapeDefault { #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for EscapeDefault { type Item = u8; - fn next(&mut self) -> Option { self.range.next().map(|i| self.data[i]) } - fn size_hint(&self) -> (usize, Option) { self.range.size_hint() } - fn last(mut self) -> Option { self.next_back() } + fn next(&mut self) -> Option { + self.range.next().map(|i| self.data[i]) + } + fn size_hint(&self) -> (usize, Option) { + self.range.size_hint() + } + fn last(mut self) -> Option { + self.next_back() + } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for EscapeDefault { diff --git a/src/libcore/char/convert.rs b/src/libcore/char/convert.rs index 28f5207449561..dd21c72e745dd 100644 --- a/src/libcore/char/convert.rs +++ b/src/libcore/char/convert.rs @@ -158,7 +158,6 @@ impl From for char { } } - /// An error which can be returned when parsing a char. #[stable(feature = "char_from_str", since = "1.20.0")] #[derive(Clone, Debug, PartialEq, Eq)] @@ -167,16 +166,16 @@ pub struct ParseCharError { } impl ParseCharError { - #[unstable(feature = "char_error_internals", - reason = "this method should not be available publicly", - issue = "0")] + #[unstable( + feature = "char_error_internals", + reason = "this method should not be available publicly", + issue = "0" + )] #[doc(hidden)] pub fn __description(&self) -> &str { match self.kind { - CharErrorKind::EmptyString => { - "cannot parse char from empty string" - }, - CharErrorKind::TooManyChars => "too many characters in string" + CharErrorKind::EmptyString => "cannot parse char from empty string", + CharErrorKind::TooManyChars => "too many characters in string", } } } @@ -194,7 +193,6 @@ impl fmt::Display for ParseCharError { } } - #[stable(feature = "char_from_str", since = "1.20.0")] impl FromStr for char { type Err = ParseCharError; @@ -203,18 +201,13 @@ impl FromStr for char { fn from_str(s: &str) -> Result { let mut chars = s.chars(); match (chars.next(), chars.next()) { - (None, _) => { - Err(ParseCharError { kind: CharErrorKind::EmptyString }) - }, + (None, _) => Err(ParseCharError { kind: CharErrorKind::EmptyString }), (Some(c), None) => Ok(c), - _ => { - Err(ParseCharError { kind: CharErrorKind::TooManyChars }) - } + _ => Err(ParseCharError { kind: CharErrorKind::TooManyChars }), } } } - #[stable(feature = "try_from", since = "1.34.0")] impl TryFrom for char { type Error = CharTryFromError; @@ -304,11 +297,7 @@ pub fn from_digit(num: u32, radix: u32) -> Option { } if num < radix { let num = num as u8; - if num < 10 { - Some((b'0' + num) as char) - } else { - Some((b'a' + num - 10) as char) - } + if num < 10 { Some((b'0' + num) as char) } else { Some((b'a' + num - 10) as char) } } else { None } diff --git a/src/libcore/char/decode.rs b/src/libcore/char/decode.rs index ae09251c776de..5e7784730e3c9 100644 --- a/src/libcore/char/decode.rs +++ b/src/libcore/char/decode.rs @@ -8,7 +8,8 @@ use super::from_u32_unchecked; #[stable(feature = "decode_utf16", since = "1.9.0")] #[derive(Clone, Debug)] pub struct DecodeUtf16 - where I: Iterator +where + I: Iterator, { iter: I, buf: Option, @@ -70,10 +71,7 @@ pub struct DecodeUtf16Error { #[stable(feature = "decode_utf16", since = "1.9.0")] #[inline] pub fn decode_utf16>(iter: I) -> DecodeUtf16 { - DecodeUtf16 { - iter: iter.into_iter(), - buf: None, - } + DecodeUtf16 { iter: iter.into_iter(), buf: None } } #[stable(feature = "decode_utf16", since = "1.9.0")] @@ -83,7 +81,7 @@ impl> Iterator for DecodeUtf16 { fn next(&mut self) -> Option> { let u = match self.buf.take() { Some(buf) => buf, - None => self.iter.next()? + None => self.iter.next()?, }; if u < 0xD800 || 0xDFFF < u { diff --git a/src/libcore/char/methods.rs b/src/libcore/char/methods.rs index c048bab287dd2..1ec614edbe2eb 100644 --- a/src/libcore/char/methods.rs +++ b/src/libcore/char/methods.rs @@ -130,11 +130,7 @@ impl char { } }; - if val < radix { - Some(val) - } else { - None - } + if val < radix { Some(val) } else { None } } /// Returns an iterator that yields the hexadecimal Unicode escape of a @@ -950,11 +946,7 @@ impl char { #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[inline] pub fn to_ascii_uppercase(&self) -> char { - if self.is_ascii() { - (*self as u8).to_ascii_uppercase() as char - } else { - *self - } + if self.is_ascii() { (*self as u8).to_ascii_uppercase() as char } else { *self } } /// Makes a copy of the value in its ASCII lower case equivalent. @@ -982,11 +974,7 @@ impl char { #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[inline] pub fn to_ascii_lowercase(&self) -> char { - if self.is_ascii() { - (*self as u8).to_ascii_lowercase() as char - } else { - *self - } + if self.is_ascii() { (*self as u8).to_ascii_lowercase() as char } else { *self } } /// Checks that two values are an ASCII case-insensitive match. diff --git a/src/libcore/char/mod.rs b/src/libcore/char/mod.rs index dedd2f758b6cb..a655ee6e7e32a 100644 --- a/src/libcore/char/mod.rs +++ b/src/libcore/char/mod.rs @@ -24,14 +24,14 @@ mod decode; mod methods; // stable re-exports -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::convert::{from_u32, from_digit}; #[stable(feature = "char_from_unchecked", since = "1.5.0")] pub use self::convert::from_u32_unchecked; -#[stable(feature = "char_from_str", since = "1.20.0")] -pub use self::convert::ParseCharError; #[stable(feature = "try_from", since = "1.34.0")] pub use self::convert::CharTryFromError; +#[stable(feature = "char_from_str", since = "1.20.0")] +pub use self::convert::ParseCharError; +#[stable(feature = "rust1", since = "1.0.0")] +pub use self::convert::{from_digit, from_u32}; #[stable(feature = "decode_utf16", since = "1.9.0")] pub use self::decode::{decode_utf16, DecodeUtf16, DecodeUtf16Error}; @@ -45,13 +45,13 @@ use crate::fmt::{self, Write}; use crate::iter::FusedIterator; // UTF-8 ranges and tags for encoding characters -const TAG_CONT: u8 = 0b1000_0000; -const TAG_TWO_B: u8 = 0b1100_0000; -const TAG_THREE_B: u8 = 0b1110_0000; -const TAG_FOUR_B: u8 = 0b1111_0000; -const MAX_ONE_B: u32 = 0x80; -const MAX_TWO_B: u32 = 0x800; -const MAX_THREE_B: u32 = 0x10000; +const TAG_CONT: u8 = 0b1000_0000; +const TAG_TWO_B: u8 = 0b1100_0000; +const TAG_THREE_B: u8 = 0b1110_0000; +const TAG_FOUR_B: u8 = 0b1111_0000; +const MAX_ONE_B: u32 = 0x80; +const MAX_TWO_B: u32 = 0x800; +const MAX_THREE_B: u32 = 0x10000; /* Lu Uppercase_Letter an uppercase letter @@ -190,11 +190,11 @@ impl Iterator for EscapeUnicode { match self.state { EscapeUnicodeState::Done => None, - EscapeUnicodeState::RightBrace | - EscapeUnicodeState::Value | - EscapeUnicodeState::LeftBrace | - EscapeUnicodeState::Type | - EscapeUnicodeState::Backslash => Some('}'), + EscapeUnicodeState::RightBrace + | EscapeUnicodeState::Value + | EscapeUnicodeState::LeftBrace + | EscapeUnicodeState::Type + | EscapeUnicodeState::Backslash => Some('}'), } } } @@ -204,14 +204,15 @@ impl ExactSizeIterator for EscapeUnicode { #[inline] fn len(&self) -> usize { // The match is a single memory access with no branching - self.hex_digit_idx + match self.state { - EscapeUnicodeState::Done => 0, - EscapeUnicodeState::RightBrace => 1, - EscapeUnicodeState::Value => 2, - EscapeUnicodeState::LeftBrace => 3, - EscapeUnicodeState::Type => 4, - EscapeUnicodeState::Backslash => 5, - } + self.hex_digit_idx + + match self.state { + EscapeUnicodeState::Done => 0, + EscapeUnicodeState::RightBrace => 1, + EscapeUnicodeState::Value => 2, + EscapeUnicodeState::LeftBrace => 3, + EscapeUnicodeState::Type => 4, + EscapeUnicodeState::Backslash => 5, + } } } @@ -238,7 +239,7 @@ impl fmt::Display for EscapeUnicode { #[derive(Clone, Debug)] #[stable(feature = "rust1", since = "1.0.0")] pub struct EscapeDefault { - state: EscapeDefaultState + state: EscapeDefaultState, } #[derive(Clone, Debug)] @@ -284,24 +285,20 @@ impl Iterator for EscapeDefault { EscapeDefaultState::Backslash(c) if n == 0 => { self.state = EscapeDefaultState::Char(c); Some('\\') - }, + } EscapeDefaultState::Backslash(c) if n == 1 => { self.state = EscapeDefaultState::Done; Some(c) - }, + } EscapeDefaultState::Backslash(_) => { self.state = EscapeDefaultState::Done; None - }, + } EscapeDefaultState::Char(c) => { self.state = EscapeDefaultState::Done; - if n == 0 { - Some(c) - } else { - None - } - }, + if n == 0 { Some(c) } else { None } + } EscapeDefaultState::Done => None, EscapeDefaultState::Unicode(ref mut i) => i.nth(n), } @@ -355,12 +352,16 @@ pub struct EscapeDebug(EscapeDefault); #[stable(feature = "char_escape_debug", since = "1.20.0")] impl Iterator for EscapeDebug { type Item = char; - fn next(&mut self) -> Option { self.0.next() } - fn size_hint(&self) -> (usize, Option) { self.0.size_hint() } + fn next(&mut self) -> Option { + self.0.next() + } + fn size_hint(&self) -> (usize, Option) { + self.0.size_hint() + } } #[stable(feature = "char_escape_debug", since = "1.20.0")] -impl ExactSizeIterator for EscapeDebug { } +impl ExactSizeIterator for EscapeDebug {} #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for EscapeDebug {} @@ -440,7 +441,7 @@ impl CaseMappingIter { fn new(chars: [char; 3]) -> CaseMappingIter { if chars[2] == '\0' { if chars[1] == '\0' { - CaseMappingIter::One(chars[0]) // Including if chars[0] == '\0' + CaseMappingIter::One(chars[0]) // Including if chars[0] == '\0' } else { CaseMappingIter::Two(chars[0], chars[1]) } @@ -493,9 +494,7 @@ impl fmt::Display for CaseMappingIter { f.write_char(b)?; f.write_char(c) } - CaseMappingIter::One(c) => { - f.write_char(c) - } + CaseMappingIter::One(c) => f.write_char(c), CaseMappingIter::Zero => Ok(()), } } diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 86dd77f10f324..6e7a46ba62aab 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -107,7 +107,7 @@ /// [impls]: #implementors #[stable(feature = "rust1", since = "1.0.0")] #[lang = "clone"] -pub trait Clone : Sized { +pub trait Clone: Sized { /// Returns a copy of the value. /// /// # Examples @@ -137,7 +137,9 @@ pub trait Clone : Sized { #[rustc_builtin_macro] #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[allow_internal_unstable(core_intrinsics, derive_clone_copy)] -pub macro Clone($item:item) { /* compiler built-in */ } +pub macro Clone($item:item) { + /* compiler built-in */ +} // FIXME(aburka): these structs are used solely by #[derive] to // assert that every component of a type implements Clone or Copy. @@ -145,16 +147,24 @@ pub macro Clone($item:item) { /* compiler built-in */ } // These structs should never appear in user code. #[doc(hidden)] #[allow(missing_debug_implementations)] -#[unstable(feature = "derive_clone_copy", - reason = "deriving hack, should not be public", - issue = "0")] -pub struct AssertParamIsClone { _field: crate::marker::PhantomData } +#[unstable( + feature = "derive_clone_copy", + reason = "deriving hack, should not be public", + issue = "0" +)] +pub struct AssertParamIsClone { + _field: crate::marker::PhantomData, +} #[doc(hidden)] #[allow(missing_debug_implementations)] -#[unstable(feature = "derive_clone_copy", - reason = "deriving hack, should not be public", - issue = "0")] -pub struct AssertParamIsCopy { _field: crate::marker::PhantomData } +#[unstable( + feature = "derive_clone_copy", + reason = "deriving hack, should not be public", + issue = "0" +)] +pub struct AssertParamIsCopy { + _field: crate::marker::PhantomData, +} /// Implementations of `Clone` for primitive types. /// @@ -217,5 +227,4 @@ mod impls { *self } } - } diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index 89a269bdb8eb9..08802b3a97a0c 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -95,7 +95,9 @@ /// ``` #[stable(feature = "convert_id", since = "1.33.0")] #[inline] -pub const fn identity(x: T) -> T { x } +pub const fn identity(x: T) -> T { + x +} /// Used to do a cheap reference-to-reference conversion. /// @@ -364,12 +366,10 @@ pub trait Into: Sized { /// [`from`]: trait.From.html#tymethod.from /// [book]: ../../book/ch09-00-error-handling.html #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented( - on( - all(_Self="&str", T="std::string::String"), - note="to coerce a `{T}` into a `{Self}`, use `&*` as a prefix", - ) -)] +#[rustc_on_unimplemented(on( + all(_Self = "&str", T = "std::string::String"), + note = "to coerce a `{T}` into a `{Self}`, use `&*` as a prefix", +))] pub trait From: Sized { /// Performs the conversion. #[stable(feature = "rust1", since = "1.0.0")] @@ -490,7 +490,9 @@ pub trait TryFrom: Sized { // As lifts over & #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef for &T where T: AsRef +impl AsRef for &T +where + T: AsRef, { fn as_ref(&self) -> &U { >::as_ref(*self) @@ -499,7 +501,9 @@ impl AsRef for &T where T: AsRef // As lifts over &mut #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef for &mut T where T: AsRef +impl AsRef for &mut T +where + T: AsRef, { fn as_ref(&self) -> &U { >::as_ref(*self) @@ -516,7 +520,9 @@ impl AsRef for &mut T where T: AsRef // AsMut lifts over &mut #[stable(feature = "rust1", since = "1.0.0")] -impl AsMut for &mut T where T: AsMut +impl AsMut for &mut T +where + T: AsMut, { fn as_mut(&mut self) -> &mut U { (*self).as_mut() @@ -533,7 +539,9 @@ impl AsMut for &mut T where T: AsMut // From implies Into #[stable(feature = "rust1", since = "1.0.0")] -impl Into for T where U: From +impl Into for T +where + U: From, { fn into(self) -> U { U::from(self) @@ -543,7 +551,9 @@ impl Into for T where U: From // From (and thus Into) is reflexive #[stable(feature = "rust1", since = "1.0.0")] impl From for T { - fn from(t: T) -> T { t } + fn from(t: T) -> T { + t + } } /// **Stability note:** This impl does not yet exist, but we are @@ -552,15 +562,19 @@ impl From for T { /// /// [#64715]: https://github.com/rust-lang/rust/issues/64715 #[stable(feature = "convert_infallible", since = "1.34.0")] -#[rustc_reservation_impl="permitting this impl would forbid us from adding \ -`impl From for T` later; see rust-lang/rust#64715 for details"] +#[rustc_reservation_impl = "permitting this impl would forbid us from adding \ + `impl From for T` later; see rust-lang/rust#64715 for details"] impl From for T { - fn from(t: !) -> T { t } + fn from(t: !) -> T { + t + } } // TryFrom implies TryInto #[stable(feature = "try_from", since = "1.34.0")] -impl TryInto for T where U: TryFrom +impl TryInto for T +where + U: TryFrom, { type Error = U::Error; @@ -572,7 +586,10 @@ impl TryInto for T where U: TryFrom // Infallible conversions are semantically equivalent to fallible conversions // with an uninhabited error type. #[stable(feature = "try_from", since = "1.34.0")] -impl TryFrom for T where U: Into { +impl TryFrom for T +where + U: Into, +{ type Error = Infallible; fn try_from(value: U) -> Result { diff --git a/src/libcore/default.rs b/src/libcore/default.rs index 1aadc77cfb8da..15ac3aea8b7ba 100644 --- a/src/libcore/default.rs +++ b/src/libcore/default.rs @@ -119,7 +119,9 @@ pub trait Default: Sized { #[rustc_builtin_macro] #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[allow_internal_unstable(core_intrinsics)] -pub macro Default($item:item) { /* compiler built-in */ } +pub macro Default($item:item) { + /* compiler built-in */ +} macro_rules! default_impl { ($t:ty, $v:expr, $doc:tt) => { diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs index 499dd0facd38c..74ec24939a310 100644 --- a/src/libcore/ffi.rs +++ b/src/libcore/ffi.rs @@ -1,5 +1,4 @@ #![stable(feature = "", since = "1.30.0")] - #![allow(non_camel_case_types)] //! Utilities related to FFI bindings. @@ -36,12 +35,20 @@ use crate::ops::{Deref, DerefMut}; #[repr(u8)] #[stable(feature = "core_c_void", since = "1.30.0")] pub enum c_void { - #[unstable(feature = "c_void_variant", reason = "temporary implementation detail", - issue = "0")] - #[doc(hidden)] __variant1, - #[unstable(feature = "c_void_variant", reason = "temporary implementation detail", - issue = "0")] - #[doc(hidden)] __variant2, + #[unstable( + feature = "c_void_variant", + reason = "temporary implementation detail", + issue = "0" + )] + #[doc(hidden)] + __variant1, + #[unstable( + feature = "c_void_variant", + reason = "temporary implementation detail", + issue = "0" + )] + #[doc(hidden)] + __variant2, } #[stable(feature = "std_debug", since = "1.16.0")] @@ -53,17 +60,20 @@ impl fmt::Debug for c_void { /// Basic implementation of a `va_list`. // The name is WIP, using `VaListImpl` for now. -#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), - not(target_arch = "x86_64")), - all(target_arch = "aarch64", target_os = "ios"), - target_arch = "wasm32", - target_arch = "asmjs", - windows))] +#[cfg(any( + all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), not(target_arch = "x86_64")), + all(target_arch = "aarch64", target_os = "ios"), + target_arch = "wasm32", + target_arch = "asmjs", + windows +))] #[repr(transparent)] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] #[lang = "va_list"] pub struct VaListImpl<'f> { ptr: *mut c_void, @@ -73,16 +83,19 @@ pub struct VaListImpl<'f> { _marker: PhantomData<&'f mut &'f c_void>, } -#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), - not(target_arch = "x86_64")), - all(target_arch = "aarch64", target_os = "ios"), - target_arch = "wasm32", - target_arch = "asmjs", - windows))] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[cfg(any( + all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), not(target_arch = "x86_64")), + all(target_arch = "aarch64", target_os = "ios"), + target_arch = "wasm32", + target_arch = "asmjs", + windows +))] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> fmt::Debug for VaListImpl<'f> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "va_list* {:p}", self.ptr) @@ -97,10 +110,12 @@ impl<'f> fmt::Debug for VaListImpl<'f> { #[cfg(all(target_arch = "aarch64", not(target_os = "ios"), not(windows)))] #[repr(C)] #[derive(Debug)] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] #[lang = "va_list"] pub struct VaListImpl<'f> { stack: *mut c_void, @@ -115,10 +130,12 @@ pub struct VaListImpl<'f> { #[cfg(all(target_arch = "powerpc", not(windows)))] #[repr(C)] #[derive(Debug)] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] #[lang = "va_list"] pub struct VaListImpl<'f> { gpr: u8, @@ -133,10 +150,12 @@ pub struct VaListImpl<'f> { #[cfg(all(target_arch = "x86_64", not(windows)))] #[repr(C)] #[derive(Debug)] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] #[lang = "va_list"] pub struct VaListImpl<'f> { gp_offset: i32, @@ -149,76 +168,86 @@ pub struct VaListImpl<'f> { /// A wrapper for a `va_list` #[repr(transparent)] #[derive(Debug)] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] pub struct VaList<'a, 'f: 'a> { - #[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), - not(target_arch = "x86_64")), - all(target_arch = "aarch64", target_os = "ios"), - target_arch = "wasm32", - target_arch = "asmjs", - windows))] + #[cfg(any( + all( + not(target_arch = "aarch64"), + not(target_arch = "powerpc"), + not(target_arch = "x86_64") + ), + all(target_arch = "aarch64", target_os = "ios"), + target_arch = "wasm32", + target_arch = "asmjs", + windows + ))] inner: VaListImpl<'f>, - #[cfg(all(any(target_arch = "aarch64", target_arch = "powerpc", - target_arch = "x86_64"), - any(not(target_arch = "aarch64"), not(target_os = "ios")), - not(target_arch = "wasm32"), - not(target_arch = "asmjs"), - not(windows)))] + #[cfg(all( + any(target_arch = "aarch64", target_arch = "powerpc", target_arch = "x86_64"), + any(not(target_arch = "aarch64"), not(target_os = "ios")), + not(target_arch = "wasm32"), + not(target_arch = "asmjs"), + not(windows) + ))] inner: &'a mut VaListImpl<'f>, _marker: PhantomData<&'a mut VaListImpl<'f>>, } -#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), - not(target_arch = "x86_64")), - all(target_arch = "aarch64", target_os = "ios"), - target_arch = "wasm32", - target_arch = "asmjs", - windows))] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[cfg(any( + all(not(target_arch = "aarch64"), not(target_arch = "powerpc"), not(target_arch = "x86_64")), + all(target_arch = "aarch64", target_os = "ios"), + target_arch = "wasm32", + target_arch = "asmjs", + windows +))] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> VaListImpl<'f> { /// Convert a `VaListImpl` into a `VaList` that is binary-compatible with C's `va_list`. #[inline] pub fn as_va_list<'a>(&'a mut self) -> VaList<'a, 'f> { - VaList { - inner: VaListImpl { ..*self }, - _marker: PhantomData, - } + VaList { inner: VaListImpl { ..*self }, _marker: PhantomData } } } -#[cfg(all(any(target_arch = "aarch64", target_arch = "powerpc", - target_arch = "x86_64"), - any(not(target_arch = "aarch64"), not(target_os = "ios")), - not(target_arch = "wasm32"), - not(target_arch = "asmjs"), - not(windows)))] -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[cfg(all( + any(target_arch = "aarch64", target_arch = "powerpc", target_arch = "x86_64"), + any(not(target_arch = "aarch64"), not(target_os = "ios")), + not(target_arch = "wasm32"), + not(target_arch = "asmjs"), + not(windows) +))] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> VaListImpl<'f> { /// Convert a `VaListImpl` into a `VaList` that is binary-compatible with C's `va_list`. #[inline] pub fn as_va_list<'a>(&'a mut self) -> VaList<'a, 'f> { - VaList { - inner: self, - _marker: PhantomData, - } + VaList { inner: self, _marker: PhantomData } } } -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'a, 'f: 'a> Deref for VaList<'a, 'f> { type Target = VaListImpl<'f>; @@ -228,10 +257,12 @@ impl<'a, 'f: 'a> Deref for VaList<'a, 'f> { } } -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'a, 'f: 'a> DerefMut for VaList<'a, 'f> { #[inline] fn deref_mut(&mut self) -> &mut VaListImpl<'f> { @@ -252,10 +283,12 @@ mod sealed_trait { /// Trait which whitelists the allowed types to be used with [VaList::arg] /// /// [VaList::va_arg]: struct.VaList.html#method.arg - #[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] + #[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" + )] pub trait VaArgSafe {} } @@ -271,25 +304,31 @@ macro_rules! impl_va_arg_safe { } } -impl_va_arg_safe!{i8, i16, i32, i64, usize} -impl_va_arg_safe!{u8, u16, u32, u64, isize} -impl_va_arg_safe!{f64} +impl_va_arg_safe! {i8, i16, i32, i64, usize} +impl_va_arg_safe! {u8, u16, u32, u64, isize} +impl_va_arg_safe! {f64} -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl sealed_trait::VaArgSafe for *mut T {} -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl sealed_trait::VaArgSafe for *const T {} -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> VaListImpl<'f> { /// Advance to the next arg. #[inline] @@ -299,7 +338,9 @@ impl<'f> VaListImpl<'f> { /// Copies the `va_list` at the current location. pub unsafe fn with_copy(&self, f: F) -> R - where F: for<'copy> FnOnce(VaList<'copy, 'f>) -> R { + where + F: for<'copy> FnOnce(VaList<'copy, 'f>) -> R, + { let mut ap = self.clone(); let ret = f(ap.as_va_list()); va_end(&mut ap); @@ -307,10 +348,12 @@ impl<'f> VaListImpl<'f> { } } -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> Clone for VaListImpl<'f> { #[inline] fn clone(&self) -> Self { @@ -323,10 +366,12 @@ impl<'f> Clone for VaListImpl<'f> { } } -#[unstable(feature = "c_variadic", - reason = "the `c_variadic` feature has not been properly tested on \ - all supported platforms", - issue = "44930")] +#[unstable( + feature = "c_variadic", + reason = "the `c_variadic` feature has not been properly tested on \ + all supported platforms", + issue = "44930" +)] impl<'f> Drop for VaListImpl<'f> { fn drop(&mut self) { // FIXME: this should call `va_end`, but there's no clean way to diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index b52b56b1bdbc2..284e94926dc85 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -1,4 +1,4 @@ -use crate::fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug}; +use crate::fmt::{Debug, Display, Formatter, LowerExp, Result, UpperExp}; use crate::mem::MaybeUninit; use crate::num::flt2dec; @@ -7,9 +7,14 @@ use crate::num::flt2dec; // Don't inline this so callers don't use the stack space this function // requires unless they have to. #[inline(never)] -fn float_to_decimal_common_exact(fmt: &mut Formatter<'_>, num: &T, - sign: flt2dec::Sign, precision: usize) -> Result - where T: flt2dec::DecodableFloat +fn float_to_decimal_common_exact( + fmt: &mut Formatter<'_>, + num: &T, + sign: flt2dec::Sign, + precision: usize, +) -> Result +where + T: flt2dec::DecodableFloat, { unsafe { let mut buf = MaybeUninit::<[u8; 1024]>::uninit(); // enough for f32 and f64 @@ -19,9 +24,15 @@ fn float_to_decimal_common_exact(fmt: &mut Formatter<'_>, num: &T, // we decided whether that is valid or not. // We can do this only because we are libstd and coupled to the compiler. // (FWIW, using `freeze` would not be enough; `flt2dec::Part` is an enum!) - let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact, - *num, sign, precision, - false, buf.get_mut(), parts.get_mut()); + let formatted = flt2dec::to_exact_fixed_str( + flt2dec::strategy::grisu::format_exact, + *num, + sign, + precision, + false, + buf.get_mut(), + parts.get_mut(), + ); fmt.pad_formatted_parts(&formatted) } } @@ -29,33 +40,49 @@ fn float_to_decimal_common_exact(fmt: &mut Formatter<'_>, num: &T, // Don't inline this so callers that call both this and the above won't wind // up using the combined stack space of both functions in some cases. #[inline(never)] -fn float_to_decimal_common_shortest(fmt: &mut Formatter<'_>, num: &T, - sign: flt2dec::Sign, precision: usize) -> Result - where T: flt2dec::DecodableFloat +fn float_to_decimal_common_shortest( + fmt: &mut Formatter<'_>, + num: &T, + sign: flt2dec::Sign, + precision: usize, +) -> Result +where + T: flt2dec::DecodableFloat, { unsafe { // enough for f32 and f64 let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninit(); let mut parts = MaybeUninit::<[flt2dec::Part<'_>; 4]>::uninit(); // FIXME(#53491) - let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num, - sign, precision, false, buf.get_mut(), - parts.get_mut()); + let formatted = flt2dec::to_shortest_str( + flt2dec::strategy::grisu::format_shortest, + *num, + sign, + precision, + false, + buf.get_mut(), + parts.get_mut(), + ); fmt.pad_formatted_parts(&formatted) } } // Common code of floating point Debug and Display. -fn float_to_decimal_common(fmt: &mut Formatter<'_>, num: &T, - negative_zero: bool, min_precision: usize) -> Result - where T: flt2dec::DecodableFloat +fn float_to_decimal_common( + fmt: &mut Formatter<'_>, + num: &T, + negative_zero: bool, + min_precision: usize, +) -> Result +where + T: flt2dec::DecodableFloat, { let force_sign = fmt.sign_plus(); let sign = match (force_sign, negative_zero) { (false, false) => flt2dec::Sign::Minus, - (false, true) => flt2dec::Sign::MinusRaw, - (true, false) => flt2dec::Sign::MinusPlus, - (true, true) => flt2dec::Sign::MinusPlusRaw, + (false, true) => flt2dec::Sign::MinusRaw, + (true, false) => flt2dec::Sign::MinusPlus, + (true, true) => flt2dec::Sign::MinusPlusRaw, }; if let Some(precision) = fmt.precision { @@ -68,18 +95,29 @@ fn float_to_decimal_common(fmt: &mut Formatter<'_>, num: &T, // Don't inline this so callers don't use the stack space this function // requires unless they have to. #[inline(never)] -fn float_to_exponential_common_exact(fmt: &mut Formatter<'_>, num: &T, - sign: flt2dec::Sign, precision: usize, - upper: bool) -> Result - where T: flt2dec::DecodableFloat +fn float_to_exponential_common_exact( + fmt: &mut Formatter<'_>, + num: &T, + sign: flt2dec::Sign, + precision: usize, + upper: bool, +) -> Result +where + T: flt2dec::DecodableFloat, { unsafe { let mut buf = MaybeUninit::<[u8; 1024]>::uninit(); // enough for f32 and f64 let mut parts = MaybeUninit::<[flt2dec::Part<'_>; 6]>::uninit(); // FIXME(#53491) - let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact, - *num, sign, precision, - upper, buf.get_mut(), parts.get_mut()); + let formatted = flt2dec::to_exact_exp_str( + flt2dec::strategy::grisu::format_exact, + *num, + sign, + precision, + upper, + buf.get_mut(), + parts.get_mut(), + ); fmt.pad_formatted_parts(&formatted) } } @@ -87,31 +125,42 @@ fn float_to_exponential_common_exact(fmt: &mut Formatter<'_>, num: &T, // Don't inline this so callers that call both this and the above won't wind // up using the combined stack space of both functions in some cases. #[inline(never)] -fn float_to_exponential_common_shortest(fmt: &mut Formatter<'_>, - num: &T, sign: flt2dec::Sign, - upper: bool) -> Result - where T: flt2dec::DecodableFloat +fn float_to_exponential_common_shortest( + fmt: &mut Formatter<'_>, + num: &T, + sign: flt2dec::Sign, + upper: bool, +) -> Result +where + T: flt2dec::DecodableFloat, { unsafe { // enough for f32 and f64 let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninit(); let mut parts = MaybeUninit::<[flt2dec::Part<'_>; 6]>::uninit(); // FIXME(#53491) - let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest, - *num, sign, (0, 0), upper, - buf.get_mut(), parts.get_mut()); + let formatted = flt2dec::to_shortest_exp_str( + flt2dec::strategy::grisu::format_shortest, + *num, + sign, + (0, 0), + upper, + buf.get_mut(), + parts.get_mut(), + ); fmt.pad_formatted_parts(&formatted) } } // Common code of floating point LowerExp and UpperExp. fn float_to_exponential_common(fmt: &mut Formatter<'_>, num: &T, upper: bool) -> Result - where T: flt2dec::DecodableFloat +where + T: flt2dec::DecodableFloat, { let force_sign = fmt.sign_plus(); let sign = match force_sign { false => flt2dec::Sign::Minus, - true => flt2dec::Sign::MinusPlus, + true => flt2dec::Sign::MinusPlus, }; if let Some(precision) = fmt.precision { @@ -123,7 +172,7 @@ fn float_to_exponential_common(fmt: &mut Formatter<'_>, num: &T, upper: bool) } macro_rules! floating { - ($ty:ident) => ( + ($ty:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl Debug for $ty { fn fmt(&self, fmt: &mut Formatter<'_>) -> Result { @@ -151,7 +200,7 @@ macro_rules! floating { float_to_exponential_common(fmt, self, true) } } - ) + }; } floating! { f32 } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 07dca9ad214ec..4c941e2dfe6de 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -4,7 +4,7 @@ #![stable(feature = "rust1", since = "1.0.0")] -use crate::cell::{UnsafeCell, Cell, RefCell, Ref, RefMut}; +use crate::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell}; use crate::marker::PhantomData; use crate::mem; use crate::num::flt2dec; @@ -13,9 +13,9 @@ use crate::result; use crate::slice; use crate::str; +mod builders; mod float; mod num; -mod builders; #[stable(feature = "fmt_flags_align", since = "1.28.0")] /// Possible alignments returned by `Formatter::align` @@ -33,10 +33,9 @@ pub enum Alignment { } #[stable(feature = "debug_builders", since = "1.2.0")] -pub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugList, DebugMap}; +pub use self::builders::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple}; -#[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] +#[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] #[doc(hidden)] pub mod rt { pub mod v1; @@ -234,7 +233,7 @@ pub struct Formatter<'a> { width: Option, precision: Option, - buf: &'a mut (dyn Write+'a), + buf: &'a mut (dyn Write + 'a), curarg: slice::Iter<'a, ArgumentV1<'a>>, args: &'a [ArgumentV1<'a>], } @@ -260,8 +259,7 @@ struct Void { /// types, and then this struct is used to canonicalize arguments to one type. #[derive(Copy, Clone)] #[allow(missing_debug_implementations)] -#[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] +#[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] #[doc(hidden)] pub struct ArgumentV1<'a> { value: &'a Void, @@ -275,21 +273,13 @@ impl<'a> ArgumentV1<'a> { } #[doc(hidden)] - #[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] - pub fn new<'b, T>(x: &'b T, - f: fn(&T, &mut Formatter<'_>) -> Result) -> ArgumentV1<'b> { - unsafe { - ArgumentV1 { - formatter: mem::transmute(f), - value: mem::transmute(x) - } - } + #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] + pub fn new<'b, T>(x: &'b T, f: fn(&T, &mut Formatter<'_>) -> Result) -> ArgumentV1<'b> { + unsafe { ArgumentV1 { formatter: mem::transmute(f), value: mem::transmute(x) } } } #[doc(hidden)] - #[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] + #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] pub fn from_usize(x: &usize) -> ArgumentV1<'_> { ArgumentV1::new(x, ArgumentV1::show_usize) } @@ -305,21 +295,23 @@ impl<'a> ArgumentV1<'a> { // flags available in the v1 format of format_args #[derive(Copy, Clone)] -enum FlagV1 { SignPlus, SignMinus, Alternate, SignAwareZeroPad, DebugLowerHex, DebugUpperHex } +enum FlagV1 { + SignPlus, + SignMinus, + Alternate, + SignAwareZeroPad, + DebugLowerHex, + DebugUpperHex, +} impl<'a> Arguments<'a> { /// When using the format_args!() macro, this function is used to generate the /// Arguments structure. - #[doc(hidden)] #[inline] - #[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] - pub fn new_v1(pieces: &'a [&'a str], - args: &'a [ArgumentV1<'a>]) -> Arguments<'a> { - Arguments { - pieces, - fmt: None, - args, - } + #[doc(hidden)] + #[inline] + #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] + pub fn new_v1(pieces: &'a [&'a str], args: &'a [ArgumentV1<'a>]) -> Arguments<'a> { + Arguments { pieces, fmt: None, args } } /// This function is used to specify nonstandard formatting parameters. @@ -328,29 +320,26 @@ impl<'a> Arguments<'a> { /// `CountIsParam` or `CountIsNextParam` has to point to an argument /// created with `argumentusize`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . - #[doc(hidden)] #[inline] - #[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] - pub fn new_v1_formatted(pieces: &'a [&'a str], - args: &'a [ArgumentV1<'a>], - fmt: &'a [rt::v1::Argument]) -> Arguments<'a> { - Arguments { - pieces, - fmt: Some(fmt), - args, - } + #[doc(hidden)] + #[inline] + #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] + pub fn new_v1_formatted( + pieces: &'a [&'a str], + args: &'a [ArgumentV1<'a>], + fmt: &'a [rt::v1::Argument], + ) -> Arguments<'a> { + Arguments { pieces, fmt: Some(fmt), args } } /// Estimates the length of the formatted text. /// /// This is intended to be used for setting initial `String` capacity /// when using `format!`. Note: this is neither the lower nor upper bound. - #[doc(hidden)] #[inline] - #[unstable(feature = "fmt_internals", reason = "internal to format_args!", - issue = "0")] + #[doc(hidden)] + #[inline] + #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "0")] pub fn estimated_capacity(&self) -> usize { - let pieces_length: usize = self.pieces.iter() - .map(|x| x.len()).sum(); + let pieces_length: usize = self.pieces.iter().map(|x| x.len()).sum(); if self.args.is_empty() { pieces_length @@ -514,10 +503,13 @@ impl Display for Arguments<'_> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[rustc_on_unimplemented( - on(crate_local, label="`{Self}` cannot be formatted using `{{:?}}`", - note="add `#[derive(Debug)]` or manually implement `{Debug}`"), - message="`{Self}` doesn't implement `{Debug}`", - label="`{Self}` cannot be formatted using `{{:?}}` because it doesn't implement `{Debug}`", + on( + crate_local, + label = "`{Self}` cannot be formatted using `{{:?}}`", + note = "add `#[derive(Debug)]` or manually implement `{Debug}`" + ), + message = "`{Self}` doesn't implement `{Debug}`", + label = "`{Self}` cannot be formatted using `{{:?}}` because it doesn't implement `{Debug}`" )] #[doc(alias = "{:?}")] #[rustc_diagnostic_item = "debug_trait"] @@ -553,7 +545,9 @@ pub(crate) mod macros { #[rustc_builtin_macro] #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[allow_internal_unstable(core_intrinsics)] - pub macro Debug($item:item) { /* compiler built-in */ } + pub macro Debug($item:item) { + /* compiler built-in */ + } } #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[doc(inline)] @@ -594,14 +588,14 @@ pub use macros::Debug; /// ``` #[rustc_on_unimplemented( on( - _Self="std::path::Path", - label="`{Self}` cannot be formatted with the default formatter; call `.display()` on it", - note="call `.display()` or `.to_string_lossy()` to safely print paths, \ - as they may contain non-Unicode data" + _Self = "std::path::Path", + label = "`{Self}` cannot be formatted with the default formatter; call `.display()` on it", + note = "call `.display()` or `.to_string_lossy()` to safely print paths, \ + as they may contain non-Unicode data" ), - message="`{Self}` doesn't implement `{Display}`", - label="`{Self}` cannot be formatted with the default formatter", - note="in format strings you may be able to use `{{:?}}` (or {{:#?}} for pretty-print) instead", + message = "`{Self}` doesn't implement `{Display}`", + label = "`{Self}` cannot be formatted with the default formatter", + note = "in format strings you may be able to use `{{:?}}` (or {{:#?}} for pretty-print) instead" )] #[doc(alias = "{}")] #[stable(feature = "rust1", since = "1.0.0")] @@ -1073,7 +1067,9 @@ impl PostPadding { impl<'a> Formatter<'a> { fn wrap_buf<'b, 'c, F>(&'b mut self, wrap: F) -> Formatter<'c> - where 'b: 'c, F: FnOnce(&'b mut (dyn Write+'b)) -> &'c mut (dyn Write+'c) + where + 'b: 'c, + F: FnOnce(&'b mut (dyn Write + 'b)) -> &'c mut (dyn Write + 'c), { Formatter { // We want to change this @@ -1106,7 +1102,7 @@ impl<'a> Formatter<'a> { // Extract the correct argument let value = match arg.position { - rt::v1::Position::Next => { *self.curarg.next().unwrap() } + rt::v1::Position::Next => *self.curarg.next().unwrap(), rt::v1::Position::At(i) => self.args[i], }; @@ -1118,12 +1114,8 @@ impl<'a> Formatter<'a> { match *cnt { rt::v1::Count::Is(n) => Some(n), rt::v1::Count::Implied => None, - rt::v1::Count::Param(i) => { - self.args[i].as_usize() - } - rt::v1::Count::NextParam => { - self.curarg.next()?.as_usize() - } + rt::v1::Count::Param(i) => self.args[i].as_usize(), + rt::v1::Count::NextParam => self.curarg.next()?.as_usize(), } } @@ -1174,18 +1166,16 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{:0>#8}", Foo::new(-1)), "00-Foo 1"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn pad_integral(&mut self, - is_nonnegative: bool, - prefix: &str, - buf: &str) - -> Result { + pub fn pad_integral(&mut self, is_nonnegative: bool, prefix: &str, buf: &str) -> Result { let mut width = buf.len(); let mut sign = None; if !is_nonnegative { - sign = Some('-'); width += 1; + sign = Some('-'); + width += 1; } else if self.sign_plus() { - sign = Some('+'); width += 1; + sign = Some('+'); + width += 1; } let prefix = if self.alternate() { @@ -1201,11 +1191,7 @@ impl<'a> Formatter<'a> { if let Some(c) = sign { f.buf.write_char(c)?; } - if let Some(prefix) = prefix { - f.buf.write_str(prefix) - } else { - Ok(()) - } + if let Some(prefix) = prefix { f.buf.write_str(prefix) } else { Ok(()) } } // The `width` field is more of a `min-width` parameter at this point. @@ -1301,9 +1287,7 @@ impl<'a> Formatter<'a> { None => self.buf.write_str(s), // If we're under the maximum width, check if we're over the minimum // width, if so it's as easy as just emitting the string. - Some(width) if s.chars().count() >= width => { - self.buf.write_str(s) - } + Some(width) if s.chars().count() >= width => self.buf.write_str(s), // If we're under both the maximum and the minimum width, then fill // up the minimum width with the specified string + some alignment. Some(width) => { @@ -1321,17 +1305,16 @@ impl<'a> Formatter<'a> { fn padding( &mut self, padding: usize, - default: rt::v1::Alignment + default: rt::v1::Alignment, ) -> result::Result { let align = match self.align { rt::v1::Alignment::Unknown => default, - _ => self.align + _ => self.align, }; let (pre_pad, post_pad) = match align { rt::v1::Alignment::Left => (0, padding), - rt::v1::Alignment::Right | - rt::v1::Alignment::Unknown => (padding, 0), + rt::v1::Alignment::Right | rt::v1::Alignment::Unknown => (padding, 0), rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2), }; @@ -1368,7 +1351,8 @@ impl<'a> Formatter<'a> { // remaining parts go through the ordinary padding process. let len = formatted.len(); - let ret = if width <= len { // no padding + let ret = if width <= len { + // no padding self.write_formatted_parts(&formatted) } else { let post_padding = self.padding(width - len, align)?; @@ -1473,10 +1457,14 @@ impl<'a> Formatter<'a> { /// Flags for formatting #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_deprecated(since = "1.24.0", - reason = "use the `sign_plus`, `sign_minus`, `alternate`, \ - or `sign_aware_zero_pad` methods instead")] - pub fn flags(&self) -> u32 { self.flags } + #[rustc_deprecated( + since = "1.24.0", + reason = "use the `sign_plus`, `sign_minus`, `alternate`, \ + or `sign_aware_zero_pad` methods instead" + )] + pub fn flags(&self) -> u32 { + self.flags + } /// Character used as 'fill' whenever there is alignment. /// @@ -1506,7 +1494,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{:t>6}", Foo), "tttttt"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn fill(&self) -> char { self.fill } + pub fn fill(&self) -> char { + self.fill + } /// Flag indicating what form of alignment was requested. /// @@ -1574,7 +1564,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{}", Foo(23)), "Foo(23)"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn width(&self) -> Option { self.width } + pub fn width(&self) -> Option { + self.width + } /// Optionally specified precision for numeric types. /// @@ -1601,7 +1593,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{}", Foo(23.2)), "Foo(23.20)"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn precision(&self) -> Option { self.precision } + pub fn precision(&self) -> Option { + self.precision + } /// Determines if the `+` flag was specified. /// @@ -1629,7 +1623,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{}", Foo(23)), "Foo(23)"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn sign_plus(&self) -> bool { self.flags & (1 << FlagV1::SignPlus as u32) != 0 } + pub fn sign_plus(&self) -> bool { + self.flags & (1 << FlagV1::SignPlus as u32) != 0 + } /// Determines if the `-` flag was specified. /// @@ -1655,7 +1651,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{}", Foo(23)), "Foo(23)"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn sign_minus(&self) -> bool { self.flags & (1 << FlagV1::SignMinus as u32) != 0 } + pub fn sign_minus(&self) -> bool { + self.flags & (1 << FlagV1::SignMinus as u32) != 0 + } /// Determines if the `#` flag was specified. /// @@ -1680,7 +1678,9 @@ impl<'a> Formatter<'a> { /// assert_eq!(&format!("{}", Foo(23)), "23"); /// ``` #[stable(feature = "fmt_flags", since = "1.5.0")] - pub fn alternate(&self) -> bool { self.flags & (1 << FlagV1::Alternate as u32) != 0 } + pub fn alternate(&self) -> bool { + self.flags & (1 << FlagV1::Alternate as u32) != 0 + } /// Determines if the `0` flag was specified. /// @@ -1709,9 +1709,13 @@ impl<'a> Formatter<'a> { // FIXME: Decide what public API we want for these two flags. // https://github.com/rust-lang/rust/issues/48584 - fn debug_lower_hex(&self) -> bool { self.flags & (1 << FlagV1::DebugLowerHex as u32) != 0 } + fn debug_lower_hex(&self) -> bool { + self.flags & (1 << FlagV1::DebugLowerHex as u32) != 0 + } - fn debug_upper_hex(&self) -> bool { self.flags & (1 << FlagV1::DebugUpperHex as u32) != 0 } + fn debug_upper_hex(&self) -> bool { + self.flags & (1 << FlagV1::DebugUpperHex as u32) != 0 + } /// Creates a [`DebugStruct`] builder designed to assist with creation of /// [`fmt::Debug`] implementations for structs. @@ -2067,11 +2071,15 @@ impl Pointer for &mut T { #[stable(feature = "rust1", since = "1.0.0")] impl Debug for *const T { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { Pointer::fmt(self, f) } + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + Pointer::fmt(self, f) + } } #[stable(feature = "rust1", since = "1.0.0")] impl Debug for *mut T { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { Pointer::fmt(self, f) } + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + Pointer::fmt(self, f) + } } macro_rules! peel { @@ -2129,9 +2137,7 @@ impl Debug for PhantomData { #[stable(feature = "rust1", since = "1.0.0")] impl Debug for Cell { fn fmt(&self, f: &mut Formatter<'_>) -> Result { - f.debug_struct("Cell") - .field("value", &self.get()) - .finish() + f.debug_struct("Cell").field("value", &self.get()).finish() } } @@ -2139,11 +2145,7 @@ impl Debug for Cell { impl Debug for RefCell { fn fmt(&self, f: &mut Formatter<'_>) -> Result { match self.try_borrow() { - Ok(borrow) => { - f.debug_struct("RefCell") - .field("value", &borrow) - .finish() - } + Ok(borrow) => f.debug_struct("RefCell").field("value", &borrow).finish(), Err(_) => { // The RefCell is mutably borrowed so we can't look at its value // here. Show a placeholder instead. @@ -2155,9 +2157,7 @@ impl Debug for RefCell { } } - f.debug_struct("RefCell") - .field("value", &BorrowedPlaceholder) - .finish() + f.debug_struct("RefCell").field("value", &BorrowedPlaceholder).finish() } } } diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 0082363692df6..0db8d86ebbf52 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -192,7 +192,8 @@ pub trait Hash { /// [`Hasher`]: trait.Hasher.html #[stable(feature = "hash_slice", since = "1.3.0")] fn hash_slice(data: &[Self], state: &mut H) - where Self: Sized + where + Self: Sized, { for piece in data { piece.hash(state); @@ -206,7 +207,9 @@ pub(crate) mod macros { #[rustc_builtin_macro] #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[allow_internal_unstable(core_intrinsics)] - pub macro Hash($item:item) { /* compiler built-in */ } + pub macro Hash($item:item) { + /* compiler built-in */ + } } #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[doc(inline)] @@ -666,7 +669,6 @@ mod impls { } } - #[stable(feature = "rust1", since = "1.0.0")] impl Hash for &T { fn hash(&self, state: &mut H) { @@ -689,9 +691,7 @@ mod impls { state.write_usize(*self as *const () as usize); } else { // Fat pointer - let (a, b) = unsafe { - *(self as *const Self as *const (usize, usize)) - }; + let (a, b) = unsafe { *(self as *const Self as *const (usize, usize)) }; state.write_usize(a); state.write_usize(b); } @@ -706,9 +706,7 @@ mod impls { state.write_usize(*self as *const () as usize); } else { // Fat pointer - let (a, b) = unsafe { - *(self as *const Self as *const (usize, usize)) - }; + let (a, b) = unsafe { *(self as *const Self as *const (usize, usize)) }; state.write_usize(a); state.write_usize(b); } diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index 194d9e6e2f8ad..0aa3b97ebcf15 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -4,10 +4,10 @@ #![allow(deprecated)] // the types in this module are deprecated -use crate::marker::PhantomData; -use crate::ptr; use crate::cmp; +use crate::marker::PhantomData; use crate::mem; +use crate::ptr; /// An implementation of SipHash 1-3. /// @@ -16,8 +16,10 @@ use crate::mem; /// /// See: #[unstable(feature = "hashmap_internals", issue = "0")] -#[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] +#[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" +)] #[derive(Debug, Clone, Default)] #[doc(hidden)] pub struct SipHasher13 { @@ -28,8 +30,10 @@ pub struct SipHasher13 { /// /// See: #[unstable(feature = "hashmap_internals", issue = "0")] -#[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] +#[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" +)] #[derive(Debug, Clone, Default)] struct SipHasher24 { hasher: Hasher, @@ -48,8 +52,10 @@ struct SipHasher24 { /// it is not intended for cryptographic purposes. As such, all /// cryptographic uses of this implementation are _strongly discouraged_. #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] +#[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" +)] #[derive(Debug, Clone, Default)] pub struct SipHasher(SipHasher24); @@ -58,9 +64,9 @@ struct Hasher { k0: u64, k1: u64, length: usize, // how many bytes we've processed - state: State, // hash State - tail: u64, // unprocessed bytes le - ntail: usize, // how many bytes in tail are valid + state: State, // hash State + tail: u64, // unprocessed bytes le + ntail: usize, // how many bytes in tail are valid _marker: PhantomData, } @@ -78,18 +84,23 @@ struct State { } macro_rules! compress { - ($state:expr) => ({ - compress!($state.v0, $state.v1, $state.v2, $state.v3) - }); - ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => - ({ - $v0 = $v0.wrapping_add($v1); $v1 = $v1.rotate_left(13); $v1 ^= $v0; + ($state:expr) => {{ compress!($state.v0, $state.v1, $state.v2, $state.v3) }}; + ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{ + $v0 = $v0.wrapping_add($v1); + $v1 = $v1.rotate_left(13); + $v1 ^= $v0; $v0 = $v0.rotate_left(32); - $v2 = $v2.wrapping_add($v3); $v3 = $v3.rotate_left(16); $v3 ^= $v2; - $v0 = $v0.wrapping_add($v3); $v3 = $v3.rotate_left(21); $v3 ^= $v0; - $v2 = $v2.wrapping_add($v1); $v1 = $v1.rotate_left(17); $v1 ^= $v2; + $v2 = $v2.wrapping_add($v3); + $v3 = $v3.rotate_left(16); + $v3 ^= $v2; + $v0 = $v0.wrapping_add($v3); + $v3 = $v3.rotate_left(21); + $v3 ^= $v0; + $v2 = $v2.wrapping_add($v1); + $v1 = $v1.rotate_left(17); + $v1 ^= $v2; $v2 = $v2.rotate_left(32); - }); + }}; } /// Loads an integer of the desired type from a byte stream, in LE order. Uses @@ -98,15 +109,16 @@ macro_rules! compress { /// /// Unsafe because: unchecked indexing at i..i+size_of(int_ty) macro_rules! load_int_le { - ($buf:expr, $i:expr, $int_ty:ident) => - ({ - debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len()); - let mut data = 0 as $int_ty; - ptr::copy_nonoverlapping($buf.get_unchecked($i), - &mut data as *mut _ as *mut u8, - mem::size_of::<$int_ty>()); - data.to_le() - }); + ($buf:expr, $i:expr, $int_ty:ident) => {{ + debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len()); + let mut data = 0 as $int_ty; + ptr::copy_nonoverlapping( + $buf.get_unchecked($i), + &mut data as *mut _ as *mut u8, + mem::size_of::<$int_ty>(), + ); + data.to_le() + }}; } /// Loads an u64 using up to 7 bytes of a byte slice. @@ -137,8 +149,10 @@ impl SipHasher { /// Creates a new `SipHasher` with the two initial keys set to 0. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] + #[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" + )] pub fn new() -> SipHasher { SipHasher::new_with_keys(0, 0) } @@ -146,12 +160,12 @@ impl SipHasher { /// Creates a `SipHasher` that is keyed off the provided keys. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] + #[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" + )] pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher { - SipHasher(SipHasher24 { - hasher: Hasher::new_with_keys(key0, key1) - }) + SipHasher(SipHasher24 { hasher: Hasher::new_with_keys(key0, key1) }) } } @@ -159,8 +173,10 @@ impl SipHasher13 { /// Creates a new `SipHasher13` with the two initial keys set to 0. #[inline] #[unstable(feature = "hashmap_internals", issue = "0")] - #[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] + #[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" + )] pub fn new() -> SipHasher13 { SipHasher13::new_with_keys(0, 0) } @@ -168,12 +184,12 @@ impl SipHasher13 { /// Creates a `SipHasher13` that is keyed off the provided keys. #[inline] #[unstable(feature = "hashmap_internals", issue = "0")] - #[rustc_deprecated(since = "1.13.0", - reason = "use `std::collections::hash_map::DefaultHasher` instead")] + #[rustc_deprecated( + since = "1.13.0", + reason = "use `std::collections::hash_map::DefaultHasher` instead" + )] pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 { - SipHasher13 { - hasher: Hasher::new_with_keys(key0, key1) - } + SipHasher13 { hasher: Hasher::new_with_keys(key0, key1) } } } @@ -184,12 +200,7 @@ impl Hasher { k0: key0, k1: key1, length: 0, - state: State { - v0: 0, - v1: 0, - v2: 0, - v3: 0, - }, + state: State { v0: 0, v1: 0, v2: 0, v3: 0 }, tail: 0, ntail: 0, _marker: PhantomData, @@ -294,7 +305,7 @@ impl super::Hasher for Hasher { self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << 8 * self.ntail; if length < needed { self.ntail += length; - return + return; } else { self.state.v3 ^= self.tail; S::c_rounds(&mut self.state); diff --git a/src/libcore/iter/adapters/flatten.rs b/src/libcore/iter/adapters/flatten.rs index a45173f614ded..0a7a9f26f8912 100644 --- a/src/libcore/iter/adapters/flatten.rs +++ b/src/libcore/iter/adapters/flatten.rs @@ -1,7 +1,7 @@ use crate::fmt; use crate::ops::Try; -use super::super::{Iterator, DoubleEndedIterator, FusedIterator}; +use super::super::{DoubleEndedIterator, FusedIterator, Iterator}; use super::Map; /// An iterator that maps each element to an iterator, and yields the elements @@ -15,7 +15,7 @@ use super::Map; #[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] pub struct FlatMap { - inner: FlattenCompat, ::IntoIter> + inner: FlattenCompat, ::IntoIter>, } impl U> FlatMap { pub(in super::super) fn new(iter: I, f: F) -> FlatMap { @@ -28,7 +28,9 @@ impl Clone for FlatMap where U: Clone + IntoIterator, { - fn clone(&self) -> Self { FlatMap { inner: self.inner.clone() } } + fn clone(&self) -> Self { + FlatMap { inner: self.inner.clone() } + } } #[stable(feature = "core_impl_debug", since = "1.9.0")] @@ -43,26 +45,35 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for FlatMap - where F: FnMut(I::Item) -> U, +where + F: FnMut(I::Item) -> U, { type Item = U::Item; #[inline] - fn next(&mut self) -> Option { self.inner.next() } + fn next(&mut self) -> Option { + self.inner.next() + } #[inline] - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } #[inline] - fn try_fold(&mut self, init: Acc, fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_fold(&mut self, init: Acc, fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { self.inner.try_fold(init, fold) } #[inline] fn fold(self, init: Acc, fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { self.inner.fold(init, fold) } @@ -75,18 +86,24 @@ where U: IntoIterator, { #[inline] - fn next_back(&mut self) -> Option { self.inner.next_back() } + fn next_back(&mut self) -> Option { + self.inner.next_back() + } #[inline] - fn try_rfold(&mut self, init: Acc, fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_rfold(&mut self, init: Acc, fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { self.inner.try_rfold(init, fold) } #[inline] fn rfold(self, init: Acc, fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { self.inner.rfold(init, fold) } @@ -94,7 +111,12 @@ where #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for FlatMap - where I: FusedIterator, U: IntoIterator, F: FnMut(I::Item) -> U {} +where + I: FusedIterator, + U: IntoIterator, + F: FnMut(I::Item) -> U, +{ +} /// An iterator that flattens one level of nesting in an iterator of things /// that can be turned into iterators. @@ -133,7 +155,9 @@ where I: Clone + Iterator>, U: Clone + Iterator, { - fn clone(&self) -> Self { Flatten { inner: self.inner.clone() } } + fn clone(&self) -> Self { + Flatten { inner: self.inner.clone() } + } } #[stable(feature = "iterator_flatten", since = "1.29.0")] @@ -145,21 +169,29 @@ where type Item = U::Item; #[inline] - fn next(&mut self) -> Option { self.inner.next() } + fn next(&mut self) -> Option { + self.inner.next() + } #[inline] - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } #[inline] - fn try_fold(&mut self, init: Acc, fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_fold(&mut self, init: Acc, fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { self.inner.try_fold(init, fold) } #[inline] fn fold(self, init: Acc, fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { self.inner.fold(init, fold) } @@ -172,18 +204,24 @@ where U: DoubleEndedIterator, { #[inline] - fn next_back(&mut self) -> Option { self.inner.next_back() } + fn next_back(&mut self) -> Option { + self.inner.next_back() + } #[inline] - fn try_rfold(&mut self, init: Acc, fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_rfold(&mut self, init: Acc, fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { self.inner.try_rfold(init, fold) } #[inline] fn rfold(self, init: Acc, fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { self.inner.rfold(init, fold) } @@ -194,7 +232,8 @@ impl FusedIterator for Flatten where I: FusedIterator>, U: Iterator, -{} +{ +} /// Real logic of both `Flatten` and `FlatMap` which simply delegate to /// this type. @@ -222,7 +261,9 @@ where fn next(&mut self) -> Option { loop { if let Some(ref mut inner) = self.frontiter { - if let elt@Some(_) = inner.next() { return elt } + if let elt @ Some(_) = inner.next() { + return elt; + } } match self.iter.next() { None => return self.backiter.as_mut()?.next(), @@ -238,13 +279,16 @@ where let lo = flo.saturating_add(blo); match (self.iter.size_hint(), fhi, bhi) { ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(b)), - _ => (lo, None) + _ => (lo, None), } } #[inline] - fn try_fold(&mut self, mut init: Acc, mut fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_fold(&mut self, mut init: Acc, mut fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { #[inline] fn flatten<'a, T: IntoIterator, Acc, R: Try>( @@ -277,7 +321,8 @@ where #[inline] fn fold(self, init: Acc, ref mut fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { #[inline] fn flatten( @@ -286,7 +331,8 @@ where move |acc, iter| iter.fold(acc, &mut *fold) } - self.frontiter.into_iter() + self.frontiter + .into_iter() .chain(self.iter.map(IntoIterator::into_iter)) .chain(self.backiter) .fold(init, flatten(fold)) @@ -302,7 +348,9 @@ where fn next_back(&mut self) -> Option { loop { if let Some(ref mut inner) = self.backiter { - if let elt@Some(_) = inner.next_back() { return elt } + if let elt @ Some(_) = inner.next_back() { + return elt; + } } match self.iter.next_back() { None => return self.frontiter.as_mut()?.next_back(), @@ -312,14 +360,18 @@ where } #[inline] - fn try_rfold(&mut self, mut init: Acc, mut fold: Fold) -> R where - Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try + fn try_rfold(&mut self, mut init: Acc, mut fold: Fold) -> R + where + Self: Sized, + Fold: FnMut(Acc, Self::Item) -> R, + R: Try, { #[inline] fn flatten<'a, T: IntoIterator, Acc, R: Try>( backiter: &'a mut Option, fold: &'a mut impl FnMut(Acc, T::Item) -> R, - ) -> impl FnMut(Acc, T) -> R + 'a where + ) -> impl FnMut(Acc, T) -> R + 'a + where T::IntoIter: DoubleEndedIterator, { move |acc, x| { @@ -348,7 +400,8 @@ where #[inline] fn rfold(self, init: Acc, ref mut fold: Fold) -> Acc - where Fold: FnMut(Acc, Self::Item) -> Acc, + where + Fold: FnMut(Acc, Self::Item) -> Acc, { #[inline] fn flatten( @@ -357,7 +410,8 @@ where move |acc, iter| iter.rfold(acc, &mut *fold) } - self.frontiter.into_iter() + self.frontiter + .into_iter() .chain(self.iter.map(IntoIterator::into_iter)) .chain(self.backiter) .rfold(init, flatten(fold)) diff --git a/src/libcore/iter/sources.rs b/src/libcore/iter/sources.rs index 183176005ede9..ffac7d4e99538 100644 --- a/src/libcore/iter/sources.rs +++ b/src/libcore/iter/sources.rs @@ -12,7 +12,7 @@ use super::{FusedIterator, TrustedLen}; #[derive(Clone, Debug)] #[stable(feature = "rust1", since = "1.0.0")] pub struct Repeat { - element: A + element: A, } #[stable(feature = "rust1", since = "1.0.0")] @@ -20,15 +20,21 @@ impl Iterator for Repeat { type Item = A; #[inline] - fn next(&mut self) -> Option { Some(self.element.clone()) } + fn next(&mut self) -> Option { + Some(self.element.clone()) + } #[inline] - fn size_hint(&self) -> (usize, Option) { (usize::MAX, None) } + fn size_hint(&self) -> (usize, Option) { + (usize::MAX, None) + } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for Repeat { #[inline] - fn next_back(&mut self) -> Option { Some(self.element.clone()) } + fn next_back(&mut self) -> Option { + Some(self.element.clone()) + } } #[stable(feature = "fused", since = "1.26.0")] @@ -91,7 +97,7 @@ unsafe impl TrustedLen for Repeat {} #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn repeat(elt: T) -> Repeat { - Repeat{element: elt} + Repeat { element: elt } } /// An iterator that repeats elements of type `A` endlessly by @@ -104,7 +110,7 @@ pub fn repeat(elt: T) -> Repeat { #[derive(Copy, Clone, Debug)] #[stable(feature = "iterator_repeat_with", since = "1.28.0")] pub struct RepeatWith { - repeater: F + repeater: F, } #[stable(feature = "iterator_repeat_with", since = "1.28.0")] @@ -112,10 +118,14 @@ impl A> Iterator for RepeatWith { type Item = A; #[inline] - fn next(&mut self) -> Option { Some((self.repeater)()) } + fn next(&mut self) -> Option { + Some((self.repeater)()) + } #[inline] - fn size_hint(&self) -> (usize, Option) { (usize::MAX, None) } + fn size_hint(&self) -> (usize, Option) { + (usize::MAX, None) + } } #[stable(feature = "iterator_repeat_with", since = "1.28.0")] @@ -213,7 +223,7 @@ impl Iterator for Empty { None } - fn size_hint(&self) -> (usize, Option){ + fn size_hint(&self) -> (usize, Option) { (0, Some(0)) } } @@ -283,7 +293,7 @@ pub const fn empty() -> Empty { #[derive(Clone, Debug)] #[stable(feature = "iter_once", since = "1.2.0")] pub struct Once { - inner: crate::option::IntoIter + inner: crate::option::IntoIter, } #[stable(feature = "iter_once", since = "1.2.0")] @@ -530,7 +540,8 @@ pub fn once_with A>(gen: F) -> OnceWith { #[inline] #[stable(feature = "iter_from_fn", since = "1.34.0")] pub fn from_fn(f: F) -> FromFn - where F: FnMut() -> Option +where + F: FnMut() -> Option, { FromFn(f) } @@ -547,7 +558,8 @@ pub struct FromFn(F); #[stable(feature = "iter_from_fn", since = "1.34.0")] impl Iterator for FromFn - where F: FnMut() -> Option +where + F: FnMut() -> Option, { type Item = T; @@ -577,15 +589,13 @@ impl fmt::Debug for FromFn { /// ``` #[stable(feature = "iter_successors", since = "1.34.0")] pub fn successors(first: Option, succ: F) -> Successors - where F: FnMut(&T) -> Option +where + F: FnMut(&T) -> Option, { // If this function returned `impl Iterator` // it could be based on `unfold` and not need a dedicated type. // However having a named `Successors` type allows it to be `Clone` when `T` and `F` are. - Successors { - next: first, - succ, - } + Successors { next: first, succ } } /// An new iterator where each successive item is computed based on the preceding one. @@ -603,7 +613,8 @@ pub struct Successors { #[stable(feature = "iter_successors", since = "1.34.0")] impl Iterator for Successors - where F: FnMut(&T) -> Option +where + F: FnMut(&T) -> Option, { type Item = T; @@ -616,24 +627,16 @@ impl Iterator for Successors #[inline] fn size_hint(&self) -> (usize, Option) { - if self.next.is_some() { - (1, None) - } else { - (0, Some(0)) - } + if self.next.is_some() { (1, None) } else { (0, Some(0)) } } } #[stable(feature = "iter_successors", since = "1.34.0")] -impl FusedIterator for Successors - where F: FnMut(&T) -> Option -{} +impl FusedIterator for Successors where F: FnMut(&T) -> Option {} #[stable(feature = "iter_successors", since = "1.34.0")] impl fmt::Debug for Successors { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("Successors") - .field("next", &self.next) - .finish() + f.debug_struct("Successors").field("next", &self.next).finish() } } diff --git a/src/libcore/iter/traits/accum.rs b/src/libcore/iter/traits/accum.rs index 818f03303298f..65af671ddf204 100644 --- a/src/libcore/iter/traits/accum.rs +++ b/src/libcore/iter/traits/accum.rs @@ -1,6 +1,6 @@ -use crate::ops::{Mul, Add}; -use crate::num::Wrapping; use crate::iter; +use crate::num::Wrapping; +use crate::ops::{Add, Mul}; /// Trait to represent types that can be created by summing up an iterator. /// @@ -17,7 +17,7 @@ pub trait Sum: Sized { /// Method which takes an iterator and generates `Self` from the elements by /// "summing up" the items. #[stable(feature = "iter_arith_traits", since = "1.12.0")] - fn sum>(iter: I) -> Self; + fn sum>(iter: I) -> Self; } /// Trait to represent types that can be created by multiplying elements of an @@ -36,7 +36,7 @@ pub trait Product: Sized { /// Method which takes an iterator and generates `Self` from the elements by /// multiplying the items. #[stable(feature = "iter_arith_traits", since = "1.12.0")] - fn product>(iter: I) -> Self; + fn product>(iter: I) -> Self; } // N.B., explicitly use Add and Mul here to inherit overflow checks @@ -115,9 +115,10 @@ macro_rules! float_sum_product { integer_sum_product! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize } float_sum_product! { f32 f64 } -#[stable(feature = "iter_arith_traits_result", since="1.16.0")] +#[stable(feature = "iter_arith_traits_result", since = "1.16.0")] impl Sum> for Result - where T: Sum, +where + T: Sum, { /// Takes each element in the `Iterator`: if it is an `Err`, no further /// elements are taken, and the `Err` is returned. Should no `Err` occur, @@ -137,21 +138,24 @@ impl Sum> for Result /// assert_eq!(res, Ok(3)); /// ``` fn sum(iter: I) -> Result - where I: Iterator>, + where + I: Iterator>, { iter::process_results(iter, |i| i.sum()) } } -#[stable(feature = "iter_arith_traits_result", since="1.16.0")] +#[stable(feature = "iter_arith_traits_result", since = "1.16.0")] impl Product> for Result - where T: Product, +where + T: Product, { /// Takes each element in the `Iterator`: if it is an `Err`, no further /// elements are taken, and the `Err` is returned. Should no `Err` occur, /// the product of all elements is returned. fn product(iter: I) -> Result - where I: Iterator>, + where + I: Iterator>, { iter::process_results(iter, |i| i.product()) } diff --git a/src/libcore/iter/traits/double_ended.rs b/src/libcore/iter/traits/double_ended.rs index 006b243ca42aa..104724d9fb63a 100644 --- a/src/libcore/iter/traits/double_ended.rs +++ b/src/libcore/iter/traits/double_ended.rs @@ -1,5 +1,5 @@ -use crate::ops::Try; use crate::iter::LoopState; +use crate::ops::Try; /// An iterator able to yield elements from both ends. /// @@ -113,7 +113,9 @@ pub trait DoubleEndedIterator: Iterator { #[stable(feature = "iter_nth_back", since = "1.37.0")] fn nth_back(&mut self, mut n: usize) -> Option { for x in self.rev() { - if n == 0 { return Some(x) } + if n == 0 { + return Some(x); + } n -= 1; } None @@ -157,7 +159,7 @@ pub trait DoubleEndedIterator: Iterator { where Self: Sized, F: FnMut(B, Self::Item) -> R, - R: Try + R: Try, { let mut accum = init; while let Some(x) = self.next_back() { @@ -279,7 +281,7 @@ pub trait DoubleEndedIterator: Iterator { fn rfind

{ // for other reasons, though, so we just need to take care not to allow such // impls to land in std. #[stable(feature = "pin", since = "1.33.0")] -impl CoerceUnsized> for Pin

-where - P: CoerceUnsized, -{} +impl CoerceUnsized> for Pin

where P: CoerceUnsized {} #[stable(feature = "pin", since = "1.33.0")] -impl DispatchFromDyn> for Pin

-where - P: DispatchFromDyn, -{} +impl DispatchFromDyn> for Pin

where P: DispatchFromDyn {} diff --git a/src/libcore/prelude/v1.rs b/src/libcore/prelude/v1.rs index 7cc279a9ef2ec..66b5a90b77b91 100644 --- a/src/libcore/prelude/v1.rs +++ b/src/libcore/prelude/v1.rs @@ -25,25 +25,25 @@ pub use crate::mem::drop; pub use crate::clone::Clone; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::cmp::{PartialEq, PartialOrd, Eq, Ord}; +pub use crate::cmp::{Eq, Ord, PartialEq, PartialOrd}; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::convert::{AsRef, AsMut, Into, From}; +pub use crate::convert::{AsMut, AsRef, From, Into}; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use crate::default::Default; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::iter::{Iterator, Extend, IntoIterator}; +pub use crate::iter::{DoubleEndedIterator, ExactSizeIterator}; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::iter::{DoubleEndedIterator, ExactSizeIterator}; +pub use crate::iter::{Extend, IntoIterator, Iterator}; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::option::Option::{self, Some, None}; +pub use crate::option::Option::{self, None, Some}; #[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] -pub use crate::result::Result::{self, Ok, Err}; +pub use crate::result::Result::{self, Err, Ok}; // Re-exported built-in macros #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] @@ -56,37 +56,14 @@ pub use crate::hash::macros::Hash; #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[doc(no_inline)] pub use crate::{ - asm, - assert, - cfg, - column, - compile_error, - concat, - concat_idents, - env, - file, - format_args, - format_args_nl, - global_asm, - include, - include_bytes, - include_str, - line, - log_syntax, - module_path, - option_env, - stringify, - trace_macros, + asm, assert, cfg, column, compile_error, concat, concat_idents, env, file, format_args, + format_args_nl, global_asm, include, include_bytes, include_str, line, log_syntax, module_path, + option_env, stringify, trace_macros, }; #[stable(feature = "builtin_macro_prelude", since = "1.38.0")] #[allow(deprecated)] #[doc(no_inline)] pub use crate::macros::builtin::{ - RustcDecodable, - RustcEncodable, - bench, - global_allocator, - test, - test_case, + bench, global_allocator, test, test_case, RustcDecodable, RustcEncodable, }; diff --git a/src/libcore/ptr/non_null.rs b/src/libcore/ptr/non_null.rs index 7599991f0f15a..a121389bef3c9 100644 --- a/src/libcore/ptr/non_null.rs +++ b/src/libcore/ptr/non_null.rs @@ -1,11 +1,11 @@ +use crate::cmp::Ordering; use crate::convert::From; -use crate::ops::{CoerceUnsized, DispatchFromDyn}; use crate::fmt; use crate::hash; use crate::marker::Unsize; use crate::mem; +use crate::ops::{CoerceUnsized, DispatchFromDyn}; use crate::ptr::Unique; -use crate::cmp::Ordering; // ignore-tidy-undocumented-unsafe @@ -48,12 +48,12 @@ pub struct NonNull { /// `NonNull` pointers are not `Send` because the data they reference may be aliased. // N.B., this impl is unnecessary, but should provide better error messages. #[stable(feature = "nonnull", since = "1.25.0")] -impl !Send for NonNull { } +impl !Send for NonNull {} /// `NonNull` pointers are not `Sync` because the data they reference may be aliased. // N.B., this impl is unnecessary, but should provide better error messages. #[stable(feature = "nonnull", since = "1.25.0")] -impl !Sync for NonNull { } +impl !Sync for NonNull {} impl NonNull { /// Creates a new `NonNull` that is dangling, but well-aligned. @@ -91,11 +91,7 @@ impl NonNull { #[stable(feature = "nonnull", since = "1.25.0")] #[inline] pub fn new(ptr: *mut T) -> Option { - if !ptr.is_null() { - Some(unsafe { Self::new_unchecked(ptr) }) - } else { - None - } + if !ptr.is_null() { Some(unsafe { Self::new_unchecked(ptr) }) } else { None } } /// Acquires the underlying `*mut` pointer. @@ -131,9 +127,7 @@ impl NonNull { #[stable(feature = "nonnull_cast", since = "1.27.0")] #[inline] pub const fn cast(self) -> NonNull { - unsafe { - NonNull::new_unchecked(self.as_ptr() as *mut U) - } + unsafe { NonNull::new_unchecked(self.as_ptr() as *mut U) } } } @@ -146,13 +140,13 @@ impl Clone for NonNull { } #[stable(feature = "nonnull", since = "1.25.0")] -impl Copy for NonNull { } +impl Copy for NonNull {} #[unstable(feature = "coerce_unsized", issue = "27732")] -impl CoerceUnsized> for NonNull where T: Unsize { } +impl CoerceUnsized> for NonNull where T: Unsize {} #[unstable(feature = "dispatch_from_dyn", issue = "0")] -impl DispatchFromDyn> for NonNull where T: Unsize { } +impl DispatchFromDyn> for NonNull where T: Unsize {} #[stable(feature = "nonnull", since = "1.25.0")] impl fmt::Debug for NonNull { diff --git a/src/libcore/ptr/unique.rs b/src/libcore/ptr/unique.rs index 11a3aed1ab41b..546b7c9d777f5 100644 --- a/src/libcore/ptr/unique.rs +++ b/src/libcore/ptr/unique.rs @@ -1,8 +1,8 @@ use crate::convert::From; -use crate::ops::{CoerceUnsized, DispatchFromDyn}; use crate::fmt; use crate::marker::{PhantomData, Unsize}; use crate::mem; +use crate::ops::{CoerceUnsized, DispatchFromDyn}; use crate::ptr::NonNull; // ignore-tidy-undocumented-unsafe @@ -27,9 +27,12 @@ use crate::ptr::NonNull; /// /// Unlike `*mut T`, `Unique` is covariant over `T`. This should always be correct /// for any type which upholds Unique's aliasing requirements. -#[unstable(feature = "ptr_internals", issue = "0", - reason = "use `NonNull` instead and consider `PhantomData` \ - (if you also use `#[may_dangle]`), `Send`, and/or `Sync`")] +#[unstable( + feature = "ptr_internals", + issue = "0", + reason = "use `NonNull` instead and consider `PhantomData` \ + (if you also use `#[may_dangle]`), `Send`, and/or `Sync`" +)] #[doc(hidden)] #[repr(transparent)] #[rustc_layout_scalar_valid_range_start(1)] @@ -48,14 +51,14 @@ pub struct Unique { /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. #[unstable(feature = "ptr_internals", issue = "0")] -unsafe impl Send for Unique { } +unsafe impl Send for Unique {} /// `Unique` pointers are `Sync` if `T` is `Sync` because the data they /// reference is unaliased. Note that this aliasing invariant is /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. #[unstable(feature = "ptr_internals", issue = "0")] -unsafe impl Sync for Unique { } +unsafe impl Sync for Unique {} #[unstable(feature = "ptr_internals", issue = "0")] impl Unique { @@ -71,9 +74,7 @@ impl Unique { // FIXME: rename to dangling() to match NonNull? #[inline] pub const fn empty() -> Self { - unsafe { - Unique::new_unchecked(mem::align_of::() as *mut T) - } + unsafe { Unique::new_unchecked(mem::align_of::() as *mut T) } } } @@ -128,9 +129,7 @@ impl Unique { /// Casts to a pointer of another type. #[inline] pub const fn cast(self) -> Unique { - unsafe { - Unique::new_unchecked(self.as_ptr() as *mut U) - } + unsafe { Unique::new_unchecked(self.as_ptr() as *mut U) } } } @@ -143,13 +142,13 @@ impl Clone for Unique { } #[unstable(feature = "ptr_internals", issue = "0")] -impl Copy for Unique { } +impl Copy for Unique {} #[unstable(feature = "ptr_internals", issue = "0")] -impl CoerceUnsized> for Unique where T: Unsize { } +impl CoerceUnsized> for Unique where T: Unsize {} #[unstable(feature = "ptr_internals", issue = "0")] -impl DispatchFromDyn> for Unique where T: Unsize { } +impl DispatchFromDyn> for Unique where T: Unsize {} #[unstable(feature = "ptr_internals", issue = "0")] impl fmt::Debug for Unique { diff --git a/src/libcore/slice/sort.rs b/src/libcore/slice/sort.rs index a719a51b61605..019832e16f89c 100644 --- a/src/libcore/slice/sort.rs +++ b/src/libcore/slice/sort.rs @@ -20,13 +20,16 @@ struct CopyOnDrop { impl Drop for CopyOnDrop { fn drop(&mut self) { - unsafe { ptr::copy_nonoverlapping(self.src, self.dest, 1); } + unsafe { + ptr::copy_nonoverlapping(self.src, self.dest, 1); + } } } /// Shifts the first element to the right until it encounters a greater or equal element. fn shift_head(v: &mut [T], is_less: &mut F) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { let len = v.len(); unsafe { @@ -36,10 +39,7 @@ fn shift_head(v: &mut [T], is_less: &mut F) // operation panics, `hole` will get dropped and automatically write the element back // into the slice. let mut tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(0))); - let mut hole = CopyOnDrop { - src: &mut *tmp, - dest: v.get_unchecked_mut(1), - }; + let mut hole = CopyOnDrop { src: &mut *tmp, dest: v.get_unchecked_mut(1) }; ptr::copy_nonoverlapping(v.get_unchecked(1), v.get_unchecked_mut(0), 1); for i in 2..len { @@ -58,7 +58,8 @@ fn shift_head(v: &mut [T], is_less: &mut F) /// Shifts the last element to the left until it encounters a smaller or equal element. fn shift_tail(v: &mut [T], is_less: &mut F) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { let len = v.len(); unsafe { @@ -68,13 +69,10 @@ fn shift_tail(v: &mut [T], is_less: &mut F) // operation panics, `hole` will get dropped and automatically write the element back // into the slice. let mut tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(len - 1))); - let mut hole = CopyOnDrop { - src: &mut *tmp, - dest: v.get_unchecked_mut(len - 2), - }; + let mut hole = CopyOnDrop { src: &mut *tmp, dest: v.get_unchecked_mut(len - 2) }; ptr::copy_nonoverlapping(v.get_unchecked(len - 2), v.get_unchecked_mut(len - 1), 1); - for i in (0..len-2).rev() { + for i in (0..len - 2).rev() { if !is_less(&*tmp, v.get_unchecked(i)) { break; } @@ -93,7 +91,8 @@ fn shift_tail(v: &mut [T], is_less: &mut F) /// Returns `true` if the slice is sorted at the end. This function is `O(n)` worst-case. #[cold] fn partial_insertion_sort(v: &mut [T], is_less: &mut F) -> bool - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Maximum number of adjacent out-of-order pairs that will get shifted. const MAX_STEPS: usize = 5; @@ -136,17 +135,19 @@ fn partial_insertion_sort(v: &mut [T], is_less: &mut F) -> bool /// Sorts a slice using insertion sort, which is `O(n^2)` worst-case. fn insertion_sort(v: &mut [T], is_less: &mut F) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { for i in 1..v.len() { - shift_tail(&mut v[..i+1], is_less); + shift_tail(&mut v[..i + 1], is_less); } } /// Sorts `v` using heapsort, which guarantees `O(n log n)` worst-case. #[cold] pub fn heapsort(v: &mut [T], is_less: &mut F) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // This binary heap respects the invariant `parent >= child`. let mut sift_down = |v: &mut [T], mut node| { @@ -156,11 +157,8 @@ pub fn heapsort(v: &mut [T], is_less: &mut F) let right = 2 * node + 2; // Choose the greater child. - let greater = if right < v.len() && is_less(&v[left], &v[right]) { - right - } else { - left - }; + let greater = + if right < v.len() && is_less(&v[left], &v[right]) { right } else { left }; // Stop if the invariant holds at `node`. if greater >= v.len() || !is_less(&v[node], &v[greater]) { @@ -174,12 +172,12 @@ pub fn heapsort(v: &mut [T], is_less: &mut F) }; // Build the heap in linear time. - for i in (0 .. v.len() / 2).rev() { + for i in (0..v.len() / 2).rev() { sift_down(v, i); } // Pop maximal elements from the heap. - for i in (1 .. v.len()).rev() { + for i in (1..v.len()).rev() { v.swap(0, i); sift_down(&mut v[..i], 0); } @@ -195,7 +193,8 @@ pub fn heapsort(v: &mut [T], is_less: &mut F) /// /// [pdf]: http://drops.dagstuhl.de/opus/volltexte/2016/6389/pdf/LIPIcs-ESA-2016-38.pdf fn partition_in_blocks(v: &mut [T], pivot: &T, is_less: &mut F) -> usize - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Number of elements in a typical block. const BLOCK: usize = 128; @@ -298,8 +297,16 @@ fn partition_in_blocks(v: &mut [T], pivot: &T, is_less: &mut F) -> usize let count = cmp::min(width(start_l, end_l), width(start_r, end_r)); if count > 0 { - macro_rules! left { () => { l.offset(*start_l as isize) } } - macro_rules! right { () => { r.offset(-(*start_r as isize) - 1) } } + macro_rules! left { + () => { + l.offset(*start_l as isize) + }; + } + macro_rules! right { + () => { + r.offset(-(*start_r as isize) - 1) + }; + } // Instead of swapping one pair at the time, it is more efficient to perform a cyclic // permutation. This is not strictly equivalent to swapping, but produces a similar @@ -379,7 +386,8 @@ fn partition_in_blocks(v: &mut [T], pivot: &T, is_less: &mut F) -> usize /// 1. Number of elements smaller than `v[pivot]`. /// 2. True if `v` was already partitioned. fn partition(v: &mut [T], pivot: usize, is_less: &mut F) -> (usize, bool) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { let (mid, was_partitioned) = { // Place the pivot at the beginning of slice. @@ -390,10 +398,7 @@ fn partition(v: &mut [T], pivot: usize, is_less: &mut F) -> (usize, bool) // Read the pivot into a stack-allocated variable for efficiency. If a following comparison // operation panics, the pivot will be automatically written back into the slice. let mut tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) }); - let _pivot_guard = CopyOnDrop { - src: &mut *tmp, - dest: pivot, - }; + let _pivot_guard = CopyOnDrop { src: &mut *tmp, dest: pivot }; let pivot = &*tmp; // Find the first pair of out-of-order elements. @@ -429,7 +434,8 @@ fn partition(v: &mut [T], pivot: usize, is_less: &mut F) -> (usize, bool) /// Returns the number of elements equal to the pivot. It is assumed that `v` does not contain /// elements smaller than the pivot. fn partition_equal(v: &mut [T], pivot: usize, is_less: &mut F) -> usize - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Place the pivot at the beginning of slice. v.swap(0, pivot); @@ -439,10 +445,7 @@ fn partition_equal(v: &mut [T], pivot: usize, is_less: &mut F) -> usize // Read the pivot into a stack-allocated variable for efficiency. If a following comparison // operation panics, the pivot will be automatically written back into the slice. let mut tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) }); - let _pivot_guard = CopyOnDrop { - src: &mut *tmp, - dest: pivot, - }; + let _pivot_guard = CopyOnDrop { src: &mut *tmp, dest: pivot }; let pivot = &*tmp; // Now partition the slice. @@ -528,7 +531,8 @@ fn break_patterns(v: &mut [T]) { /// /// Elements in `v` might be reordered in the process. fn choose_pivot(v: &mut [T], is_less: &mut F) -> (usize, bool) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Minimum length to choose the median-of-medians method. // Shorter slices use the simple median-of-three method. @@ -596,7 +600,8 @@ fn choose_pivot(v: &mut [T], is_less: &mut F) -> (usize, bool) /// `limit` is the number of allowed imbalanced partitions before switching to `heapsort`. If zero, /// this function will immediately switch to heapsort. fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &mut F, mut pred: Option<&'a T>, mut limit: usize) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Slices of up to this length get sorted using insertion sort. const MAX_INSERTION: usize = 20; @@ -650,7 +655,7 @@ fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &mut F, mut pred: Option<&'a T let mid = partition_equal(v, pivot, is_less); // Continue sorting elements greater than the pivot. - v = &mut {v}[mid..]; + v = &mut { v }[mid..]; continue; } } @@ -661,7 +666,7 @@ fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &mut F, mut pred: Option<&'a T was_partitioned = was_p; // Split the slice into `left`, `pivot`, and `right`. - let (left, right) = {v}.split_at_mut(mid); + let (left, right) = { v }.split_at_mut(mid); let (pivot, right) = right.split_at_mut(1); let pivot = &pivot[0]; @@ -681,7 +686,8 @@ fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &mut F, mut pred: Option<&'a T /// Sorts `v` using pattern-defeating quicksort, which is `O(n log n)` worst-case. pub fn quicksort(v: &mut [T], mut is_less: F) - where F: FnMut(&T, &T) -> bool +where + F: FnMut(&T, &T) -> bool, { // Sorting has no meaningful behavior on zero-sized types. if mem::size_of::() == 0 { @@ -694,8 +700,13 @@ pub fn quicksort(v: &mut [T], mut is_less: F) recurse(v, &mut is_less, None, limit); } -fn partition_at_index_loop<'a, T, F>( mut v: &'a mut [T], mut index: usize, is_less: &mut F - , mut pred: Option<&'a T>) where F: FnMut(&T, &T) -> bool +fn partition_at_index_loop<'a, T, F>( + mut v: &'a mut [T], + mut index: usize, + is_less: &mut F, + mut pred: Option<&'a T>, +) where + F: FnMut(&T, &T) -> bool, { loop { // For slices of up to this length it's probably faster to simply sort them. @@ -731,7 +742,7 @@ fn partition_at_index_loop<'a, T, F>( mut v: &'a mut [T], mut index: usize, is_l let (mid, _) = partition(v, pivot, is_less); // Split the slice into `left`, `pivot`, and `right`. - let (left, right) = {v}.split_at_mut(mid); + let (left, right) = { v }.split_at_mut(mid); let (pivot, right) = right.split_at_mut(1); let pivot = &pivot[0]; @@ -749,11 +760,16 @@ fn partition_at_index_loop<'a, T, F>( mut v: &'a mut [T], mut index: usize, is_l } } -pub fn partition_at_index(v: &mut [T], index: usize, mut is_less: F) - -> (&mut [T], &mut T, &mut [T]) where F: FnMut(&T, &T) -> bool +pub fn partition_at_index( + v: &mut [T], + index: usize, + mut is_less: F, +) -> (&mut [T], &mut T, &mut [T]) +where + F: FnMut(&T, &T) -> bool, { - use cmp::Ordering::Less; use cmp::Ordering::Greater; + use cmp::Ordering::Less; if index >= v.len() { panic!("partition_at_index index {} greater than length of slice {}", index, v.len()); @@ -764,14 +780,20 @@ pub fn partition_at_index(v: &mut [T], index: usize, mut is_less: F) } else if index == v.len() - 1 { // Find max element and place it in the last position of the array. We're free to use // `unwrap()` here because we know v must not be empty. - let (max_index, _) = v.iter().enumerate().max_by( - |&(_, x), &(_, y)| if is_less(x, y) { Less } else { Greater }).unwrap(); + let (max_index, _) = v + .iter() + .enumerate() + .max_by(|&(_, x), &(_, y)| if is_less(x, y) { Less } else { Greater }) + .unwrap(); v.swap(max_index, index); } else if index == 0 { // Find min element and place it in the first position of the array. We're free to use // `unwrap()` here because we know v must not be empty. - let (min_index, _) = v.iter().enumerate().min_by( - |&(_, x), &(_, y)| if is_less(x, y) { Less } else { Greater }).unwrap(); + let (min_index, _) = v + .iter() + .enumerate() + .min_by(|&(_, x), &(_, y)| if is_less(x, y) { Less } else { Greater }) + .unwrap(); v.swap(min_index, index); } else { partition_at_index_loop(v, index, &mut is_less, None); diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs index ef090928392cd..27760749c1d4b 100644 --- a/src/libcore/task/mod.rs +++ b/src/libcore/task/mod.rs @@ -8,4 +8,4 @@ pub use self::poll::Poll; mod wake; #[stable(feature = "futures_api", since = "1.36.0")] -pub use self::wake::{Context, Waker, RawWaker, RawWakerVTable}; +pub use self::wake::{Context, RawWaker, RawWakerVTable, Waker}; diff --git a/src/libcore/task/poll.rs b/src/libcore/task/poll.rs index fec17c4d1a4df..d567ae545774e 100644 --- a/src/libcore/task/poll.rs +++ b/src/libcore/task/poll.rs @@ -11,10 +11,7 @@ use crate::result::Result; pub enum Poll { /// Represents that a value is immediately ready. #[stable(feature = "futures_api", since = "1.36.0")] - Ready( - #[stable(feature = "futures_api", since = "1.36.0")] - T - ), + Ready(#[stable(feature = "futures_api", since = "1.36.0")] T), /// Represents that a value is not ready yet. /// @@ -29,7 +26,8 @@ impl Poll { /// Changes the ready value of this `Poll` with the closure provided. #[stable(feature = "futures_api", since = "1.36.0")] pub fn map(self, f: F) -> Poll - where F: FnOnce(T) -> U + where + F: FnOnce(T) -> U, { match self { Poll::Ready(t) => Poll::Ready(f(t)), @@ -59,7 +57,8 @@ impl Poll> { /// Changes the success value of this `Poll` with the closure provided. #[stable(feature = "futures_api", since = "1.36.0")] pub fn map_ok(self, f: F) -> Poll> - where F: FnOnce(T) -> U + where + F: FnOnce(T) -> U, { match self { Poll::Ready(Ok(t)) => Poll::Ready(Ok(f(t))), @@ -71,7 +70,8 @@ impl Poll> { /// Changes the error value of this `Poll` with the closure provided. #[stable(feature = "futures_api", since = "1.36.0")] pub fn map_err(self, f: F) -> Poll> - where F: FnOnce(E) -> U + where + F: FnOnce(E) -> U, { match self { Poll::Ready(Ok(t)) => Poll::Ready(Ok(t)), @@ -85,7 +85,8 @@ impl Poll>> { /// Changes the success value of this `Poll` with the closure provided. #[unstable(feature = "poll_map", issue = "63514")] pub fn map_ok(self, f: F) -> Poll>> - where F: FnOnce(T) -> U + where + F: FnOnce(T) -> U, { match self { Poll::Ready(Some(Ok(t))) => Poll::Ready(Some(Ok(f(t)))), @@ -98,7 +99,8 @@ impl Poll>> { /// Changes the error value of this `Poll` with the closure provided. #[unstable(feature = "poll_map", issue = "63514")] pub fn map_err(self, f: F) -> Poll>> - where F: FnOnce(E) -> U + where + F: FnOnce(E) -> U, { match self { Poll::Ready(Some(Ok(t))) => Poll::Ready(Some(Ok(t))), diff --git a/src/libcore/task/wake.rs b/src/libcore/task/wake.rs index 6f841bd2adf41..0759ff93ea85f 100644 --- a/src/libcore/task/wake.rs +++ b/src/libcore/task/wake.rs @@ -40,10 +40,7 @@ impl RawWaker { #[rustc_promotable] #[stable(feature = "futures_api", since = "1.36.0")] pub const fn new(data: *const (), vtable: &'static RawWakerVTable) -> RawWaker { - RawWaker { - data, - vtable, - } + RawWaker { data, vtable } } } @@ -160,12 +157,7 @@ impl RawWakerVTable { wake_by_ref: unsafe fn(*const ()), drop: unsafe fn(*const ()), ) -> Self { - Self { - clone, - wake, - wake_by_ref, - drop, - } + Self { clone, wake, wake_by_ref, drop } } } @@ -188,10 +180,7 @@ impl<'a> Context<'a> { #[stable(feature = "futures_api", since = "1.36.0")] #[inline] pub fn from_waker(waker: &'a Waker) -> Self { - Context { - waker, - _marker: PhantomData, - } + Context { waker, _marker: PhantomData } } /// Returns a reference to the `Waker` for the current task. @@ -205,9 +194,7 @@ impl<'a> Context<'a> { #[stable(feature = "futures_api", since = "1.36.0")] impl fmt::Debug for Context<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("Context") - .field("waker", &self.waker) - .finish() + f.debug_struct("Context").field("waker", &self.waker).finish() } } @@ -291,9 +278,7 @@ impl Waker { #[inline] #[stable(feature = "futures_api", since = "1.36.0")] pub unsafe fn from_raw(waker: RawWaker) -> Waker { - Waker { - waker, - } + Waker { waker } } } diff --git a/src/libcore/time.rs b/src/libcore/time.rs index 57fc1a7b76075..70ec1e42fd71b 100644 --- a/src/libcore/time.rs +++ b/src/libcore/time.rs @@ -12,9 +12,9 @@ //! assert_eq!(Duration::new(5, 0), Duration::from_secs(5)); //! ``` -use crate::{fmt, u64}; use crate::iter::Sum; -use crate::ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign}; +use crate::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign}; +use crate::{fmt, u64}; const NANOS_PER_SEC: u32 = 1_000_000_000; const NANOS_PER_MILLI: u32 = 1_000_000; @@ -131,8 +131,8 @@ impl Duration { #[stable(feature = "duration", since = "1.3.0")] #[inline] pub fn new(secs: u64, nanos: u32) -> Duration { - let secs = secs.checked_add((nanos / NANOS_PER_SEC) as u64) - .expect("overflow in Duration::new"); + let secs = + secs.checked_add((nanos / NANOS_PER_SEC) as u64).expect("overflow in Duration::new"); let nanos = nanos % NANOS_PER_SEC; Duration { secs, nanos } } @@ -252,7 +252,9 @@ impl Duration { /// [`subsec_nanos`]: #method.subsec_nanos #[stable(feature = "duration", since = "1.3.0")] #[inline] - pub const fn as_secs(&self) -> u64 { self.secs } + pub const fn as_secs(&self) -> u64 { + self.secs + } /// Returns the fractional part of this `Duration`, in whole milliseconds. /// @@ -271,7 +273,9 @@ impl Duration { /// ``` #[stable(feature = "duration_extras", since = "1.27.0")] #[inline] - pub const fn subsec_millis(&self) -> u32 { self.nanos / NANOS_PER_MILLI } + pub const fn subsec_millis(&self) -> u32 { + self.nanos / NANOS_PER_MILLI + } /// Returns the fractional part of this `Duration`, in whole microseconds. /// @@ -290,7 +294,9 @@ impl Duration { /// ``` #[stable(feature = "duration_extras", since = "1.27.0")] #[inline] - pub const fn subsec_micros(&self) -> u32 { self.nanos / NANOS_PER_MICRO } + pub const fn subsec_micros(&self) -> u32 { + self.nanos / NANOS_PER_MICRO + } /// Returns the fractional part of this `Duration`, in nanoseconds. /// @@ -309,7 +315,9 @@ impl Duration { /// ``` #[stable(feature = "duration", since = "1.3.0")] #[inline] - pub const fn subsec_nanos(&self) -> u32 { self.nanos } + pub const fn subsec_nanos(&self) -> u32 { + self.nanos + } /// Returns the total number of whole milliseconds contained by this `Duration`. /// @@ -388,10 +396,7 @@ impl Duration { } } debug_assert!(nanos < NANOS_PER_SEC); - Some(Duration { - secs, - nanos, - }) + Some(Duration { secs, nanos }) } else { None } @@ -455,14 +460,11 @@ impl Duration { let total_nanos = self.nanos as u64 * rhs as u64; let extra_secs = total_nanos / (NANOS_PER_SEC as u64); let nanos = (total_nanos % (NANOS_PER_SEC as u64)) as u32; - if let Some(secs) = self.secs - .checked_mul(rhs as u64) - .and_then(|s| s.checked_add(extra_secs)) { + if let Some(secs) = + self.secs.checked_mul(rhs as u64).and_then(|s| s.checked_add(extra_secs)) + { debug_assert!(nanos < NANOS_PER_SEC); - Some(Duration { - secs, - nanos, - }) + Some(Duration { secs, nanos }) } else { None } @@ -549,9 +551,8 @@ impl Duration { #[stable(feature = "duration_float", since = "1.38.0")] #[inline] pub fn from_secs_f64(secs: f64) -> Duration { - const MAX_NANOS_F64: f64 = - ((u64::MAX as u128 + 1)*(NANOS_PER_SEC as u128)) as f64; - let nanos = secs * (NANOS_PER_SEC as f64); + const MAX_NANOS_F64: f64 = ((u64::MAX as u128 + 1) * (NANOS_PER_SEC as u128)) as f64; + let nanos = secs * (NANOS_PER_SEC as f64); if !nanos.is_finite() { panic!("got non-finite value when converting float to duration"); } @@ -561,7 +562,7 @@ impl Duration { if nanos < 0.0 { panic!("underflow when converting float to duration"); } - let nanos = nanos as u128; + let nanos = nanos as u128; Duration { secs: (nanos / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos % (NANOS_PER_SEC as u128)) as u32, @@ -584,9 +585,8 @@ impl Duration { #[stable(feature = "duration_float", since = "1.38.0")] #[inline] pub fn from_secs_f32(secs: f32) -> Duration { - const MAX_NANOS_F32: f32 = - ((u64::MAX as u128 + 1)*(NANOS_PER_SEC as u128)) as f32; - let nanos = secs * (NANOS_PER_SEC as f32); + const MAX_NANOS_F32: f32 = ((u64::MAX as u128 + 1) * (NANOS_PER_SEC as u128)) as f32; + let nanos = secs * (NANOS_PER_SEC as f32); if !nanos.is_finite() { panic!("got non-finite value when converting float to duration"); } @@ -596,7 +596,7 @@ impl Duration { if nanos < 0.0 { panic!("underflow when converting float to duration"); } - let nanos = nanos as u128; + let nanos = nanos as u128; Duration { secs: (nanos / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos % (NANOS_PER_SEC as u128)) as u32, @@ -799,9 +799,8 @@ macro_rules! sum_durations { let mut total_nanos: u64 = 0; for entry in $iter { - total_secs = total_secs - .checked_add(entry.secs) - .expect("overflow in iter::sum over durations"); + total_secs = + total_secs.checked_add(entry.secs).expect("overflow in iter::sum over durations"); total_nanos = match total_nanos.checked_add(entry.nanos as u64) { Some(n) => n, None => { @@ -816,23 +815,20 @@ macro_rules! sum_durations { .checked_add(total_nanos / NANOS_PER_SEC as u64) .expect("overflow in iter::sum over durations"); total_nanos = total_nanos % NANOS_PER_SEC as u64; - Duration { - secs: total_secs, - nanos: total_nanos as u32, - } + Duration { secs: total_secs, nanos: total_nanos as u32 } }}; } #[stable(feature = "duration_sum", since = "1.16.0")] impl Sum for Duration { - fn sum>(iter: I) -> Duration { + fn sum>(iter: I) -> Duration { sum_durations!(iter) } } #[stable(feature = "duration_sum", since = "1.16.0")] impl<'a> Sum<&'a Duration> for Duration { - fn sum>(iter: I) -> Duration { + fn sum>(iter: I) -> Duration { sum_durations!(iter) } } @@ -922,9 +918,7 @@ impl fmt::Debug for Duration { } else { // SAFETY: We are only writing ASCII digits into the buffer and it was // initialized with '0's, so it contains valid UTF8. - let s = unsafe { - crate::str::from_utf8_unchecked(&buf[..end]) - }; + let s = unsafe { crate::str::from_utf8_unchecked(&buf[..end]) }; // If the user request a precision > 9, we pad '0's at the end. let w = f.precision().unwrap_or(pos); diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index f05780f4a6270..9f8a3a1de4201 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -1,7 +1,7 @@ // See src/libstd/primitive_docs.rs for documentation. -use crate::cmp::*; use crate::cmp::Ordering::*; +use crate::cmp::*; // macro for implementing n-ary tuple functions and operations macro_rules! tuple_impls { diff --git a/src/libcore/unicode/bool_trie.rs b/src/libcore/unicode/bool_trie.rs index 39584d346e4a8..b7fba88a540f9 100644 --- a/src/libcore/unicode/bool_trie.rs +++ b/src/libcore/unicode/bool_trie.rs @@ -19,16 +19,16 @@ /// non-BMP range of most Unicode sets. pub struct BoolTrie { // 0..0x800 (corresponding to 1 and 2 byte utf-8 sequences) - pub r1: [u64; 32], // leaves + pub r1: [u64; 32], // leaves // 0x800..0x10000 (corresponding to 3 byte utf-8 sequences) pub r2: [u8; 992], // first level - pub r3: &'static [u64], // leaves + pub r3: &'static [u64], // leaves // 0x10000..0x110000 (corresponding to 4 byte utf-8 sequences) - pub r4: [u8; 256], // first level - pub r5: &'static [u8], // second level - pub r6: &'static [u64], // leaves + pub r4: [u8; 256], // first level + pub r5: &'static [u8], // second level + pub r6: &'static [u64], // leaves } impl BoolTrie { pub fn lookup(&self, c: char) -> bool { @@ -48,7 +48,7 @@ impl BoolTrie { pub struct SmallBoolTrie { pub(crate) r1: &'static [u8], // first level - pub(crate) r2: &'static [u64], // leaves + pub(crate) r2: &'static [u64], // leaves } impl SmallBoolTrie { diff --git a/src/libcore/unit.rs b/src/libcore/unit.rs index bf01ceb8b2d3e..f41f4a5e94a76 100644 --- a/src/libcore/unit.rs +++ b/src/libcore/unit.rs @@ -15,7 +15,7 @@ use crate::iter::FromIterator; /// ``` #[stable(feature = "unit_from_iter", since = "1.23.0")] impl FromIterator<()> for () { - fn from_iter>(iter: I) -> Self { + fn from_iter>(iter: I) -> Self { iter.into_iter().for_each(|()| {}) } } diff --git a/src/test/ui/macros/unknown-builtin.stderr b/src/test/ui/macros/unknown-builtin.stderr index 33b7b055b4e4b..f1e828a46d8f2 100644 --- a/src/test/ui/macros/unknown-builtin.stderr +++ b/src/test/ui/macros/unknown-builtin.stderr @@ -7,8 +7,8 @@ LL | macro_rules! unknown { () => () } error: cannot find a built-in macro with name `line` --> <::core::macros::builtin::line macros>:1:1 | -LL | () => { } - | ^^^^^^^^^ +LL | () => { } ; + | ^^^^^^^^^^^ error: aborting due to 2 previous errors

(&mut self, predicate: P) -> Option where Self: Sized, - P: FnMut(&Self::Item) -> bool + P: FnMut(&Self::Item) -> bool, { #[inline] fn check( diff --git a/src/libcore/macros/mod.rs b/src/libcore/macros/mod.rs index 7f27e62fb1598..cf460745ffa30 100644 --- a/src/libcore/macros/mod.rs +++ b/src/libcore/macros/mod.rs @@ -337,13 +337,17 @@ macro_rules! matches { #[rustc_deprecated(since = "1.39.0", reason = "use the `?` operator instead")] #[doc(alias = "?")] macro_rules! r#try { - ($expr:expr) => (match $expr { - $crate::result::Result::Ok(val) => val, - $crate::result::Result::Err(err) => { - return $crate::result::Result::Err($crate::convert::From::from(err)) + ($expr:expr) => { + match $expr { + $crate::result::Result::Ok(val) => val, + $crate::result::Result::Err(err) => { + return $crate::result::Result::Err($crate::convert::From::from(err)); + } } - }); - ($expr:expr,) => ($crate::r#try!($expr)); + }; + ($expr:expr,) => { + $crate::r#try!($expr) + }; } /// Writes formatted data into a buffer. @@ -734,8 +738,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! compile_error { - ($msg:expr) => ({ /* compiler built-in */ }); - ($msg:expr,) => ({ /* compiler built-in */ }) + ($msg:expr) => {{ /* compiler built-in */ }}; + ($msg:expr,) => {{ /* compiler built-in */ }}; } /// Constructs parameters for the other string-formatting macros. @@ -788,20 +792,23 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! format_args { - ($fmt:expr) => ({ /* compiler built-in */ }); - ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ }) + ($fmt:expr) => {{ /* compiler built-in */ }}; + ($fmt:expr, $($args:tt)*) => {{ /* compiler built-in */ }}; } /// Same as `format_args`, but adds a newline in the end. - #[unstable(feature = "format_args_nl", issue = "0", - reason = "`format_args_nl` is only for internal \ - language use and is subject to change")] + #[unstable( + feature = "format_args_nl", + issue = "0", + reason = "`format_args_nl` is only for internal \ + language use and is subject to change" + )] #[allow_internal_unstable(fmt_internals)] #[rustc_builtin_macro] #[macro_export] macro_rules! format_args_nl { - ($fmt:expr) => ({ /* compiler built-in */ }); - ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ }) + ($fmt:expr) => {{ /* compiler built-in */ }}; + ($fmt:expr, $($args:tt)*) => {{ /* compiler built-in */ }}; } /// Inspects an environment variable at compile time. @@ -839,8 +846,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! env { - ($name:expr) => ({ /* compiler built-in */ }); - ($name:expr,) => ({ /* compiler built-in */ }) + ($name:expr) => {{ /* compiler built-in */ }}; + ($name:expr,) => {{ /* compiler built-in */ }}; } /// Optionally inspects an environment variable at compile time. @@ -866,8 +873,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! option_env { - ($name:expr) => ({ /* compiler built-in */ }); - ($name:expr,) => ({ /* compiler built-in */ }) + ($name:expr) => {{ /* compiler built-in */ }}; + ($name:expr,) => {{ /* compiler built-in */ }}; } /// Concatenates identifiers into one identifier. @@ -894,13 +901,16 @@ pub(crate) mod builtin { /// // fn concat_idents!(new, fun, name) { } // not usable in this way! /// # } /// ``` - #[unstable(feature = "concat_idents", issue = "29599", - reason = "`concat_idents` is not stable enough for use and is subject to change")] + #[unstable( + feature = "concat_idents", + issue = "29599", + reason = "`concat_idents` is not stable enough for use and is subject to change" + )] #[rustc_builtin_macro] #[macro_export] macro_rules! concat_idents { - ($($e:ident),+) => ({ /* compiler built-in */ }); - ($($e:ident,)+) => ({ /* compiler built-in */ }) + ($($e:ident),+) => {{ /* compiler built-in */ }}; + ($($e:ident,)+) => {{ /* compiler built-in */ }}; } /// Concatenates literals into a static string slice. @@ -922,8 +932,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! concat { - ($($e:expr),*) => ({ /* compiler built-in */ }); - ($($e:expr,)*) => ({ /* compiler built-in */ }) + ($($e:expr),*) => {{ /* compiler built-in */ }}; + ($($e:expr,)*) => {{ /* compiler built-in */ }}; } /// Expands to the line number on which it was invoked. @@ -950,7 +960,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! line { () => { /* compiler built-in */ } } + macro_rules! line { + () => { + /* compiler built-in */ + }; + } /// Expands to the column number at which it was invoked. /// @@ -976,7 +990,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! column { () => { /* compiler built-in */ } } + macro_rules! column { + () => { + /* compiler built-in */ + }; + } /// Expands to the file name in which it was invoked. /// @@ -1001,7 +1019,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! file { () => { /* compiler built-in */ } } + macro_rules! file { + () => { + /* compiler built-in */ + }; + } /// Stringifies its arguments. /// @@ -1021,7 +1043,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! stringify { ($($t:tt)*) => { /* compiler built-in */ } } + macro_rules! stringify { + ($($t:tt)*) => { + /* compiler built-in */ + }; + } /// Includes a utf8-encoded file as a string. /// @@ -1057,8 +1083,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! include_str { - ($file:expr) => ({ /* compiler built-in */ }); - ($file:expr,) => ({ /* compiler built-in */ }) + ($file:expr) => {{ /* compiler built-in */ }}; + ($file:expr,) => {{ /* compiler built-in */ }}; } /// Includes a file as a reference to a byte array. @@ -1095,8 +1121,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! include_bytes { - ($file:expr) => ({ /* compiler built-in */ }); - ($file:expr,) => ({ /* compiler built-in */ }) + ($file:expr) => {{ /* compiler built-in */ }}; + ($file:expr,) => {{ /* compiler built-in */ }}; } /// Expands to a string that represents the current module path. @@ -1119,7 +1145,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! module_path { () => { /* compiler built-in */ } } + macro_rules! module_path { + () => { + /* compiler built-in */ + }; + } /// Evaluates boolean combinations of configuration flags at compile-time. /// @@ -1144,7 +1174,11 @@ pub(crate) mod builtin { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_builtin_macro] #[macro_export] - macro_rules! cfg { ($($cfg:tt)*) => { /* compiler built-in */ } } + macro_rules! cfg { + ($($cfg:tt)*) => { + /* compiler built-in */ + }; + } /// Parses a file as an expression or an item according to the context. /// @@ -1189,8 +1223,8 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! include { - ($file:expr) => ({ /* compiler built-in */ }); - ($file:expr,) => ({ /* compiler built-in */ }) + ($file:expr) => {{ /* compiler built-in */ }}; + ($file:expr,) => {{ /* compiler built-in */ }}; } /// Asserts that a boolean expression is `true` at runtime. @@ -1242,9 +1276,9 @@ pub(crate) mod builtin { #[rustc_builtin_macro] #[macro_export] macro_rules! assert { - ($cond:expr) => ({ /* compiler built-in */ }); - ($cond:expr,) => ({ /* compiler built-in */ }); - ($cond:expr, $($arg:tt)+) => ({ /* compiler built-in */ }) + ($cond:expr) => {{ /* compiler built-in */ }}; + ($cond:expr,) => {{ /* compiler built-in */ }}; + ($cond:expr, $($arg:tt)+) => {{ /* compiler built-in */ }}; } /// Inline assembly. @@ -1252,75 +1286,118 @@ pub(crate) mod builtin { /// Read the [unstable book] for the usage. /// /// [unstable book]: ../unstable-book/library-features/asm.html - #[unstable(feature = "asm", issue = "29722", - reason = "inline assembly is not stable enough for use and is subject to change")] + #[unstable( + feature = "asm", + issue = "29722", + reason = "inline assembly is not stable enough for use and is subject to change" + )] #[rustc_builtin_macro] #[macro_export] - macro_rules! asm { ("assembly template" + macro_rules! asm { + ("assembly template" : $("output"(operand),)* : $("input"(operand),)* : $("clobbers",)* - : $("options",)*) => { /* compiler built-in */ } } + : $("options",)*) => { + /* compiler built-in */ + }; + } /// Module-level inline assembly. - #[unstable(feature = "global_asm", issue = "35119", - reason = "`global_asm!` is not stable enough for use and is subject to change")] + #[unstable( + feature = "global_asm", + issue = "35119", + reason = "`global_asm!` is not stable enough for use and is subject to change" + )] #[rustc_builtin_macro] #[macro_export] - macro_rules! global_asm { ("assembly") => { /* compiler built-in */ } } + macro_rules! global_asm { + ("assembly") => { + /* compiler built-in */ + }; + } /// Prints passed tokens into the standard output. - #[unstable(feature = "log_syntax", issue = "29598", - reason = "`log_syntax!` is not stable enough for use and is subject to change")] + #[unstable( + feature = "log_syntax", + issue = "29598", + reason = "`log_syntax!` is not stable enough for use and is subject to change" + )] #[rustc_builtin_macro] #[macro_export] - macro_rules! log_syntax { ($($arg:tt)*) => { /* compiler built-in */ } } + macro_rules! log_syntax { + ($($arg:tt)*) => { + /* compiler built-in */ + }; + } /// Enables or disables tracing functionality used for debugging other macros. - #[unstable(feature = "trace_macros", issue = "29598", - reason = "`trace_macros` is not stable enough for use and is subject to change")] + #[unstable( + feature = "trace_macros", + issue = "29598", + reason = "`trace_macros` is not stable enough for use and is subject to change" + )] #[rustc_builtin_macro] #[macro_export] macro_rules! trace_macros { - (true) => ({ /* compiler built-in */ }); - (false) => ({ /* compiler built-in */ }) + (true) => {{ /* compiler built-in */ }}; + (false) => {{ /* compiler built-in */ }}; } /// Attribute macro applied to a function to turn it into a unit test. #[stable(feature = "rust1", since = "1.0.0")] #[allow_internal_unstable(test, rustc_attrs)] #[rustc_builtin_macro] - pub macro test($item:item) { /* compiler built-in */ } + pub macro test($item:item) { + /* compiler built-in */ + } /// Attribute macro applied to a function to turn it into a benchmark test. - #[unstable(soft, feature = "test", issue = "50297", - reason = "`bench` is a part of custom test frameworks which are unstable")] + #[unstable( + feature = "test", + issue = "50297", + soft, + reason = "`bench` is a part of custom test frameworks which are unstable" + )] #[allow_internal_unstable(test, rustc_attrs)] #[rustc_builtin_macro] - pub macro bench($item:item) { /* compiler built-in */ } + pub macro bench($item:item) { + /* compiler built-in */ + } /// An implementation detail of the `#[test]` and `#[bench]` macros. - #[unstable(feature = "custom_test_frameworks", issue = "50297", - reason = "custom test frameworks are an unstable feature")] + #[unstable( + feature = "custom_test_frameworks", + issue = "50297", + reason = "custom test frameworks are an unstable feature" + )] #[allow_internal_unstable(test, rustc_attrs)] #[rustc_builtin_macro] - pub macro test_case($item:item) { /* compiler built-in */ } + pub macro test_case($item:item) { + /* compiler built-in */ + } /// Attribute macro applied to a static to register it as a global allocator. #[stable(feature = "global_allocator", since = "1.28.0")] #[allow_internal_unstable(rustc_attrs)] #[rustc_builtin_macro] - pub macro global_allocator($item:item) { /* compiler built-in */ } + pub macro global_allocator($item:item) { + /* compiler built-in */ + } /// Unstable implementation detail of the `rustc` compiler, do not use. #[rustc_builtin_macro] #[stable(feature = "rust1", since = "1.0.0")] #[allow_internal_unstable(core_intrinsics, libstd_sys_internals)] - pub macro RustcDecodable($item:item) { /* compiler built-in */ } + pub macro RustcDecodable($item:item) { + /* compiler built-in */ + } /// Unstable implementation detail of the `rustc` compiler, do not use. #[rustc_builtin_macro] #[stable(feature = "rust1", since = "1.0.0")] #[allow_internal_unstable(core_intrinsics)] - pub macro RustcEncodable($item:item) { /* compiler built-in */ } + pub macro RustcEncodable($item:item) { + /* compiler built-in */ + } } diff --git a/src/libcore/mem/manually_drop.rs b/src/libcore/mem/manually_drop.rs index bb35399323628..34fc0618ea2ae 100644 --- a/src/libcore/mem/manually_drop.rs +++ b/src/libcore/mem/manually_drop.rs @@ -1,5 +1,5 @@ -use crate::ptr; use crate::ops::{Deref, DerefMut}; +use crate::ptr; /// A wrapper to inhibit compiler from automatically calling `T`’s destructor. /// diff --git a/src/libcore/num/bignum.rs b/src/libcore/num/bignum.rs index 342ac69748d92..b8ddd5322a1da 100644 --- a/src/libcore/num/bignum.rs +++ b/src/libcore/num/bignum.rs @@ -12,13 +12,15 @@ // This module is only for dec2flt and flt2dec, and only public because of coretests. // It is not intended to ever be stabilized. #![doc(hidden)] -#![unstable(feature = "core_private_bignum", - reason = "internal routines only exposed for testing", - issue = "0")] +#![unstable( + feature = "core_private_bignum", + reason = "internal routines only exposed for testing", + issue = "0" +)] #![macro_use] -use crate::mem; use crate::intrinsics; +use crate::mem; /// Arithmetic operations required by bignums. pub trait FullOps: Sized { @@ -36,10 +38,8 @@ pub trait FullOps: Sized { /// Returns `(quo, rem)` such that `borrow * 2^W + self = quo * other + rem` /// and `0 <= rem < other`, where `W` is the number of bits in `Self`. - fn full_div_rem(self, - other: Self, - borrow: Self) - -> (Self /* quotient */, Self /* remainder */); + fn full_div_rem(self, other: Self, borrow: Self) + -> (Self /* quotient */, Self /* remainder */); } macro_rules! impl_full_ops { @@ -98,7 +98,7 @@ impl_full_ops! { const SMALL_POW5: [(u64, usize); 3] = [(125, 3), (15625, 6), (1_220_703_125, 13)]; macro_rules! define_bignum { - ($name:ident: type=$ty:ty, n=$n:expr) => ( + ($name:ident: type=$ty:ty, n=$n:expr) => { /// Stack-allocated arbitrary-precision (up to certain limit) integer. /// /// This is backed by a fixed-size array of given type ("digit"). @@ -115,7 +115,7 @@ macro_rules! define_bignum { size: usize, /// Digits. `[a, b, c, ...]` represents `a + b*2^W + c*2^(2W) + ...` /// where `W` is the number of bits in the digit type. - base: [$ty; $n] + base: [$ty; $n], } impl $name { @@ -180,7 +180,7 @@ macro_rules! define_bignum { } // This could be optimized with leading_zeros() and bit shifts, but that's // probably not worth the hassle. - let digitbits = mem::size_of::<$ty>()* 8; + let digitbits = mem::size_of::<$ty>() * 8; let mut i = nonzero.len() * digitbits - 1; while self.get_bit(i) == 0 { i -= 1; @@ -272,12 +272,12 @@ macro_rules! define_bignum { let bits = bits % digitbits; assert!(digits < $n); - debug_assert!(self.base[$n-digits..].iter().all(|&v| v == 0)); - debug_assert!(bits == 0 || (self.base[$n-digits-1] >> (digitbits - bits)) == 0); + debug_assert!(self.base[$n - digits..].iter().all(|&v| v == 0)); + debug_assert!(bits == 0 || (self.base[$n - digits - 1] >> (digitbits - bits)) == 0); // shift by `digits * digitbits` bits for i in (0..self.size).rev() { - self.base[i+digits] = self.base[i]; + self.base[i + digits] = self.base[i]; } for i in 0..digits { self.base[i] = 0; @@ -287,14 +287,14 @@ macro_rules! define_bignum { let mut sz = self.size + digits; if bits > 0 { let last = sz; - let overflow = self.base[last-1] >> (digitbits - bits); + let overflow = self.base[last - 1] >> (digitbits - bits); if overflow > 0 { self.base[last] = overflow; sz += 1; } - for i in (digits+1..last).rev() { - self.base[i] = (self.base[i] << bits) | - (self.base[i-1] >> (digitbits - bits)); + for i in (digits + 1..last).rev() { + self.base[i] = + (self.base[i] << bits) | (self.base[i - 1] >> (digitbits - bits)); } self.base[digits] <<= bits; // self.base[..digits] is zero, no need to shift @@ -331,7 +331,6 @@ macro_rules! define_bignum { self } - /// Multiplies itself by a number described by `other[0] + other[1] * 2^W + /// other[2] * 2^(2W) + ...` (where `W` is the number of bits in the digit type) /// and returns its own mutable reference. @@ -342,7 +341,9 @@ macro_rules! define_bignum { let mut retsz = 0; for (i, &a) in aa.iter().enumerate() { - if a == 0 { continue; } + if a == 0 { + continue; + } let mut sz = bb.len(); let mut carry = 0; for (j, &b) in bb.iter().enumerate() { @@ -430,11 +431,12 @@ macro_rules! define_bignum { } impl crate::cmp::PartialEq for $name { - fn eq(&self, other: &$name) -> bool { self.base[..] == other.base[..] } + fn eq(&self, other: &$name) -> bool { + self.base[..] == other.base[..] + } } - impl crate::cmp::Eq for $name { - } + impl crate::cmp::Eq for $name {} impl crate::cmp::PartialOrd for $name { fn partial_cmp(&self, other: &$name) -> crate::option::Option { @@ -462,17 +464,17 @@ macro_rules! define_bignum { fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { use crate::mem; - let sz = if self.size < 1 {1} else {self.size}; + let sz = if self.size < 1 { 1 } else { self.size }; let digitlen = mem::size_of::<$ty>() * 2; - write!(f, "{:#x}", self.base[sz-1])?; - for &v in self.base[..sz-1].iter().rev() { + write!(f, "{:#x}", self.base[sz - 1])?; + for &v in self.base[..sz - 1].iter().rev() { write!(f, "_{:01$x}", v, digitlen)?; } crate::result::Result::Ok(()) } } - ) + }; } /// The digit type for `Big32x40`. diff --git a/src/libcore/num/dec2flt/algorithm.rs b/src/libcore/num/dec2flt/algorithm.rs index 641463026261d..c5f6903f379c4 100644 --- a/src/libcore/num/dec2flt/algorithm.rs +++ b/src/libcore/num/dec2flt/algorithm.rs @@ -1,11 +1,11 @@ //! The various algorithms from the paper. use crate::cmp::min; -use crate::cmp::Ordering::{Less, Equal, Greater}; -use crate::num::diy_float::Fp; -use crate::num::dec2flt::table; -use crate::num::dec2flt::rawfp::{self, Unpacked, RawFloat, fp_to_float, next_float, prev_float}; +use crate::cmp::Ordering::{Equal, Greater, Less}; use crate::num::dec2flt::num::{self, Big}; +use crate::num::dec2flt::rawfp::{self, fp_to_float, next_float, prev_float, RawFloat, Unpacked}; +use crate::num::dec2flt::table; +use crate::num::diy_float::Fp; /// Number of significand bits in Fp const P: u32 = 64; @@ -23,9 +23,9 @@ fn power_of_ten(e: i16) -> Fp { // In most architectures, floating point operations have an explicit bit size, therefore the // precision of the computation is determined on a per-operation basis. -#[cfg(any(not(target_arch="x86"), target_feature="sse2"))] +#[cfg(any(not(target_arch = "x86"), target_feature = "sse2"))] mod fpu_precision { - pub fn set_precision() { } + pub fn set_precision() {} } // On x86, the x87 FPU is used for float operations if the SSE/SSE2 extensions are not available. @@ -33,7 +33,7 @@ mod fpu_precision { // round to 80 bits causing double rounding to happen when values are eventually represented as // 32/64 bit float values. To overcome this, the FPU control word can be set so that the // computations are performed in the desired precision. -#[cfg(all(target_arch="x86", not(target_feature="sse2")))] +#[cfg(all(target_arch = "x86", not(target_feature = "sse2")))] mod fpu_precision { use crate::mem::size_of; diff --git a/src/libcore/num/dec2flt/mod.rs b/src/libcore/num/dec2flt/mod.rs index 4536bbc94ad80..6fe9af8cbd8ee 100644 --- a/src/libcore/num/dec2flt/mod.rs +++ b/src/libcore/num/dec2flt/mod.rs @@ -78,23 +78,25 @@ //! turned into {positive,negative} {zero,infinity}. #![doc(hidden)] -#![unstable(feature = "dec2flt", - reason = "internal routines only exposed for testing", - issue = "0")] +#![unstable( + feature = "dec2flt", + reason = "internal routines only exposed for testing", + issue = "0" +)] use crate::fmt; use crate::str::FromStr; -use self::parse::{parse_decimal, Decimal, Sign, ParseResult}; use self::num::digits_to_big; +use self::parse::{parse_decimal, Decimal, ParseResult, Sign}; use self::rawfp::RawFloat; mod algorithm; -mod table; mod num; +mod table; // These two have their own tests. -pub mod rawfp; pub mod parse; +pub mod rawfp; macro_rules! from_str_float_impl { ($t:ty) => { @@ -155,7 +157,7 @@ macro_rules! from_str_float_impl { dec2flt(src) } } - } + }; } from_str_float_impl!(f32); from_str_float_impl!(f64); @@ -171,7 +173,7 @@ from_str_float_impl!(f64); #[derive(Debug, Clone, PartialEq, Eq)] #[stable(feature = "rust1", since = "1.0.0")] pub struct ParseFloatError { - kind: FloatErrorKind + kind: FloatErrorKind, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -181,10 +183,12 @@ enum FloatErrorKind { } impl ParseFloatError { - #[unstable(feature = "int_error_internals", - reason = "available through Error trait and this method should \ - not be exposed publicly", - issue = "0")] + #[unstable( + feature = "int_error_internals", + reason = "available through Error trait and this method should \ + not be exposed publicly", + issue = "0" + )] #[doc(hidden)] pub fn __description(&self) -> &str { match self.kind { @@ -222,7 +226,7 @@ fn extract_sign(s: &str) -> (Sign, &str) { /// Converts a decimal string into a floating point number. fn dec2flt(s: &str) -> Result { if s.is_empty() { - return Err(pfe_empty()) + return Err(pfe_empty()); } let (sign, s) = extract_sign(s); let flt = match parse_decimal(s) { @@ -232,8 +236,10 @@ fn dec2flt(s: &str) -> Result { ParseResult::Invalid => match s { "inf" => T::INFINITY, "NaN" => T::NAN, - _ => { return Err(pfe_invalid()); } - } + _ => { + return Err(pfe_invalid()); + } + }, }; match sign { diff --git a/src/libcore/num/dec2flt/num.rs b/src/libcore/num/dec2flt/num.rs index 4d50516ce546b..208783dd32fd5 100644 --- a/src/libcore/num/dec2flt/num.rs +++ b/src/libcore/num/dec2flt/num.rs @@ -2,7 +2,7 @@ // FIXME This module's name is a bit unfortunate, since other modules also import `core::num`. -use crate::cmp::Ordering::{self, Less, Equal, Greater}; +use crate::cmp::Ordering::{self, Equal, Greater, Less}; pub use crate::num::bignum::Big32x40 as Big; @@ -36,7 +36,10 @@ pub fn compare_with_half_ulp(f: &Big, ones_place: usize) -> Ordering { /// 1. using `FromStr` on `&[u8]` requires `from_utf8_unchecked`, which is bad, and /// 2. piecing together the results of `integral.parse()` and `fractional.parse()` is /// more complicated than this entire function. -pub fn from_str_unchecked<'a, T>(bytes: T) -> u64 where T : IntoIterator { +pub fn from_str_unchecked<'a, T>(bytes: T) -> u64 +where + T: IntoIterator, +{ let mut result = 0; for &c in bytes { result = result * 10 + (c - b'0') as u64; @@ -61,14 +64,9 @@ pub fn digits_to_big(integral: &[u8], fractional: &[u8]) -> Big { pub fn to_u64(x: &Big) -> u64 { assert!(x.bit_length() < 64); let d = x.digits(); - if d.len() < 2 { - d[0] as u64 - } else { - (d[1] as u64) << 32 | d[0] as u64 - } + if d.len() < 2 { d[0] as u64 } else { (d[1] as u64) << 32 | d[0] as u64 } } - /// Extracts a range of bits. /// Index 0 is the least significant bit and the range is half-open as usual. diff --git a/src/libcore/num/dec2flt/parse.rs b/src/libcore/num/dec2flt/parse.rs index cf3664a874886..93b08bce853c7 100644 --- a/src/libcore/num/dec2flt/parse.rs +++ b/src/libcore/num/dec2flt/parse.rs @@ -10,8 +10,8 @@ //! modules rely on to not panic (or overflow) in turn. //! To make matters worse, all that happens in a single pass over the input. //! So, be careful when modifying anything, and double-check with the other modules. +use self::ParseResult::{Invalid, ShortcutToInf, ShortcutToZero, Valid}; use super::num; -use self::ParseResult::{Valid, ShortcutToInf, ShortcutToZero, Invalid}; #[derive(Debug)] pub enum Sign { diff --git a/src/libcore/num/dec2flt/rawfp.rs b/src/libcore/num/dec2flt/rawfp.rs index fdbdaa238e0f2..a127c6c3fa7ce 100644 --- a/src/libcore/num/dec2flt/rawfp.rs +++ b/src/libcore/num/dec2flt/rawfp.rs @@ -17,15 +17,15 @@ //! Many functions in this module only handle normal numbers. The dec2flt routines conservatively //! take the universally-correct slow path (Algorithm M) for very small and very large numbers. //! That algorithm needs only next_float() which does handle subnormals and zeros. -use crate::cmp::Ordering::{Less, Equal, Greater}; +use crate::cmp::Ordering::{Equal, Greater, Less}; use crate::convert::{TryFrom, TryInto}; -use crate::ops::{Add, Mul, Div, Neg}; use crate::fmt::{Debug, LowerExp}; -use crate::num::diy_float::Fp; -use crate::num::FpCategory::{Infinite, Zero, Subnormal, Normal, Nan}; -use crate::num::FpCategory; use crate::num::dec2flt::num::{self, Big}; use crate::num::dec2flt::table; +use crate::num::diy_float::Fp; +use crate::num::FpCategory; +use crate::num::FpCategory::{Infinite, Nan, Normal, Subnormal, Zero}; +use crate::ops::{Add, Div, Mul, Neg}; #[derive(Copy, Clone, Debug)] pub struct Unpacked { @@ -44,13 +44,8 @@ impl Unpacked { /// See the parent module's doc comment for why this is necessary. /// /// Should **never ever** be implemented for other types or be used outside the dec2flt module. -pub trait RawFloat - : Copy - + Debug - + LowerExp - + Mul - + Div - + Neg +pub trait RawFloat: + Copy + Debug + LowerExp + Mul + Div + Neg { const INFINITY: Self; const NAN: Self; @@ -144,7 +139,7 @@ macro_rules! other_constants { const INFINITY: Self = $crate::$type::INFINITY; const NAN: Self = $crate::$type::NAN; const ZERO: Self = 0.0; - } + }; } impl RawFloat for f32 { @@ -163,11 +158,8 @@ impl RawFloat for f32 { let bits = self.to_bits(); let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 }; let mut exponent: i16 = ((bits >> 23) & 0xff) as i16; - let mantissa = if exponent == 0 { - (bits & 0x7fffff) << 1 - } else { - (bits & 0x7fffff) | 0x800000 - }; + let mantissa = + if exponent == 0 { (bits & 0x7fffff) << 1 } else { (bits & 0x7fffff) | 0x800000 }; // Exponent bias + mantissa shift exponent -= 127 + 23; (mantissa as u64, exponent, sign) @@ -188,12 +180,17 @@ impl RawFloat for f32 { table::F32_SHORT_POWERS[e] } - fn classify(self) -> FpCategory { self.classify() } - fn to_bits(self) -> Self::Bits { self.to_bits() } - fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) } + fn classify(self) -> FpCategory { + self.classify() + } + fn to_bits(self) -> Self::Bits { + self.to_bits() + } + fn from_bits(v: Self::Bits) -> Self { + Self::from_bits(v) + } } - impl RawFloat for f64 { type Bits = u64; @@ -235,9 +232,15 @@ impl RawFloat for f64 { table::F64_SHORT_POWERS[e] } - fn classify(self) -> FpCategory { self.classify() } - fn to_bits(self) -> Self::Bits { self.to_bits() } - fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) } + fn classify(self) -> FpCategory { + self.classify() + } + fn to_bits(self) -> Self::Bits { + self.to_bits() + } + fn from_bits(v: Self::Bits) -> Self { + Self::from_bits(v) + } } /// Converts an `Fp` to the closest machine float type. @@ -248,7 +251,7 @@ pub fn fp_to_float(x: Fp) -> T { let e = x.e + 63; if e > T::MAX_EXP { panic!("fp_to_float: exponent {} too large", e) - } else if e > T::MIN_EXP { + } else if e > T::MIN_EXP { encode_normal(round_normal::(x)) } else { panic!("fp_to_float: exponent {} too small", e) @@ -278,14 +281,15 @@ pub fn round_normal(x: Fp) -> Unpacked { /// Inverse of `RawFloat::unpack()` for normalized numbers. /// Panics if the significand or exponent are not valid for normalized numbers. pub fn encode_normal(x: Unpacked) -> T { - debug_assert!(T::MIN_SIG <= x.sig && x.sig <= T::MAX_SIG, - "encode_normal: significand not normalized"); + debug_assert!( + T::MIN_SIG <= x.sig && x.sig <= T::MAX_SIG, + "encode_normal: significand not normalized" + ); // Remove the hidden bit let sig_enc = x.sig & !(1 << T::EXPLICIT_SIG_BITS); // Adjust the exponent for exponent bias and mantissa shift let k_enc = x.k + T::MAX_EXP + T::EXPLICIT_SIG_BITS as i16; - debug_assert!(k_enc != 0 && k_enc < T::MAX_ENCODED_EXP, - "encode_normal: exponent out of range"); + debug_assert!(k_enc != 0 && k_enc < T::MAX_ENCODED_EXP, "encode_normal: exponent out of range"); // Leave sign bit at 0 ("+"), our numbers are all positive let bits = (k_enc as u64) << T::EXPLICIT_SIG_BITS | sig_enc; T::from_bits(bits.try_into().unwrap_or_else(|_| unreachable!())) @@ -315,7 +319,7 @@ pub fn big_to_fp(f: &Big) -> Fp { Equal | Greater => match leading.checked_add(1) { Some(f) => Fp { f, e }.normalize(), None => Fp { f: 1 << 63, e: e + 1 }, - } + }, } } @@ -354,8 +358,6 @@ pub fn next_float(x: T) -> T { // want, and the mantissa bits become zero. Because of the hidden bit convention, this // too is exactly what we want! // Finally, f64::MAX + 1 = 7eff...f + 1 = 7ff0...0 = f64::INFINITY. - Zero | Subnormal | Normal => { - T::from_bits(x.to_bits() + T::Bits::from(1u8)) - } + Zero | Subnormal | Normal => T::from_bits(x.to_bits() + T::Bits::from(1u8)), } } diff --git a/src/libcore/num/diy_float.rs b/src/libcore/num/diy_float.rs index cdf332989492f..0e601d45a2124 100644 --- a/src/libcore/num/diy_float.rs +++ b/src/libcore/num/diy_float.rs @@ -3,9 +3,11 @@ // This module is only for dec2flt and flt2dec, and only public because of coretests. // It is not intended to ever be stabilized. #![doc(hidden)] -#![unstable(feature = "core_private_diy_float", - reason = "internal routines only exposed for testing", - issue = "0")] +#![unstable( + feature = "core_private_diy_float", + reason = "internal routines only exposed for testing", + issue = "0" +)] /// A custom 64-bit floating point type, representing `f * 2^e`. #[derive(Copy, Clone, Debug)] @@ -74,9 +76,6 @@ impl Fp { assert!(edelta >= 0); let edelta = edelta as usize; assert_eq!(self.f << edelta >> edelta, self.f); - Fp { - f: self.f << edelta, - e, - } + Fp { f: self.f << edelta, e } } } diff --git a/src/libcore/num/flt2dec/decoder.rs b/src/libcore/num/flt2dec/decoder.rs index ee0f18ba295e9..2b74effbe2e98 100644 --- a/src/libcore/num/flt2dec/decoder.rs +++ b/src/libcore/num/flt2dec/decoder.rs @@ -1,8 +1,8 @@ //! Decodes a floating-point value into individual parts and error ranges. -use crate::{f32, f64}; -use crate::num::FpCategory; use crate::num::dec2flt::rawfp::RawFloat; +use crate::num::FpCategory; +use crate::{f32, f64}; /// Decoded unsigned finite value, such that: /// @@ -47,11 +47,15 @@ pub trait DecodableFloat: RawFloat + Copy { } impl DecodableFloat for f32 { - fn min_pos_norm_value() -> Self { f32::MIN_POSITIVE } + fn min_pos_norm_value() -> Self { + f32::MIN_POSITIVE + } } impl DecodableFloat for f64 { - fn min_pos_norm_value() -> Self { f64::MIN_POSITIVE } + fn min_pos_norm_value() -> Self { + f64::MIN_POSITIVE + } } /// Returns a sign (true when negative) and `FullDecoded` value @@ -67,20 +71,29 @@ pub fn decode(v: T) -> (/*negative?*/ bool, FullDecoded) { // neighbors: (mant - 2, exp) -- (mant, exp) -- (mant + 2, exp) // Float::integer_decode always preserves the exponent, // so the mantissa is scaled for subnormals. - FullDecoded::Finite(Decoded { mant, minus: 1, plus: 1, - exp, inclusive: even }) + FullDecoded::Finite(Decoded { mant, minus: 1, plus: 1, exp, inclusive: even }) } FpCategory::Normal => { let minnorm = ::min_pos_norm_value().integer_decode(); if mant == minnorm.0 { // neighbors: (maxmant, exp - 1) -- (minnormmant, exp) -- (minnormmant + 1, exp) // where maxmant = minnormmant * 2 - 1 - FullDecoded::Finite(Decoded { mant: mant << 2, minus: 1, plus: 2, - exp: exp - 2, inclusive: even }) + FullDecoded::Finite(Decoded { + mant: mant << 2, + minus: 1, + plus: 2, + exp: exp - 2, + inclusive: even, + }) } else { // neighbors: (mant - 1, exp) -- (mant, exp) -- (mant + 1, exp) - FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1, - exp: exp - 1, inclusive: even }) + FullDecoded::Finite(Decoded { + mant: mant << 1, + minus: 1, + plus: 1, + exp: exp - 1, + inclusive: even, + }) } } }; diff --git a/src/libcore/num/flt2dec/mod.rs b/src/libcore/num/flt2dec/mod.rs index 6d42a77744966..63df561345323 100644 --- a/src/libcore/num/flt2dec/mod.rs +++ b/src/libcore/num/flt2dec/mod.rs @@ -116,15 +116,17 @@ functions. // while this is extensively documented, this is in principle private which is // only made public for testing. do not expose us. #![doc(hidden)] -#![unstable(feature = "flt2dec", - reason = "internal routines only exposed for testing", - issue = "0")] +#![unstable( + feature = "flt2dec", + reason = "internal routines only exposed for testing", + issue = "0" +)] +pub use self::decoder::{decode, DecodableFloat, Decoded, FullDecoded}; use crate::i16; -pub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded}; -pub mod estimator; pub mod decoder; +pub mod estimator; /// Digit-generation algorithms. pub mod strategy { @@ -144,17 +146,24 @@ pub const MAX_SIG_DIGITS: usize = 17; #[doc(hidden)] pub fn round_up(d: &mut [u8], n: usize) -> Option { match d[..n].iter().rposition(|&c| c != b'9') { - Some(i) => { // d[i+1..n] is all nines + Some(i) => { + // d[i+1..n] is all nines d[i] += 1; - for j in i+1..n { d[j] = b'0'; } + for j in i + 1..n { + d[j] = b'0'; + } None } - None if n > 0 => { // 999..999 rounds to 1000..000 with an increased exponent + None if n > 0 => { + // 999..999 rounds to 1000..000 with an increased exponent d[0] = b'1'; - for j in 1..n { d[j] = b'0'; } + for j in 1..n { + d[j] = b'0'; + } Some(b'0') } - None => { // an empty buffer rounds up (a bit strange but reasonable) + None => { + // an empty buffer rounds up (a bit strange but reasonable) Some(b'1') } } @@ -176,8 +185,19 @@ impl<'a> Part<'a> { pub fn len(&self) -> usize { match *self { Part::Zero(nzeroes) => nzeroes, - Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } } - else { if v < 10_000 { 4 } else { 5 } }, + Part::Num(v) => { + if v < 1_000 { + if v < 10 { + 1 + } else if v < 100 { + 2 + } else { + 3 + } + } else { + if v < 10_000 { 4 } else { 5 } + } + } Part::Copy(buf) => buf.len(), } } @@ -190,7 +210,9 @@ impl<'a> Part<'a> { if out.len() >= len { match *self { Part::Zero(nzeroes) => { - for c in &mut out[..nzeroes] { *c = b'0'; } + for c in &mut out[..nzeroes] { + *c = b'0'; + } } Part::Num(mut v) => { for c in out[..len].iter_mut().rev() { @@ -234,7 +256,9 @@ impl<'a> Formatted<'a> { /// Returns the number of written bytes, or `None` if the buffer is not enough. /// (It may still leave partially written bytes in the buffer; do not rely on that.) pub fn write(&self, out: &mut [u8]) -> Option { - if out.len() < self.sign.len() { return None; } + if out.len() < self.sign.len() { + return None; + } out[..self.sign.len()].copy_from_slice(self.sign); let mut written = self.sign.len(); @@ -254,8 +278,12 @@ impl<'a> Formatted<'a> { /// it will be ignored and full digits will be printed. It is only used to print /// additional zeroes after rendered digits. Thus `frac_digits` of 0 means that /// it will only print given digits and nothing else. -fn digits_to_dec_str<'a>(buf: &'a [u8], exp: i16, frac_digits: usize, - parts: &'a mut [Part<'a>]) -> &'a [Part<'a>] { +fn digits_to_dec_str<'a>( + buf: &'a [u8], + exp: i16, + frac_digits: usize, + parts: &'a mut [Part<'a>], +) -> &'a [Part<'a>] { assert!(!buf.is_empty()); assert!(buf[0] > b'0'); assert!(parts.len() >= 4); @@ -322,8 +350,13 @@ fn digits_to_dec_str<'a>(buf: &'a [u8], exp: i16, frac_digits: usize, /// it will be ignored and full digits will be printed. It is only used to print /// additional zeroes after rendered digits. Thus, `min_digits == 0` means that /// it will only print the given digits and nothing else. -fn digits_to_exp_str<'a>(buf: &'a [u8], exp: i16, min_ndigits: usize, upper: bool, - parts: &'a mut [Part<'a>]) -> &'a [Part<'a>] { +fn digits_to_exp_str<'a>( + buf: &'a [u8], + exp: i16, + min_ndigits: usize, + upper: bool, + parts: &'a mut [Part<'a>], +) -> &'a [Part<'a>] { assert!(!buf.is_empty()); assert!(buf[0] > b'0'); assert!(parts.len() >= 6); @@ -359,11 +392,11 @@ fn digits_to_exp_str<'a>(buf: &'a [u8], exp: i16, min_ndigits: usize, upper: boo #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum Sign { /// Prints `-` only for the negative non-zero values. - Minus, // -inf -1 0 0 1 inf nan + Minus, // -inf -1 0 0 1 inf nan /// Prints `-` only for any negative values (including the negative zero). - MinusRaw, // -inf -1 -0 0 1 inf nan + MinusRaw, // -inf -1 -0 0 1 inf nan /// Prints `-` for the negative non-zero values, or `+` otherwise. - MinusPlus, // -inf -1 +0 +0 +1 +inf nan + MinusPlus, // -inf -1 +0 +0 +1 +inf nan /// Prints `-` for any negative values (including the negative zero), or `+` otherwise. MinusPlusRaw, // -inf -1 -0 +0 +1 +inf nan } @@ -374,11 +407,35 @@ fn determine_sign(sign: Sign, decoded: &FullDecoded, negative: bool) -> &'static match (*decoded, sign) { (FullDecoded::Nan, _) => b"", (FullDecoded::Zero, Sign::Minus) => b"", - (FullDecoded::Zero, Sign::MinusRaw) => if negative { b"-" } else { b"" }, + (FullDecoded::Zero, Sign::MinusRaw) => { + if negative { + b"-" + } else { + b"" + } + } (FullDecoded::Zero, Sign::MinusPlus) => b"+", - (FullDecoded::Zero, Sign::MinusPlusRaw) => if negative { b"-" } else { b"+" }, - (_, Sign::Minus) | (_, Sign::MinusRaw) => if negative { b"-" } else { b"" }, - (_, Sign::MinusPlus) | (_, Sign::MinusPlusRaw) => if negative { b"-" } else { b"+" }, + (FullDecoded::Zero, Sign::MinusPlusRaw) => { + if negative { + b"-" + } else { + b"+" + } + } + (_, Sign::Minus) | (_, Sign::MinusRaw) => { + if negative { + b"-" + } else { + b"" + } + } + (_, Sign::MinusPlus) | (_, Sign::MinusPlusRaw) => { + if negative { + b"-" + } else { + b"+" + } + } } } @@ -400,10 +457,19 @@ fn determine_sign(sign: Sign, decoded: &FullDecoded, negative: bool) -> &'static /// The byte buffer should be at least `MAX_SIG_DIGITS` bytes long. /// There should be at least 4 parts available, due to the worst case like /// `[+][0.][0000][2][0000]` with `frac_digits = 10`. -pub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T, - sign: Sign, frac_digits: usize, _upper: bool, - buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a> - where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8]) -> (usize, i16) { +pub fn to_shortest_str<'a, T, F>( + mut format_shortest: F, + v: T, + sign: Sign, + frac_digits: usize, + _upper: bool, + buf: &'a mut [u8], + parts: &'a mut [Part<'a>], +) -> Formatted<'a> +where + T: DecodableFloat, + F: FnMut(&Decoded, &mut [u8]) -> (usize, i16), +{ assert!(parts.len() >= 4); assert!(buf.len() >= MAX_SIG_DIGITS); @@ -419,7 +485,8 @@ pub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T, Formatted { sign, parts: &parts[..1] } } FullDecoded::Zero => { - if frac_digits > 0 { // [0.][0000] + if frac_digits > 0 { + // [0.][0000] parts[0] = Part::Copy(b"0."); parts[1] = Part::Zero(frac_digits); Formatted { sign, parts: &parts[..2] } @@ -430,8 +497,7 @@ pub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T, } FullDecoded::Finite(ref decoded) => { let (len, exp) = format_shortest(decoded, buf); - Formatted { sign, - parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) } + Formatted { sign, parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) } } } } @@ -455,10 +521,19 @@ pub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T, /// The byte buffer should be at least `MAX_SIG_DIGITS` bytes long. /// There should be at least 6 parts available, due to the worst case like /// `[+][1][.][2345][e][-][6]`. -pub fn to_shortest_exp_str<'a, T, F>(mut format_shortest: F, v: T, - sign: Sign, dec_bounds: (i16, i16), upper: bool, - buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a> - where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8]) -> (usize, i16) { +pub fn to_shortest_exp_str<'a, T, F>( + mut format_shortest: F, + v: T, + sign: Sign, + dec_bounds: (i16, i16), + upper: bool, + buf: &'a mut [u8], + parts: &'a mut [Part<'a>], +) -> Formatted<'a> +where + T: DecodableFloat, + F: FnMut(&Decoded, &mut [u8]) -> (usize, i16), +{ assert!(parts.len() >= 6); assert!(buf.len() >= MAX_SIG_DIGITS); assert!(dec_bounds.0 <= dec_bounds.1); @@ -534,10 +609,19 @@ fn estimate_max_buf_len(exp: i16) -> usize { /// (The tipping point for `f64` is about 800, so 1000 bytes should be enough.) /// There should be at least 6 parts available, due to the worst case like /// `[+][1][.][2345][e][-][6]`. -pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T, - sign: Sign, ndigits: usize, upper: bool, - buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a> - where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) { +pub fn to_exact_exp_str<'a, T, F>( + mut format_exact: F, + v: T, + sign: Sign, + ndigits: usize, + upper: bool, + buf: &'a mut [u8], + parts: &'a mut [Part<'a>], +) -> Formatted<'a> +where + T: DecodableFloat, + F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16), +{ assert!(parts.len() >= 6); assert!(ndigits > 0); @@ -553,7 +637,8 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T, Formatted { sign, parts: &parts[..1] } } FullDecoded::Zero => { - if ndigits > 1 { // [0.][0000][e0] + if ndigits > 1 { + // [0.][0000][e0] parts[0] = Part::Copy(b"0."); parts[1] = Part::Zero(ndigits - 1); parts[2] = Part::Copy(if upper { b"E0" } else { b"e0" }); @@ -569,8 +654,7 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T, let trunc = if ndigits < maxlen { ndigits } else { maxlen }; let (len, exp) = format_exact(decoded, &mut buf[..trunc], i16::MIN); - Formatted { sign, - parts: digits_to_exp_str(&buf[..len], exp, ndigits, upper, parts) } + Formatted { sign, parts: digits_to_exp_str(&buf[..len], exp, ndigits, upper, parts) } } } } @@ -590,10 +674,19 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T, /// (The tipping point for `f64` is about 800, and 1000 bytes should be enough.) /// There should be at least 4 parts available, due to the worst case like /// `[+][0.][0000][2][0000]` with `frac_digits = 10`. -pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T, - sign: Sign, frac_digits: usize, _upper: bool, - buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a> - where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) { +pub fn to_exact_fixed_str<'a, T, F>( + mut format_exact: F, + v: T, + sign: Sign, + frac_digits: usize, + _upper: bool, + buf: &'a mut [u8], + parts: &'a mut [Part<'a>], +) -> Formatted<'a> +where + T: DecodableFloat, + F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16), +{ assert!(parts.len() >= 4); let (negative, full_decoded) = decode(v); @@ -608,7 +701,8 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T, Formatted { sign, parts: &parts[..1] } } FullDecoded::Zero => { - if frac_digits > 0 { // [0.][0000] + if frac_digits > 0 { + // [0.][0000] parts[0] = Part::Copy(b"0."); parts[1] = Part::Zero(frac_digits); Formatted { sign, parts: &parts[..2] } @@ -631,7 +725,8 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T, // `exp` was. this does not include the case that the restriction has been met // only after the final rounding-up; it's a regular case with `exp = limit + 1`. debug_assert_eq!(len, 0); - if frac_digits > 0 { // [0.][0000] + if frac_digits > 0 { + // [0.][0000] parts[0] = Part::Copy(b"0."); parts[1] = Part::Zero(frac_digits); Formatted { sign, parts: &parts[..2] } @@ -640,8 +735,7 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T, Formatted { sign, parts: &parts[..1] } } } else { - Formatted { sign, - parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) } + Formatted { sign, parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) } } } } diff --git a/src/libcore/num/flt2dec/strategy/dragon.rs b/src/libcore/num/flt2dec/strategy/dragon.rs index 35fb4b927589f..c8de0004352ef 100644 --- a/src/libcore/num/flt2dec/strategy/dragon.rs +++ b/src/libcore/num/flt2dec/strategy/dragon.rs @@ -6,38 +6,54 @@ use crate::cmp::Ordering; -use crate::num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up}; -use crate::num::flt2dec::estimator::estimate_scaling_factor; -use crate::num::bignum::Digit32 as Digit; use crate::num::bignum::Big32x40 as Big; +use crate::num::bignum::Digit32 as Digit; +use crate::num::flt2dec::estimator::estimate_scaling_factor; +use crate::num::flt2dec::{round_up, Decoded, MAX_SIG_DIGITS}; -static POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000, - 1000000, 10000000, 100000000, 1000000000]; -static TWOPOW10: [Digit; 10] = [2, 20, 200, 2000, 20000, 200000, - 2000000, 20000000, 200000000, 2000000000]; +static POW10: [Digit; 10] = + [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000]; +static TWOPOW10: [Digit; 10] = + [2, 20, 200, 2000, 20000, 200000, 2000000, 20000000, 200000000, 2000000000]; // precalculated arrays of `Digit`s for 10^(2^n) static POW10TO16: [Digit; 2] = [0x6fc10000, 0x2386f2]; static POW10TO32: [Digit; 4] = [0, 0x85acef81, 0x2d6d415b, 0x4ee]; static POW10TO64: [Digit; 7] = [0, 0, 0xbf6a1f01, 0x6e38ed64, 0xdaa797ed, 0xe93ff9f4, 0x184f03]; -static POW10TO128: [Digit; 14] = - [0, 0, 0, 0, 0x2e953e01, 0x3df9909, 0xf1538fd, 0x2374e42f, 0xd3cff5ec, 0xc404dc08, - 0xbccdb0da, 0xa6337f19, 0xe91f2603, 0x24e]; -static POW10TO256: [Digit; 27] = - [0, 0, 0, 0, 0, 0, 0, 0, 0x982e7c01, 0xbed3875b, 0xd8d99f72, 0x12152f87, 0x6bde50c6, - 0xcf4a6e70, 0xd595d80f, 0x26b2716e, 0xadc666b0, 0x1d153624, 0x3c42d35a, 0x63ff540e, - 0xcc5573c0, 0x65f9ef17, 0x55bc28f2, 0x80dcc7f7, 0xf46eeddc, 0x5fdcefce, 0x553f7]; +static POW10TO128: [Digit; 14] = [ + 0, 0, 0, 0, 0x2e953e01, 0x3df9909, 0xf1538fd, 0x2374e42f, 0xd3cff5ec, 0xc404dc08, 0xbccdb0da, + 0xa6337f19, 0xe91f2603, 0x24e, +]; +static POW10TO256: [Digit; 27] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 0x982e7c01, 0xbed3875b, 0xd8d99f72, 0x12152f87, 0x6bde50c6, 0xcf4a6e70, + 0xd595d80f, 0x26b2716e, 0xadc666b0, 0x1d153624, 0x3c42d35a, 0x63ff540e, 0xcc5573c0, 0x65f9ef17, + 0x55bc28f2, 0x80dcc7f7, 0xf46eeddc, 0x5fdcefce, 0x553f7, +]; #[doc(hidden)] pub fn mul_pow10(x: &mut Big, n: usize) -> &mut Big { debug_assert!(n < 512); - if n & 7 != 0 { x.mul_small(POW10[n & 7]); } - if n & 8 != 0 { x.mul_small(POW10[8]); } - if n & 16 != 0 { x.mul_digits(&POW10TO16); } - if n & 32 != 0 { x.mul_digits(&POW10TO32); } - if n & 64 != 0 { x.mul_digits(&POW10TO64); } - if n & 128 != 0 { x.mul_digits(&POW10TO128); } - if n & 256 != 0 { x.mul_digits(&POW10TO256); } + if n & 7 != 0 { + x.mul_small(POW10[n & 7]); + } + if n & 8 != 0 { + x.mul_small(POW10[8]); + } + if n & 16 != 0 { + x.mul_digits(&POW10TO16); + } + if n & 32 != 0 { + x.mul_digits(&POW10TO32); + } + if n & 64 != 0 { + x.mul_digits(&POW10TO64); + } + if n & 128 != 0 { + x.mul_digits(&POW10TO128); + } + if n & 256 != 0 { + x.mul_digits(&POW10TO256); + } x } @@ -52,13 +68,30 @@ fn div_2pow10(x: &mut Big, mut n: usize) -> &mut Big { } // only usable when `x < 16 * scale`; `scaleN` should be `scale.mul_small(N)` -fn div_rem_upto_16<'a>(x: &'a mut Big, scale: &Big, - scale2: &Big, scale4: &Big, scale8: &Big) -> (u8, &'a mut Big) { +fn div_rem_upto_16<'a>( + x: &'a mut Big, + scale: &Big, + scale2: &Big, + scale4: &Big, + scale8: &Big, +) -> (u8, &'a mut Big) { let mut d = 0; - if *x >= *scale8 { x.sub(scale8); d += 8; } - if *x >= *scale4 { x.sub(scale4); d += 4; } - if *x >= *scale2 { x.sub(scale2); d += 2; } - if *x >= *scale { x.sub(scale); d += 1; } + if *x >= *scale8 { + x.sub(scale8); + d += 8; + } + if *x >= *scale4 { + x.sub(scale4); + d += 4; + } + if *x >= *scale2 { + x.sub(scale2); + d += 2; + } + if *x >= *scale { + x.sub(scale); + d += 1; + } debug_assert!(*x < *scale); (d, x) } @@ -85,7 +118,7 @@ pub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp assert!(buf.len() >= MAX_SIG_DIGITS); // `a.cmp(&b) < rounding` is `if d.inclusive {a <= b} else {a < b}` - let rounding = if d.inclusive {Ordering::Greater} else {Ordering::Equal}; + let rounding = if d.inclusive { Ordering::Greater } else { Ordering::Equal }; // estimate `k_0` from original inputs satisfying `10^(k_0-1) < high <= 10^(k_0+1)`. // the tight bound `k` satisfying `10^(k-1) < high <= 10^k` is calculated later. @@ -132,9 +165,12 @@ pub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp } // cache `(2, 4, 8) * scale` for digit generation. - let mut scale2 = scale.clone(); scale2.mul_pow2(1); - let mut scale4 = scale.clone(); scale4.mul_pow2(2); - let mut scale8 = scale.clone(); scale8.mul_pow2(3); + let mut scale2 = scale.clone(); + scale2.mul_pow2(1); + let mut scale4 = scale.clone(); + scale4.mul_pow2(2); + let mut scale8 = scale.clone(); + scale8.mul_pow2(3); let mut down; let mut up; @@ -186,7 +222,9 @@ pub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp // - keep generating otherwise. down = mant.cmp(&minus) < rounding; up = scale.cmp(mant.clone().add(&plus)) < rounding; - if down || up { break; } // we have the shortest representation, proceed to the rounding + if down || up { + break; + } // we have the shortest representation, proceed to the rounding // restore the invariants. // this makes the algorithm always terminating: `minus` and `plus` always increases, @@ -269,22 +307,40 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi if len > 0 { // cache `(2, 4, 8) * scale` for digit generation. // (this can be expensive, so do not calculate them when the buffer is empty.) - let mut scale2 = scale.clone(); scale2.mul_pow2(1); - let mut scale4 = scale.clone(); scale4.mul_pow2(2); - let mut scale8 = scale.clone(); scale8.mul_pow2(3); + let mut scale2 = scale.clone(); + scale2.mul_pow2(1); + let mut scale4 = scale.clone(); + scale4.mul_pow2(2); + let mut scale8 = scale.clone(); + scale8.mul_pow2(3); for i in 0..len { - if mant.is_zero() { // following digits are all zeroes, we stop here + if mant.is_zero() { + // following digits are all zeroes, we stop here // do *not* try to perform rounding! rather, fill remaining digits. - for c in &mut buf[i..len] { *c = b'0'; } + for c in &mut buf[i..len] { + *c = b'0'; + } return (len, k); } let mut d = 0; - if mant >= scale8 { mant.sub(&scale8); d += 8; } - if mant >= scale4 { mant.sub(&scale4); d += 4; } - if mant >= scale2 { mant.sub(&scale2); d += 2; } - if mant >= scale { mant.sub(&scale); d += 1; } + if mant >= scale8 { + mant.sub(&scale8); + d += 8; + } + if mant >= scale4 { + mant.sub(&scale4); + d += 4; + } + if mant >= scale2 { + mant.sub(&scale2); + d += 2; + } + if mant >= scale { + mant.sub(&scale); + d += 1; + } debug_assert!(mant < scale); debug_assert!(d < 10); buf[i] = b'0' + d; @@ -296,8 +352,9 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi // if the following digits are exactly 5000..., check the prior digit and try to // round to even (i.e., avoid rounding up when the prior digit is even). let order = mant.cmp(scale.mul_small(5)); - if order == Ordering::Greater || (order == Ordering::Equal && - (len == 0 || buf[len-1] & 1 == 1)) { + if order == Ordering::Greater + || (order == Ordering::Equal && (len == 0 || buf[len - 1] & 1 == 1)) + { // if rounding up changes the length, the exponent should also change. // but we've been requested a fixed number of digits, so do not alter the buffer... if let Some(c) = round_up(buf, len) { diff --git a/src/libcore/num/flt2dec/strategy/grisu.rs b/src/libcore/num/flt2dec/strategy/grisu.rs index 61b50ec8ca566..1e2db212dd0de 100644 --- a/src/libcore/num/flt2dec/strategy/grisu.rs +++ b/src/libcore/num/flt2dec/strategy/grisu.rs @@ -6,12 +6,13 @@ //! accurately with integers. SIGPLAN Not. 45, 6 (June 2010), 233-243. use crate::num::diy_float::Fp; -use crate::num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up}; - +use crate::num::flt2dec::{round_up, Decoded, MAX_SIG_DIGITS}; // see the comments in `format_shortest_opt` for the rationale. -#[doc(hidden)] pub const ALPHA: i16 = -60; -#[doc(hidden)] pub const GAMMA: i16 = -32; +#[doc(hidden)] +pub const ALPHA: i16 = -60; +#[doc(hidden)] +pub const GAMMA: i16 = -32; /* # the following Python code generates this table: @@ -24,92 +25,95 @@ for i in xrange(-308, 333, 8): */ #[doc(hidden)] -pub static CACHED_POW10: [(u64, i16, i16); 81] = [ // (f, e, k) +pub static CACHED_POW10: [(u64, i16, i16); 81] = [ + // (f, e, k) (0xe61acf033d1a45df, -1087, -308), (0xab70fe17c79ac6ca, -1060, -300), (0xff77b1fcbebcdc4f, -1034, -292), (0xbe5691ef416bd60c, -1007, -284), - (0x8dd01fad907ffc3c, -980, -276), - (0xd3515c2831559a83, -954, -268), - (0x9d71ac8fada6c9b5, -927, -260), - (0xea9c227723ee8bcb, -901, -252), - (0xaecc49914078536d, -874, -244), - (0x823c12795db6ce57, -847, -236), - (0xc21094364dfb5637, -821, -228), - (0x9096ea6f3848984f, -794, -220), - (0xd77485cb25823ac7, -768, -212), - (0xa086cfcd97bf97f4, -741, -204), - (0xef340a98172aace5, -715, -196), - (0xb23867fb2a35b28e, -688, -188), - (0x84c8d4dfd2c63f3b, -661, -180), - (0xc5dd44271ad3cdba, -635, -172), - (0x936b9fcebb25c996, -608, -164), - (0xdbac6c247d62a584, -582, -156), - (0xa3ab66580d5fdaf6, -555, -148), - (0xf3e2f893dec3f126, -529, -140), - (0xb5b5ada8aaff80b8, -502, -132), - (0x87625f056c7c4a8b, -475, -124), - (0xc9bcff6034c13053, -449, -116), - (0x964e858c91ba2655, -422, -108), - (0xdff9772470297ebd, -396, -100), - (0xa6dfbd9fb8e5b88f, -369, -92), - (0xf8a95fcf88747d94, -343, -84), - (0xb94470938fa89bcf, -316, -76), - (0x8a08f0f8bf0f156b, -289, -68), - (0xcdb02555653131b6, -263, -60), - (0x993fe2c6d07b7fac, -236, -52), - (0xe45c10c42a2b3b06, -210, -44), - (0xaa242499697392d3, -183, -36), - (0xfd87b5f28300ca0e, -157, -28), - (0xbce5086492111aeb, -130, -20), - (0x8cbccc096f5088cc, -103, -12), - (0xd1b71758e219652c, -77, -4), - (0x9c40000000000000, -50, 4), - (0xe8d4a51000000000, -24, 12), - (0xad78ebc5ac620000, 3, 20), - (0x813f3978f8940984, 30, 28), - (0xc097ce7bc90715b3, 56, 36), - (0x8f7e32ce7bea5c70, 83, 44), - (0xd5d238a4abe98068, 109, 52), - (0x9f4f2726179a2245, 136, 60), - (0xed63a231d4c4fb27, 162, 68), - (0xb0de65388cc8ada8, 189, 76), - (0x83c7088e1aab65db, 216, 84), - (0xc45d1df942711d9a, 242, 92), - (0x924d692ca61be758, 269, 100), - (0xda01ee641a708dea, 295, 108), - (0xa26da3999aef774a, 322, 116), - (0xf209787bb47d6b85, 348, 124), - (0xb454e4a179dd1877, 375, 132), - (0x865b86925b9bc5c2, 402, 140), - (0xc83553c5c8965d3d, 428, 148), - (0x952ab45cfa97a0b3, 455, 156), - (0xde469fbd99a05fe3, 481, 164), - (0xa59bc234db398c25, 508, 172), - (0xf6c69a72a3989f5c, 534, 180), - (0xb7dcbf5354e9bece, 561, 188), - (0x88fcf317f22241e2, 588, 196), - (0xcc20ce9bd35c78a5, 614, 204), - (0x98165af37b2153df, 641, 212), - (0xe2a0b5dc971f303a, 667, 220), - (0xa8d9d1535ce3b396, 694, 228), - (0xfb9b7cd9a4a7443c, 720, 236), - (0xbb764c4ca7a44410, 747, 244), - (0x8bab8eefb6409c1a, 774, 252), - (0xd01fef10a657842c, 800, 260), - (0x9b10a4e5e9913129, 827, 268), - (0xe7109bfba19c0c9d, 853, 276), - (0xac2820d9623bf429, 880, 284), - (0x80444b5e7aa7cf85, 907, 292), - (0xbf21e44003acdd2d, 933, 300), - (0x8e679c2f5e44ff8f, 960, 308), - (0xd433179d9c8cb841, 986, 316), - (0x9e19db92b4e31ba9, 1013, 324), - (0xeb96bf6ebadf77d9, 1039, 332), + (0x8dd01fad907ffc3c, -980, -276), + (0xd3515c2831559a83, -954, -268), + (0x9d71ac8fada6c9b5, -927, -260), + (0xea9c227723ee8bcb, -901, -252), + (0xaecc49914078536d, -874, -244), + (0x823c12795db6ce57, -847, -236), + (0xc21094364dfb5637, -821, -228), + (0x9096ea6f3848984f, -794, -220), + (0xd77485cb25823ac7, -768, -212), + (0xa086cfcd97bf97f4, -741, -204), + (0xef340a98172aace5, -715, -196), + (0xb23867fb2a35b28e, -688, -188), + (0x84c8d4dfd2c63f3b, -661, -180), + (0xc5dd44271ad3cdba, -635, -172), + (0x936b9fcebb25c996, -608, -164), + (0xdbac6c247d62a584, -582, -156), + (0xa3ab66580d5fdaf6, -555, -148), + (0xf3e2f893dec3f126, -529, -140), + (0xb5b5ada8aaff80b8, -502, -132), + (0x87625f056c7c4a8b, -475, -124), + (0xc9bcff6034c13053, -449, -116), + (0x964e858c91ba2655, -422, -108), + (0xdff9772470297ebd, -396, -100), + (0xa6dfbd9fb8e5b88f, -369, -92), + (0xf8a95fcf88747d94, -343, -84), + (0xb94470938fa89bcf, -316, -76), + (0x8a08f0f8bf0f156b, -289, -68), + (0xcdb02555653131b6, -263, -60), + (0x993fe2c6d07b7fac, -236, -52), + (0xe45c10c42a2b3b06, -210, -44), + (0xaa242499697392d3, -183, -36), + (0xfd87b5f28300ca0e, -157, -28), + (0xbce5086492111aeb, -130, -20), + (0x8cbccc096f5088cc, -103, -12), + (0xd1b71758e219652c, -77, -4), + (0x9c40000000000000, -50, 4), + (0xe8d4a51000000000, -24, 12), + (0xad78ebc5ac620000, 3, 20), + (0x813f3978f8940984, 30, 28), + (0xc097ce7bc90715b3, 56, 36), + (0x8f7e32ce7bea5c70, 83, 44), + (0xd5d238a4abe98068, 109, 52), + (0x9f4f2726179a2245, 136, 60), + (0xed63a231d4c4fb27, 162, 68), + (0xb0de65388cc8ada8, 189, 76), + (0x83c7088e1aab65db, 216, 84), + (0xc45d1df942711d9a, 242, 92), + (0x924d692ca61be758, 269, 100), + (0xda01ee641a708dea, 295, 108), + (0xa26da3999aef774a, 322, 116), + (0xf209787bb47d6b85, 348, 124), + (0xb454e4a179dd1877, 375, 132), + (0x865b86925b9bc5c2, 402, 140), + (0xc83553c5c8965d3d, 428, 148), + (0x952ab45cfa97a0b3, 455, 156), + (0xde469fbd99a05fe3, 481, 164), + (0xa59bc234db398c25, 508, 172), + (0xf6c69a72a3989f5c, 534, 180), + (0xb7dcbf5354e9bece, 561, 188), + (0x88fcf317f22241e2, 588, 196), + (0xcc20ce9bd35c78a5, 614, 204), + (0x98165af37b2153df, 641, 212), + (0xe2a0b5dc971f303a, 667, 220), + (0xa8d9d1535ce3b396, 694, 228), + (0xfb9b7cd9a4a7443c, 720, 236), + (0xbb764c4ca7a44410, 747, 244), + (0x8bab8eefb6409c1a, 774, 252), + (0xd01fef10a657842c, 800, 260), + (0x9b10a4e5e9913129, 827, 268), + (0xe7109bfba19c0c9d, 853, 276), + (0xac2820d9623bf429, 880, 284), + (0x80444b5e7aa7cf85, 907, 292), + (0xbf21e44003acdd2d, 933, 300), + (0x8e679c2f5e44ff8f, 960, 308), + (0xd433179d9c8cb841, 986, 316), + (0x9e19db92b4e31ba9, 1013, 324), + (0xeb96bf6ebadf77d9, 1039, 332), ]; -#[doc(hidden)] pub const CACHED_POW10_FIRST_E: i16 = -1087; -#[doc(hidden)] pub const CACHED_POW10_LAST_E: i16 = 1039; +#[doc(hidden)] +pub const CACHED_POW10_FIRST_E: i16 = -1087; +#[doc(hidden)] +pub const CACHED_POW10_LAST_E: i16 = 1039; #[doc(hidden)] pub fn cached_power(alpha: i16, gamma: i16) -> (i16, Fp) { @@ -128,30 +132,39 @@ pub fn max_pow10_no_more_than(x: u32) -> (u8, u32) { debug_assert!(x > 0); const X9: u32 = 10_0000_0000; - const X8: u32 = 1_0000_0000; - const X7: u32 = 1000_0000; - const X6: u32 = 100_0000; - const X5: u32 = 10_0000; - const X4: u32 = 1_0000; - const X3: u32 = 1000; - const X2: u32 = 100; - const X1: u32 = 10; + const X8: u32 = 1_0000_0000; + const X7: u32 = 1000_0000; + const X6: u32 = 100_0000; + const X5: u32 = 10_0000; + const X4: u32 = 1_0000; + const X3: u32 = 1000; + const X2: u32 = 100; + const X1: u32 = 10; if x < X4 { - if x < X2 { if x < X1 {(0, 1)} else {(1, X1)} } - else { if x < X3 {(2, X2)} else {(3, X3)} } + if x < X2 { + if x < X1 { (0, 1) } else { (1, X1) } + } else { + if x < X3 { (2, X2) } else { (3, X3) } + } } else { - if x < X6 { if x < X5 {(4, X4)} else {(5, X5)} } - else if x < X8 { if x < X7 {(6, X6)} else {(7, X7)} } - else { if x < X9 {(8, X8)} else {(9, X9)} } + if x < X6 { + if x < X5 { (4, X4) } else { (5, X5) } + } else if x < X8 { + if x < X7 { (6, X6) } else { (7, X7) } + } else { + if x < X9 { (8, X8) } else { (9, X9) } + } } } /// The shortest mode implementation for Grisu. /// /// It returns `None` when it would return an inexact representation otherwise. -pub fn format_shortest_opt(d: &Decoded, - buf: &mut [u8]) -> Option<(/*#digits*/ usize, /*exp*/ i16)> { +pub fn format_shortest_opt( + d: &Decoded, + buf: &mut [u8], +) -> Option<(/*#digits*/ usize, /*exp*/ i16)> { assert!(d.mant > 0); assert!(d.minus > 0); assert!(d.plus > 0); @@ -208,8 +221,8 @@ pub fn format_shortest_opt(d: &Decoded, // we start with the correct repr within the unsafe region, and try to find the closest repr // to `v` which is also within the safe region. if we can't, we give up. let plus1 = plus.f + 1; -// let plus0 = plus.f - 1; // only for explanation -// let minus0 = minus.f + 1; // only for explanation + // let plus0 = plus.f - 1; // only for explanation + // let minus0 = minus.f + 1; // only for explanation let minus1 = minus.f - 1; let e = -plus.e as usize; // shared exponent @@ -235,14 +248,15 @@ pub fn format_shortest_opt(d: &Decoded, // (e.g., `x` = 32000, `y` = 32777; `kappa` = 2 since `y mod 10^3 = 777 < y - x = 777`.) // the algorithm relies on the later verification phase to exclude `y`. let delta1 = plus1 - minus1; -// let delta1int = (delta1 >> e) as usize; // only for explanation + // let delta1int = (delta1 >> e) as usize; // only for explanation let delta1frac = delta1 & ((1 << e) - 1); // render integral parts, while checking for the accuracy at each step. let mut kappa = max_kappa as i16; let mut ten_kappa = max_ten_kappa; // 10^kappa let mut remainder = plus1int; // digits yet to be rendered - loop { // we always have at least one digit to render, as `plus1 >= 10^kappa` + loop { + // we always have at least one digit to render, as `plus1 >= 10^kappa` // invariants: // - `delta1int <= remainder < 10^(kappa+1)` // - `plus1int = d[0..n-1] * 10^(kappa+1) + remainder` @@ -281,7 +295,8 @@ pub fn format_shortest_opt(d: &Decoded, let mut remainder = plus1frac; let mut threshold = delta1frac; let mut ulp = 1; - loop { // the next digit should be significant as we've tested that before breaking out + loop { + // the next digit should be significant as we've tested that before breaking out // invariants, where `m = max_kappa + 1` (# of digits in the integral part): // - `remainder < 2^e` // - `plus1frac * 10^(n-m) = d[m..n-1] * 2^e + remainder` @@ -300,8 +315,15 @@ pub fn format_shortest_opt(d: &Decoded, if r < threshold { let ten_kappa = 1 << e; // implicit divisor - return round_and_weed(&mut buf[..i], exp, r, threshold, - (plus1 - v.f) * ulp, ten_kappa, ulp); + return round_and_weed( + &mut buf[..i], + exp, + r, + threshold, + (plus1 - v.f) * ulp, + ten_kappa, + ulp, + ); } // restore invariants @@ -325,8 +347,15 @@ pub fn format_shortest_opt(d: &Decoded, // - `plus1v = (plus1 - v) * k` (and also, `threshold > plus1v` from prior invariants) // - `ten_kappa = 10^kappa * k` // - `ulp = 2^-e * k` - fn round_and_weed(buf: &mut [u8], exp: i16, remainder: u64, threshold: u64, plus1v: u64, - ten_kappa: u64, ulp: u64) -> Option<(usize, i16)> { + fn round_and_weed( + buf: &mut [u8], + exp: i16, + remainder: u64, + threshold: u64, + plus1v: u64, + ten_kappa: u64, + ulp: u64, + ) -> Option<(usize, i16)> { assert!(!buf.is_empty()); // produce two approximations to `v` (actually `plus1 - v`) within 1.5 ulps. @@ -381,10 +410,11 @@ pub fn format_shortest_opt(d: &Decoded, // // consequently, we should stop when `TC1 || TC2 || (TC3a && TC3b)`. the following is // equal to its inverse, `!TC1 && !TC2 && (!TC3a || !TC3b)`. - while plus1w < plus1v_up && - threshold - plus1w >= ten_kappa && - (plus1w + ten_kappa < plus1v_up || - plus1v_up - plus1w >= plus1w + ten_kappa - plus1v_up) { + while plus1w < plus1v_up + && threshold - plus1w >= ten_kappa + && (plus1w + ten_kappa < plus1v_up + || plus1v_up - plus1w >= plus1w + ten_kappa - plus1v_up) + { *last -= 1; debug_assert!(*last > b'0'); // the shortest repr cannot end with `0` plus1w += ten_kappa; @@ -395,10 +425,11 @@ pub fn format_shortest_opt(d: &Decoded, // // this is simply same to the terminating conditions for `v + 1 ulp`, with all `plus1v_up` // replaced by `plus1v_down` instead. overflow analysis equally holds. - if plus1w < plus1v_down && - threshold - plus1w >= ten_kappa && - (plus1w + ten_kappa < plus1v_down || - plus1v_down - plus1w >= plus1w + ten_kappa - plus1v_down) { + if plus1w < plus1v_down + && threshold - plus1w >= ten_kappa + && (plus1w + ten_kappa < plus1v_down + || plus1v_down - plus1w >= plus1w + ten_kappa - plus1v_down) + { return None; } @@ -428,8 +459,11 @@ pub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp /// The exact and fixed mode implementation for Grisu. /// /// It returns `None` when it would return an inexact representation otherwise. -pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16) - -> Option<(/*#digits*/ usize, /*exp*/ i16)> { +pub fn format_exact_opt( + d: &Decoded, + buf: &mut [u8], + limit: i16, +) -> Option<(/*#digits*/ usize, /*exp*/ i16)> { assert!(d.mant > 0); assert!(d.mant < (1 << 61)); // we need at least three bits of additional precision assert!(!buf.is_empty()); @@ -489,7 +523,8 @@ pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16) let mut kappa = max_kappa as i16; let mut ten_kappa = max_ten_kappa; // 10^kappa let mut remainder = vint; // digits yet to be rendered - loop { // we always have at least one digit to render + loop { + // we always have at least one digit to render // invariants: // - `remainder < 10^(kappa+1)` // - `vint = d[0..n-1] * 10^(kappa+1) + remainder` @@ -575,8 +610,15 @@ pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16) // - `remainder = (v % 10^kappa) * k` // - `ten_kappa = 10^kappa * k` // - `ulp = 2^-e * k` - fn possibly_round(buf: &mut [u8], mut len: usize, mut exp: i16, limit: i16, - remainder: u64, ten_kappa: u64, ulp: u64) -> Option<(usize, i16)> { + fn possibly_round( + buf: &mut [u8], + mut len: usize, + mut exp: i16, + limit: i16, + remainder: u64, + ten_kappa: u64, + ulp: u64, + ) -> Option<(usize, i16)> { debug_assert!(remainder < ten_kappa); // 10^kappa @@ -593,7 +635,9 @@ pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16) // // error is too large that there are at least three possible representations // between `v - 1 ulp` and `v + 1 ulp`. we cannot determine which one is correct. - if ulp >= ten_kappa { return None; } + if ulp >= ten_kappa { + return None; + } // 10^kappa // :<------->: @@ -607,7 +651,9 @@ pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16) // in fact, 1/2 ulp is enough to introduce two possible representations. // (remember that we need a unique representation for both `v - 1 ulp` and `v + 1 ulp`.) // this won't overflow, as `ulp < ten_kappa` from the first check. - if ten_kappa - ulp <= ulp { return None; } + if ten_kappa - ulp <= ulp { + return None; + } // remainder // :<->| : diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs index 5fe9895d8d24f..0ddfbd02aa5b0 100644 --- a/src/libcore/num/wrapping.rs +++ b/src/libcore/num/wrapping.rs @@ -4,7 +4,7 @@ use crate::ops::*; #[allow(unused_macros)] macro_rules! sh_impl_signed { - ($t:ident, $f:ident) => ( + ($t:ident, $f:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl Shl<$f> for Wrapping<$t> { type Output = Wrapping<$t>; @@ -19,7 +19,7 @@ macro_rules! sh_impl_signed { } } forward_ref_binop! { impl Shl, shl for Wrapping<$t>, $f, - #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } + #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShlAssign<$f> for Wrapping<$t> { @@ -44,7 +44,7 @@ macro_rules! sh_impl_signed { } } forward_ref_binop! { impl Shr, shr for Wrapping<$t>, $f, - #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } + #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShrAssign<$f> for Wrapping<$t> { @@ -54,11 +54,11 @@ macro_rules! sh_impl_signed { } } forward_ref_op_assign! { impl ShrAssign, shr_assign for Wrapping<$t>, $f } - ) + }; } macro_rules! sh_impl_unsigned { - ($t:ident, $f:ident) => ( + ($t:ident, $f:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl Shl<$f> for Wrapping<$t> { type Output = Wrapping<$t>; @@ -69,7 +69,7 @@ macro_rules! sh_impl_unsigned { } } forward_ref_binop! { impl Shl, shl for Wrapping<$t>, $f, - #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } + #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShlAssign<$f> for Wrapping<$t> { @@ -90,7 +90,7 @@ macro_rules! sh_impl_unsigned { } } forward_ref_binop! { impl Shr, shr for Wrapping<$t>, $f, - #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } + #[stable(feature = "wrapping_ref_ops", since = "1.39.0")] } #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShrAssign<$f> for Wrapping<$t> { @@ -100,7 +100,7 @@ macro_rules! sh_impl_unsigned { } } forward_ref_op_assign! { impl ShrAssign, shr_assign for Wrapping<$t>, $f } - ) + }; } // FIXME (#23545): uncomment the remaining impls diff --git a/src/libcore/ops/arith.rs b/src/libcore/ops/arith.rs index 3c009d644c64e..59a72799e2567 100644 --- a/src/libcore/ops/arith.rs +++ b/src/libcore/ops/arith.rs @@ -66,19 +66,13 @@ #[lang = "add"] #[stable(feature = "rust1", since = "1.0.0")] #[rustc_on_unimplemented( - on( - all(_Self="{integer}", Rhs="{float}"), - message="cannot add a float to an integer", - ), - on( - all(_Self="{float}", Rhs="{integer}"), - message="cannot add an integer to a float", - ), - message="cannot add `{Rhs}` to `{Self}`", - label="no implementation for `{Self} + {Rhs}`", + on(all(_Self = "{integer}", Rhs = "{float}"), message = "cannot add a float to an integer",), + on(all(_Self = "{float}", Rhs = "{integer}"), message = "cannot add an integer to a float",), + message = "cannot add `{Rhs}` to `{Self}`", + label = "no implementation for `{Self} + {Rhs}`" )] #[doc(alias = "+")] -pub trait Add { +pub trait Add { /// The resulting type after applying the `+` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -173,10 +167,12 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "sub"] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="cannot subtract `{Rhs}` from `{Self}`", - label="no implementation for `{Self} - {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot subtract `{Rhs}` from `{Self}`", + label = "no implementation for `{Self} - {Rhs}`" +)] #[doc(alias = "-")] -pub trait Sub { +pub trait Sub { /// The resulting type after applying the `-` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -293,10 +289,12 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "mul"] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="cannot multiply `{Rhs}` to `{Self}`", - label="no implementation for `{Self} * {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot multiply `{Rhs}` to `{Self}`", + label = "no implementation for `{Self} * {Rhs}`" +)] #[doc(alias = "*")] -pub trait Mul { +pub trait Mul { /// The resulting type after applying the `*` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -417,10 +415,12 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "div"] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="cannot divide `{Self}` by `{Rhs}`", - label="no implementation for `{Self} / {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot divide `{Self}` by `{Rhs}`", + label = "no implementation for `{Self} / {Rhs}`" +)] #[doc(alias = "/")] -pub trait Div { +pub trait Div { /// The resulting type after applying the `/` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -502,10 +502,12 @@ div_impl_float! { f32 f64 } /// ``` #[lang = "rem"] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="cannot mod `{Self}` by `{Rhs}`", - label="no implementation for `{Self} % {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot mod `{Self}` by `{Rhs}`", + label = "no implementation for `{Self} % {Rhs}`" +)] #[doc(alias = "%")] -pub trait Rem { +pub trait Rem { /// The resulting type after applying the `%` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -534,7 +536,6 @@ macro_rules! rem_impl_integer { rem_impl_integer! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } - macro_rules! rem_impl_float { ($($t:ty)*) => ($( @@ -616,8 +617,6 @@ pub trait Neg { fn neg(self) -> Self::Output; } - - macro_rules! neg_impl_core { ($id:ident => $body:expr, $($t:ty)*) => ($( #[stable(feature = "rust1", since = "1.0.0")] @@ -679,11 +678,13 @@ neg_impl_numeric! { isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "add_assign"] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="cannot add-assign `{Rhs}` to `{Self}`", - label="no implementation for `{Self} += {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot add-assign `{Rhs}` to `{Self}`", + label = "no implementation for `{Self} += {Rhs}`" +)] #[doc(alias = "+")] #[doc(alias = "+=")] -pub trait AddAssign { +pub trait AddAssign { /// Performs the `+=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn add_assign(&mut self, rhs: Rhs); @@ -735,11 +736,13 @@ add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "sub_assign"] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="cannot subtract-assign `{Rhs}` from `{Self}`", - label="no implementation for `{Self} -= {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot subtract-assign `{Rhs}` from `{Self}`", + label = "no implementation for `{Self} -= {Rhs}`" +)] #[doc(alias = "-")] #[doc(alias = "-=")] -pub trait SubAssign { +pub trait SubAssign { /// Performs the `-=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn sub_assign(&mut self, rhs: Rhs); @@ -782,11 +785,13 @@ sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "mul_assign"] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="cannot multiply-assign `{Rhs}` to `{Self}`", - label="no implementation for `{Self} *= {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot multiply-assign `{Rhs}` to `{Self}`", + label = "no implementation for `{Self} *= {Rhs}`" +)] #[doc(alias = "*")] #[doc(alias = "*=")] -pub trait MulAssign { +pub trait MulAssign { /// Performs the `*=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn mul_assign(&mut self, rhs: Rhs); @@ -829,11 +834,13 @@ mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "div_assign"] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="cannot divide-assign `{Self}` by `{Rhs}`", - label="no implementation for `{Self} /= {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot divide-assign `{Self}` by `{Rhs}`", + label = "no implementation for `{Self} /= {Rhs}`" +)] #[doc(alias = "/")] #[doc(alias = "/=")] -pub trait DivAssign { +pub trait DivAssign { /// Performs the `/=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn div_assign(&mut self, rhs: Rhs); @@ -879,11 +886,13 @@ div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 } /// ``` #[lang = "rem_assign"] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="cannot mod-assign `{Self}` by `{Rhs}``", - label="no implementation for `{Self} %= {Rhs}`")] +#[rustc_on_unimplemented( + message = "cannot mod-assign `{Self}` by `{Rhs}``", + label = "no implementation for `{Self} %= {Rhs}`" +)] #[doc(alias = "%")] #[doc(alias = "%=")] -pub trait RemAssign { +pub trait RemAssign { /// Performs the `%=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn rem_assign(&mut self, rhs: Rhs); diff --git a/src/libcore/ops/bit.rs b/src/libcore/ops/bit.rs index a8f862f6c05a5..bcfff4a223bec 100644 --- a/src/libcore/ops/bit.rs +++ b/src/libcore/ops/bit.rs @@ -112,9 +112,11 @@ not_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "bitand"] #[doc(alias = "&")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} & {Rhs}`", - label="no implementation for `{Self} & {Rhs}`")] -pub trait BitAnd { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} & {Rhs}`", + label = "no implementation for `{Self} & {Rhs}`" +)] +pub trait BitAnd { /// The resulting type after applying the `&` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -196,9 +198,11 @@ bitand_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "bitor"] #[doc(alias = "|")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} | {Rhs}`", - label="no implementation for `{Self} | {Rhs}`")] -pub trait BitOr { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} | {Rhs}`", + label = "no implementation for `{Self} | {Rhs}`" +)] +pub trait BitOr { /// The resulting type after applying the `|` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -283,9 +287,11 @@ bitor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "bitxor"] #[doc(alias = "^")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} ^ {Rhs}`", - label="no implementation for `{Self} ^ {Rhs}`")] -pub trait BitXor { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} ^ {Rhs}`", + label = "no implementation for `{Self} ^ {Rhs}`" +)] +pub trait BitXor { /// The resulting type after applying the `^` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -371,9 +377,11 @@ bitxor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "shl"] #[doc(alias = "<<")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} << {Rhs}`", - label="no implementation for `{Self} << {Rhs}`")] -pub trait Shl { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} << {Rhs}`", + label = "no implementation for `{Self} << {Rhs}`" +)] +pub trait Shl { /// The resulting type after applying the `<<` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -385,7 +393,7 @@ pub trait Shl { } macro_rules! shl_impl { - ($t:ty, $f:ty) => ( + ($t:ty, $f:ty) => { #[stable(feature = "rust1", since = "1.0.0")] impl Shl<$f> for $t { type Output = $t; @@ -398,7 +406,7 @@ macro_rules! shl_impl { } forward_ref_binop! { impl Shl, shl for $t, $f } - ) + }; } macro_rules! shl_impl_all { @@ -480,9 +488,11 @@ shl_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 isize i128 } #[lang = "shr"] #[doc(alias = ">>")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} >> {Rhs}`", - label="no implementation for `{Self} >> {Rhs}`")] -pub trait Shr { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} >> {Rhs}`", + label = "no implementation for `{Self} >> {Rhs}`" +)] +pub trait Shr { /// The resulting type after applying the `>>` operator. #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -494,7 +504,7 @@ pub trait Shr { } macro_rules! shr_impl { - ($t:ty, $f:ty) => ( + ($t:ty, $f:ty) => { #[stable(feature = "rust1", since = "1.0.0")] impl Shr<$f> for $t { type Output = $t; @@ -507,7 +517,7 @@ macro_rules! shr_impl { } forward_ref_binop! { impl Shr, shr for $t, $f } - ) + }; } macro_rules! shr_impl_all { @@ -596,9 +606,11 @@ shr_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize } #[lang = "bitand_assign"] #[doc(alias = "&=")] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} &= {Rhs}`", - label="no implementation for `{Self} &= {Rhs}`")] -pub trait BitAndAssign { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} &= {Rhs}`", + label = "no implementation for `{Self} &= {Rhs}`" +)] +pub trait BitAndAssign { /// Performs the `&=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn bitand_assign(&mut self, rhs: Rhs); @@ -645,9 +657,11 @@ bitand_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "bitor_assign"] #[doc(alias = "|=")] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} |= {Rhs}`", - label="no implementation for `{Self} |= {Rhs}`")] -pub trait BitOrAssign { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} |= {Rhs}`", + label = "no implementation for `{Self} |= {Rhs}`" +)] +pub trait BitOrAssign { /// Performs the `|=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn bitor_assign(&mut self, rhs: Rhs); @@ -694,9 +708,11 @@ bitor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "bitxor_assign"] #[doc(alias = "^=")] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} ^= {Rhs}`", - label="no implementation for `{Self} ^= {Rhs}`")] -pub trait BitXorAssign { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} ^= {Rhs}`", + label = "no implementation for `{Self} ^= {Rhs}`" +)] +pub trait BitXorAssign { /// Performs the `^=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn bitxor_assign(&mut self, rhs: Rhs); @@ -741,16 +757,18 @@ bitxor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 } #[lang = "shl_assign"] #[doc(alias = "<<=")] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} <<= {Rhs}`", - label="no implementation for `{Self} <<= {Rhs}`")] -pub trait ShlAssign { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} <<= {Rhs}`", + label = "no implementation for `{Self} <<= {Rhs}`" +)] +pub trait ShlAssign { /// Performs the `<<=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn shl_assign(&mut self, rhs: Rhs); } macro_rules! shl_assign_impl { - ($t:ty, $f:ty) => ( + ($t:ty, $f:ty) => { #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShlAssign<$f> for $t { #[inline] @@ -761,7 +779,7 @@ macro_rules! shl_assign_impl { } forward_ref_op_assign! { impl ShlAssign, shl_assign for $t, $f } - ) + }; } macro_rules! shl_assign_impl_all { @@ -809,16 +827,18 @@ shl_assign_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize } #[lang = "shr_assign"] #[doc(alias = ">>=")] #[stable(feature = "op_assign_traits", since = "1.8.0")] -#[rustc_on_unimplemented(message="no implementation for `{Self} >>= {Rhs}`", - label="no implementation for `{Self} >>= {Rhs}`")] -pub trait ShrAssign { +#[rustc_on_unimplemented( + message = "no implementation for `{Self} >>= {Rhs}`", + label = "no implementation for `{Self} >>= {Rhs}`" +)] +pub trait ShrAssign { /// Performs the `>>=` operation. #[stable(feature = "op_assign_traits", since = "1.8.0")] fn shr_assign(&mut self, rhs: Rhs); } macro_rules! shr_assign_impl { - ($t:ty, $f:ty) => ( + ($t:ty, $f:ty) => { #[stable(feature = "op_assign_traits", since = "1.8.0")] impl ShrAssign<$f> for $t { #[inline] @@ -829,7 +849,7 @@ macro_rules! shr_assign_impl { } forward_ref_op_assign! { impl ShrAssign, shr_assign for $t, $f } - ) + }; } macro_rules! shr_assign_impl_all { diff --git a/src/libcore/ops/deref.rs b/src/libcore/ops/deref.rs index ce0d3fd01f78f..f521355a90722 100644 --- a/src/libcore/ops/deref.rs +++ b/src/libcore/ops/deref.rs @@ -76,14 +76,18 @@ pub trait Deref { impl Deref for &T { type Target = T; - fn deref(&self) -> &T { *self } + fn deref(&self) -> &T { + *self + } } #[stable(feature = "rust1", since = "1.0.0")] impl Deref for &mut T { type Target = T; - fn deref(&self) -> &T { *self } + fn deref(&self) -> &T { + *self + } } /// Used for mutable dereferencing operations, like in `*v = 1;`. @@ -165,7 +169,9 @@ pub trait DerefMut: Deref { #[stable(feature = "rust1", since = "1.0.0")] impl DerefMut for &mut T { - fn deref_mut(&mut self) -> &mut T { *self } + fn deref_mut(&mut self) -> &mut T { + *self + } } /// Indicates that a struct can be used as a method receiver, without the diff --git a/src/libcore/ops/function.rs b/src/libcore/ops/function.rs index 35790324a2f62..505a65cee3de0 100644 --- a/src/libcore/ops/function.rs +++ b/src/libcore/ops/function.rs @@ -57,13 +57,16 @@ #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] #[rustc_on_unimplemented( - on(Args="()", note="wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}"), - message="expected a `{Fn}<{Args}>` closure, found `{Self}`", - label="expected an `Fn<{Args}>` closure, found `{Self}`", + on( + Args = "()", + note = "wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}" + ), + message = "expected a `{Fn}<{Args}>` closure, found `{Self}`", + label = "expected an `Fn<{Args}>` closure, found `{Self}`" )] #[fundamental] // so that regex can rely that `&str: !FnMut` #[must_use = "closures are lazy and do nothing unless called"] -pub trait Fn : FnMut { +pub trait Fn: FnMut { /// Performs the call operation. #[unstable(feature = "fn_traits", issue = "29625")] extern "rust-call" fn call(&self, args: Args) -> Self::Output; @@ -136,13 +139,16 @@ pub trait Fn : FnMut { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] #[rustc_on_unimplemented( - on(Args="()", note="wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}"), - message="expected a `{FnMut}<{Args}>` closure, found `{Self}`", - label="expected an `FnMut<{Args}>` closure, found `{Self}`", + on( + Args = "()", + note = "wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}" + ), + message = "expected a `{FnMut}<{Args}>` closure, found `{Self}`", + label = "expected an `FnMut<{Args}>` closure, found `{Self}`" )] #[fundamental] // so that regex can rely that `&str: !FnMut` #[must_use = "closures are lazy and do nothing unless called"] -pub trait FnMut : FnOnce { +pub trait FnMut: FnOnce { /// Performs the call operation. #[unstable(feature = "fn_traits", issue = "29625")] extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; @@ -207,9 +213,12 @@ pub trait FnMut : FnOnce { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] #[rustc_on_unimplemented( - on(Args="()", note="wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}"), - message="expected a `{FnOnce}<{Args}>` closure, found `{Self}`", - label="expected an `FnOnce<{Args}>` closure, found `{Self}`", + on( + Args = "()", + note = "wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}" + ), + message = "expected a `{FnOnce}<{Args}>` closure, found `{Self}`", + label = "expected an `FnOnce<{Args}>` closure, found `{Self}`" )] #[fundamental] // so that regex can rely that `&str: !FnMut` #[must_use = "closures are lazy and do nothing unless called"] @@ -225,8 +234,9 @@ pub trait FnOnce { mod impls { #[stable(feature = "rust1", since = "1.0.0")] - impl Fn for &F - where F : Fn + impl Fn for &F + where + F: Fn, { extern "rust-call" fn call(&self, args: A) -> F::Output { (**self).call(args) @@ -234,8 +244,9 @@ mod impls { } #[stable(feature = "rust1", since = "1.0.0")] - impl FnMut for &F - where F : Fn + impl FnMut for &F + where + F: Fn, { extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output { (**self).call(args) @@ -243,8 +254,9 @@ mod impls { } #[stable(feature = "rust1", since = "1.0.0")] - impl FnOnce for &F - where F : Fn + impl FnOnce for &F + where + F: Fn, { type Output = F::Output; @@ -254,8 +266,9 @@ mod impls { } #[stable(feature = "rust1", since = "1.0.0")] - impl FnMut for &mut F - where F : FnMut + impl FnMut for &mut F + where + F: FnMut, { extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output { (*self).call_mut(args) @@ -263,8 +276,9 @@ mod impls { } #[stable(feature = "rust1", since = "1.0.0")] - impl FnOnce for &mut F - where F : FnMut + impl FnOnce for &mut F + where + F: FnMut, { type Output = F::Output; extern "rust-call" fn call_once(self, args: A) -> F::Output { diff --git a/src/libcore/ops/index.rs b/src/libcore/ops/index.rs index 9cff474a76030..aae0691122415 100644 --- a/src/libcore/ops/index.rs +++ b/src/libcore/ops/index.rs @@ -51,8 +51,8 @@ /// ``` #[lang = "index"] #[rustc_on_unimplemented( - message="the type `{Self}` cannot be indexed by `{Idx}`", - label="`{Self}` cannot be indexed by `{Idx}`", + message = "the type `{Self}` cannot be indexed by `{Idx}`", + label = "`{Self}` cannot be indexed by `{Idx}`" )] #[stable(feature = "rust1", since = "1.0.0")] #[doc(alias = "]")] @@ -142,22 +142,22 @@ pub trait Index { #[lang = "index_mut"] #[rustc_on_unimplemented( on( - _Self="&str", - note="you can use `.chars().nth()` or `.bytes().nth()` + _Self = "&str", + note = "you can use `.chars().nth()` or `.bytes().nth()` see chapter in The Book " ), on( - _Self="str", - note="you can use `.chars().nth()` or `.bytes().nth()` + _Self = "str", + note = "you can use `.chars().nth()` or `.bytes().nth()` see chapter in The Book " ), on( - _Self="std::string::String", - note="you can use `.chars().nth()` or `.bytes().nth()` + _Self = "std::string::String", + note = "you can use `.chars().nth()` or `.bytes().nth()` see chapter in The Book " ), - message="the type `{Self}` cannot be mutably indexed by `{Idx}`", - label="`{Self}` cannot be mutably indexed by `{Idx}`", + message = "the type `{Self}` cannot be mutably indexed by `{Idx}`", + label = "`{Self}` cannot be mutably indexed by `{Idx}`" )] #[stable(feature = "rust1", since = "1.0.0")] #[doc(alias = "[")] diff --git a/src/libcore/ops/mod.rs b/src/libcore/ops/mod.rs index 5d1d3efd4120f..80ab906961ee7 100644 --- a/src/libcore/ops/mod.rs +++ b/src/libcore/ops/mod.rs @@ -156,12 +156,12 @@ mod r#try; mod unsize; #[stable(feature = "rust1", since = "1.0.0")] -pub use self::arith::{Add, Sub, Mul, Div, Rem, Neg}; +pub use self::arith::{Add, Div, Mul, Neg, Rem, Sub}; #[stable(feature = "op_assign_traits", since = "1.8.0")] -pub use self::arith::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign}; +pub use self::arith::{AddAssign, DivAssign, MulAssign, RemAssign, SubAssign}; #[stable(feature = "rust1", since = "1.0.0")] -pub use self::bit::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; +pub use self::bit::{BitAnd, BitOr, BitXor, Not, Shl, Shr}; #[stable(feature = "op_assign_traits", since = "1.8.0")] pub use self::bit::{BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign}; @@ -184,7 +184,7 @@ pub use self::index::{Index, IndexMut}; pub use self::range::{Range, RangeFrom, RangeFull, RangeTo}; #[stable(feature = "inclusive_range", since = "1.26.0")] -pub use self::range::{RangeInclusive, RangeToInclusive, RangeBounds, Bound}; +pub use self::range::{Bound, RangeBounds, RangeInclusive, RangeToInclusive}; #[unstable(feature = "try_trait", issue = "42327")] pub use self::r#try::Try; diff --git a/src/libcore/ops/range.rs b/src/libcore/ops/range.rs index 1b4c4218cc15b..a2250337a4dca 100644 --- a/src/libcore/ops/range.rs +++ b/src/libcore/ops/range.rs @@ -399,11 +399,7 @@ impl RangeInclusive { #[inline] #[rustc_promotable] pub const fn new(start: Idx, end: Idx) -> Self { - Self { - start, - end, - is_empty: None, - } + Self { start, end, is_empty: None } } /// Returns the lower bound of the range (inclusive). diff --git a/src/libcore/ops/unsize.rs b/src/libcore/ops/unsize.rs index d29147645f7ef..80fb5642a6a76 100644 --- a/src/libcore/ops/unsize.rs +++ b/src/libcore/ops/unsize.rs @@ -39,35 +39,34 @@ pub trait CoerceUnsized { // &mut T -> &mut U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {} // &mut T -> &U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, 'b: 'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {} +impl<'a, 'b: 'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {} // &mut T -> *mut U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {} // &mut T -> *const U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {} // &T -> &U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, 'b: 'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b T {} +impl<'a, 'b: 'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b T {} // &T -> *const U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a T {} // *mut T -> *mut U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl, U: ?Sized> CoerceUnsized<*mut U> for *mut T {} +impl, U: ?Sized> CoerceUnsized<*mut U> for *mut T {} // *mut T -> *const U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl, U: ?Sized> CoerceUnsized<*const U> for *mut T {} +impl, U: ?Sized> CoerceUnsized<*const U> for *mut T {} // *const T -> *const U #[unstable(feature = "coerce_unsized", issue = "27732")] -impl, U: ?Sized> CoerceUnsized<*const U> for *const T {} - +impl, U: ?Sized> CoerceUnsized<*const U> for *const T {} /// This is used for object safety, to check that a method's receiver type can be dispatched on. /// @@ -90,13 +89,13 @@ pub trait DispatchFromDyn { // &T -> &U #[unstable(feature = "dispatch_from_dyn", issue = "0")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> DispatchFromDyn<&'a U> for &'a T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> DispatchFromDyn<&'a U> for &'a T {} // &mut T -> &mut U #[unstable(feature = "dispatch_from_dyn", issue = "0")] -impl<'a, T: ?Sized+Unsize, U: ?Sized> DispatchFromDyn<&'a mut U> for &'a mut T {} +impl<'a, T: ?Sized + Unsize, U: ?Sized> DispatchFromDyn<&'a mut U> for &'a mut T {} // *const T -> *const U #[unstable(feature = "dispatch_from_dyn", issue = "0")] -impl, U: ?Sized> DispatchFromDyn<*const U> for *const T {} +impl, U: ?Sized> DispatchFromDyn<*const U> for *const T {} // *mut T -> *mut U #[unstable(feature = "dispatch_from_dyn", issue = "0")] -impl, U: ?Sized> DispatchFromDyn<*mut U> for *mut T {} +impl, U: ?Sized> DispatchFromDyn<*mut U> for *mut T {} diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 958f31c0fd22a..2066a484dac80 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -138,8 +138,11 @@ #![stable(feature = "rust1", since = "1.0.0")] use crate::iter::{FromIterator, FusedIterator, TrustedLen}; -use crate::{convert, fmt, hint, mem, ops::{self, Deref, DerefMut}}; use crate::pin::Pin; +use crate::{ + convert, fmt, hint, mem, + ops::{self, Deref, DerefMut}, +}; // Note that this is not a lang item per se, but it has a hidden dependency on // `Iterator`, which is one. The compiler assumes that the `next` method of @@ -230,7 +233,10 @@ impl Option { #[must_use] #[inline] #[unstable(feature = "option_result_contains", issue = "62358")] - pub fn contains(&self, x: &U) -> bool where U: PartialEq { + pub fn contains(&self, x: &U) -> bool + where + U: PartialEq, + { match self { Some(y) => x == y, None => false, @@ -291,16 +297,13 @@ impl Option { } } - /// Converts from [`Pin`]`<&Option>` to `Option<`[`Pin`]`<&T>>`. /// /// [`Pin`]: ../pin/struct.Pin.html #[inline] #[stable(feature = "pin", since = "1.33.0")] pub fn as_pin_ref(self: Pin<&Self>) -> Option> { - unsafe { - Pin::get_ref(self).as_ref().map(|x| Pin::new_unchecked(x)) - } + unsafe { Pin::get_ref(self).as_ref().map(|x| Pin::new_unchecked(x)) } } /// Converts from [`Pin`]`<&mut Option>` to `Option<`[`Pin`]`<&mut T>>`. @@ -309,9 +312,7 @@ impl Option { #[inline] #[stable(feature = "pin", since = "1.33.0")] pub fn as_pin_mut(self: Pin<&mut Self>) -> Option> { - unsafe { - Pin::get_unchecked_mut(self).as_mut().map(|x| Pin::new_unchecked(x)) - } + unsafe { Pin::get_unchecked_mut(self).as_mut().map(|x| Pin::new_unchecked(x)) } } ///////////////////////////////////////////////////////////////////////// @@ -690,7 +691,7 @@ impl Option { pub fn filter bool>(self, predicate: P) -> Self { if let Some(x) = self { if predicate(&x) { - return Some(x) + return Some(x); } } None @@ -1228,7 +1229,9 @@ impl Default for Option { /// assert!(opt.is_none()); /// ``` #[inline] - fn default() -> Option { None } + fn default() -> Option { + None + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1302,7 +1305,7 @@ impl<'a, T> From<&'a mut Option> for Option<&'a mut T> { #[derive(Clone, Debug)] struct Item { - opt: Option + opt: Option, } impl Iterator for Item { @@ -1344,22 +1347,30 @@ unsafe impl TrustedLen for Item {} /// [`Option::iter`]: enum.Option.html#method.iter #[stable(feature = "rust1", since = "1.0.0")] #[derive(Debug)] -pub struct Iter<'a, A: 'a> { inner: Item<&'a A> } +pub struct Iter<'a, A: 'a> { + inner: Item<&'a A>, +} #[stable(feature = "rust1", since = "1.0.0")] impl<'a, A> Iterator for Iter<'a, A> { type Item = &'a A; #[inline] - fn next(&mut self) -> Option<&'a A> { self.inner.next() } + fn next(&mut self) -> Option<&'a A> { + self.inner.next() + } #[inline] - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, A> DoubleEndedIterator for Iter<'a, A> { #[inline] - fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() } + fn next_back(&mut self) -> Option<&'a A> { + self.inner.next_back() + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1390,22 +1401,30 @@ impl Clone for Iter<'_, A> { /// [`Option::iter_mut`]: enum.Option.html#method.iter_mut #[stable(feature = "rust1", since = "1.0.0")] #[derive(Debug)] -pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> } +pub struct IterMut<'a, A: 'a> { + inner: Item<&'a mut A>, +} #[stable(feature = "rust1", since = "1.0.0")] impl<'a, A> Iterator for IterMut<'a, A> { type Item = &'a mut A; #[inline] - fn next(&mut self) -> Option<&'a mut A> { self.inner.next() } + fn next(&mut self) -> Option<&'a mut A> { + self.inner.next() + } #[inline] - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, A> DoubleEndedIterator for IterMut<'a, A> { #[inline] - fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() } + fn next_back(&mut self) -> Option<&'a mut A> { + self.inner.next_back() + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1427,22 +1446,30 @@ unsafe impl TrustedLen for IterMut<'_, A> {} /// [`Option::into_iter`]: enum.Option.html#method.into_iter #[derive(Clone, Debug)] #[stable(feature = "rust1", since = "1.0.0")] -pub struct IntoIter { inner: Item } +pub struct IntoIter { + inner: Item, +} #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter { type Item = A; #[inline] - fn next(&mut self) -> Option { self.inner.next() } + fn next(&mut self) -> Option { + self.inner.next() + } #[inline] - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter { #[inline] - fn next_back(&mut self) -> Option { self.inner.next_back() } + fn next_back(&mut self) -> Option { + self.inner.next_back() + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1523,14 +1550,11 @@ impl> FromIterator> for Option { /// /// [`Iterator`]: ../iter/trait.Iterator.html #[inline] - fn from_iter>>(iter: I) -> Option { + fn from_iter>>(iter: I) -> Option { // FIXME(#11084): This could be replaced with Iterator::scan when this // performance bug is closed. - iter.into_iter() - .map(|x| x.ok_or(())) - .collect::>() - .ok() + iter.into_iter().map(|x| x.ok_or(())).collect::>().ok() } } diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index 1219fd09a9dfa..88fa718ae9e62 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -374,10 +374,10 @@ #![stable(feature = "pin", since = "1.33.0")] +use crate::cmp::{self, PartialEq, PartialOrd}; use crate::fmt; use crate::marker::{Sized, Unpin}; -use crate::cmp::{self, PartialEq, PartialOrd}; -use crate::ops::{Deref, DerefMut, Receiver, CoerceUnsized, DispatchFromDyn}; +use crate::ops::{CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Receiver}; /// A pinned pointer. /// @@ -646,7 +646,8 @@ impl<'a, T: ?Sized> Pin<&'a T> { /// /// [`pin` module]: ../../std/pin/index.html#projections-and-structural-pinning #[stable(feature = "pin", since = "1.33.0")] - pub unsafe fn map_unchecked(self, func: F) -> Pin<&'a U> where + pub unsafe fn map_unchecked(self, func: F) -> Pin<&'a U> + where F: FnOnce(&T) -> &U, { let pointer = &*self.pointer; @@ -698,7 +699,8 @@ impl<'a, T: ?Sized> Pin<&'a mut T> { #[stable(feature = "pin", since = "1.33.0")] #[inline(always)] pub fn get_mut(self) -> &'a mut T - where T: Unpin, + where + T: Unpin, { self.pointer } @@ -735,7 +737,8 @@ impl<'a, T: ?Sized> Pin<&'a mut T> { /// /// [`pin` module]: ../../std/pin/index.html#projections-and-structural-pinning #[stable(feature = "pin", since = "1.33.0")] - pub unsafe fn map_unchecked_mut(self, func: F) -> Pin<&'a mut U> where + pub unsafe fn map_unchecked_mut(self, func: F) -> Pin<&'a mut U> + where F: FnOnce(&mut T) -> &mut U, { let pointer = Pin::get_unchecked_mut(self); @@ -789,13 +792,7 @@ impl fmt::Pointer for Pin