From 17033a62b420fcf353150998bbdb62629efdf956 Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:01:02 +0300 Subject: [PATCH 1/3] rustfmt part of libcore/fmt Rest is blocked by https://github.com/nrc/rustfmt/issues/413 --- src/libcore/fmt/builders.rs | 62 ++++++++++++++++++++++++++++--------- src/libcore/fmt/num.rs | 21 ++++++++++--- src/libcore/fmt/rt/v1.rs | 2 +- 3 files changed, 65 insertions(+), 20 deletions(-) diff --git a/src/libcore/fmt/builders.rs b/src/libcore/fmt/builders.rs index 764d12dd903..0d4c0bb6480 100644 --- a/src/libcore/fmt/builders.rs +++ b/src/libcore/fmt/builders.rs @@ -61,7 +61,8 @@ pub struct DebugStruct<'a, 'b: 'a> { has_fields: bool, } -pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) +pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, + name: &str) -> DebugStruct<'a, 'b> { let result = fmt.write_str(name); DebugStruct { @@ -84,7 +85,8 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - fmt::write(&mut writer, format_args!("{}\n{}: {:#?}", prefix, name, value)) + fmt::write(&mut writer, + format_args!("{}\n{}: {:#?}", prefix, name, value)) } else { write!(self.fmt, "{} {}: {:?}", prefix, name, value) } @@ -195,10 +197,18 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> { self.result = self.result.and_then(|_| { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - let prefix = if self.has_fields { "," } else { "" }; + let prefix = if self.has_fields { + "," + } else { + "" + }; fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry)) } else { - let prefix = if self.has_fields { ", " } else { "" }; + let prefix = if self.has_fields { + ", " + } else { + "" + }; write!(self.fmt, "{}{:?}", prefix, entry) } }); @@ -207,7 +217,11 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> { } pub fn finish(&mut self) { - let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" }; + let prefix = if self.is_pretty() && self.has_fields { + "\n" + } else { + "" + }; self.result = self.result.and_then(|_| self.fmt.write_str(prefix)); } @@ -232,7 +246,7 @@ pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b fmt: fmt, result: result, has_fields: false, - } + }, } } @@ -247,7 +261,9 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> { /// Adds the contents of an iterator of entries to the set output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugSet<'a, 'b> - where D: fmt::Debug, I: IntoIterator { + where D: fmt::Debug, + I: IntoIterator + { for entry in entries { self.entry(&entry); } @@ -278,7 +294,7 @@ pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, fmt: fmt, result: result, has_fields: false, - } + }, } } @@ -293,7 +309,9 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> { /// Adds the contents of an iterator of entries to the list output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugList<'a, 'b> - where D: fmt::Debug, I: IntoIterator { + where D: fmt::Debug, + I: IntoIterator + { for entry in entries { self.entry(&entry); } @@ -335,10 +353,19 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { self.result = self.result.and_then(|_| { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - let prefix = if self.has_fields { "," } else { "" }; - fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value)) + let prefix = if self.has_fields { + "," + } else { + "" + }; + fmt::write(&mut writer, + format_args!("{}\n{:#?}: {:#?}", prefix, key, value)) } else { - let prefix = if self.has_fields { ", " } else { "" }; + let prefix = if self.has_fields { + ", " + } else { + "" + }; write!(self.fmt, "{}{:?}: {:?}", prefix, key, value) } }); @@ -350,7 +377,10 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// Adds the contents of an iterator of entries to the map output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugMap<'a, 'b> - where K: fmt::Debug, V: fmt::Debug, I: IntoIterator { + where K: fmt::Debug, + V: fmt::Debug, + I: IntoIterator + { for (k, v) in entries { self.entry(&k, &v); } @@ -360,7 +390,11 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// Finishes output and returns any error encountered. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn finish(&mut self) -> fmt::Result { - let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" }; + let prefix = if self.is_pretty() && self.has_fields { + "\n" + } else { + "" + }; self.result.and_then(|_| write!(self.fmt, "{}}}", prefix)) } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 022fe6711bd..5d8f5858078 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -48,7 +48,9 @@ trait GenericRadix { fn base(&self) -> u8; /// A radix-specific prefix string. - fn prefix(&self) -> &'static str { "" } + fn prefix(&self) -> &'static str { + "" + } /// Converts an integer to corresponding radix digit. fn digit(&self, x: u8) -> u8; @@ -70,7 +72,10 @@ trait GenericRadix { x = x / base; // Deaccumulate the number. *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; - if x == zero { break }; // No more digits left to accumulate. + if x == zero { + // No more digits left to accumulate. + break + }; } } else { // Do the same as above, but accounting for two's complement. @@ -79,7 +84,9 @@ trait GenericRadix { x = x / base; // Deaccumulate the number. *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; - if x == zero { break }; // No more digits left to accumulate. + if x == zero { + break + }; // No more digits left to accumulate. } } let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) }; @@ -141,13 +148,17 @@ pub struct Radix { impl Radix { fn new(base: u8) -> Radix { - assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base); + assert!(2 <= base && base <= 36, + "the base must be in the range of 2..36: {}", + base); Radix { base: base } } } impl GenericRadix for Radix { - fn base(&self) -> u8 { self.base } + fn base(&self) -> u8 { + self.base + } fn digit(&self, x: u8) -> u8 { match x { x @ 0 ... 9 => b'0' + x, diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs index 033834dd5aa..f889045a3f5 100644 --- a/src/libcore/fmt/rt/v1.rs +++ b/src/libcore/fmt/rt/v1.rs @@ -53,5 +53,5 @@ pub enum Count { #[derive(Copy, Clone)] pub enum Position { Next, - At(usize) + At(usize), } From 3fbbee6ad5a8ce225702910deb712dc88f4412c3 Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:03:52 +0300 Subject: [PATCH 2/3] rustfmt hash submodule --- src/libcore/hash/mod.rs | 31 ++++++++++++++++++++++--------- src/libcore/hash/sip.rs | 11 +++++------ 2 files changed, 27 insertions(+), 15 deletions(-) diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 2a4c909d638..4e038f455e1 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -100,7 +100,9 @@ pub trait Hash { /// Feeds a slice of this type into the state provided. #[stable(feature = "hash_slice", since = "1.3.0")] - fn hash_slice(data: &[Self], state: &mut H) where Self: Sized { + fn hash_slice(data: &[Self], state: &mut H) + where Self: Sized + { for piece in data { piece.hash(state); } @@ -121,7 +123,9 @@ pub trait Hasher { /// Write a single `u8` into this hasher #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_u8(&mut self, i: u8) { self.write(&[i]) } + fn write_u8(&mut self, i: u8) { + self.write(&[i]) + } /// Write a single `u16` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] @@ -145,8 +149,7 @@ pub trait Hasher { #[stable(feature = "hasher_write", since = "1.3.0")] fn write_usize(&mut self, i: usize) { let bytes = unsafe { - ::slice::from_raw_parts(&i as *const usize as *const u8, - mem::size_of::()) + ::slice::from_raw_parts(&i as *const usize as *const u8, mem::size_of::()) }; self.write(bytes); } @@ -154,23 +157,33 @@ pub trait Hasher { /// Write a single `i8` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i8(&mut self, i: i8) { self.write_u8(i as u8) } + fn write_i8(&mut self, i: i8) { + self.write_u8(i as u8) + } /// Write a single `i16` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i16(&mut self, i: i16) { self.write_u16(i as u16) } + fn write_i16(&mut self, i: i16) { + self.write_u16(i as u16) + } /// Write a single `i32` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i32(&mut self, i: i32) { self.write_u32(i as u32) } + fn write_i32(&mut self, i: i32) { + self.write_u32(i as u32) + } /// Write a single `i64` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i64(&mut self, i: i64) { self.write_u64(i as u64) } + fn write_i64(&mut self, i: i64) { + self.write_u64(i as u64) + } /// Write a single `isize` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_isize(&mut self, i: isize) { self.write_usize(i as usize) } + fn write_isize(&mut self, i: isize) { + self.write_usize(i as usize) + } } ////////////////////////////////////////////////////////////////////////////// diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index 32a4f1e5bd7..722d77a8a11 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -37,12 +37,12 @@ pub struct SipHasher { // and simd implementations of SipHash will use vectors // of v02 and v13. By placing them in this order in the struct, // the compiler can pick up on just a few simd optimizations by itself. - v0: u64, // hash state + v0: u64, // hash state v2: u64, v1: u64, v3: u64, tail: u64, // unprocessed bytes le - ntail: usize, // how many bytes in tail are valid + ntail: usize, // how many bytes in tail are valid } // sadly, these macro definitions can't appear later, @@ -80,8 +80,7 @@ macro_rules! u8to64_le { unsafe fn load_u64_le(buf: &[u8], i: usize) -> u64 { debug_assert!(i + 8 <= buf.len()); let mut data = 0u64; - ptr::copy_nonoverlapping(buf.get_unchecked(i), - &mut data as *mut _ as *mut u8, 8); + ptr::copy_nonoverlapping(buf.get_unchecked(i), &mut data as *mut _ as *mut u8, 8); data.to_le() } @@ -152,12 +151,12 @@ impl Hasher for SipHasher { if self.ntail != 0 { needed = 8 - self.ntail; if length < needed { - self.tail |= u8to64_le!(msg, 0, length) << 8*self.ntail; + self.tail |= u8to64_le!(msg, 0, length) << 8 * self.ntail; self.ntail += length; return } - let m = self.tail | u8to64_le!(msg, 0, needed) << 8*self.ntail; + let m = self.tail | u8to64_le!(msg, 0, needed) << 8 * self.ntail; self.v3 ^= m; compress!(self.v0, self.v1, self.v2, self.v3); From 11a7773a3acfb3c48d56cecb6a5ab076f9d71dfe Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:08:33 +0300 Subject: [PATCH 3/3] Fix comment gone astray --- src/libcore/fmt/num.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 5d8f5858078..23642790a88 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -85,8 +85,9 @@ trait GenericRadix { *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; if x == zero { + // No more digits left to accumulate. break - }; // No more digits left to accumulate. + }; } } let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };