Rollup merge of rust-lang#53062 - ljedrz:redundant_field_names, r=Mark-Simulacrum

kennytm · kennytm · commit 396dda0a6ab5 · 2018-08-04T23:09:12.000+08:00
Remove redundant field names in structs
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
@@ -1258,7 +1258,7 @@ impl<'b, T: ?Sized> RefMut<'b, T> {
         let RefMut { value, borrow } = orig;
         RefMut {
             value: f(value),
-            borrow: borrow,
+            borrow,
         }
     }
 
@@ -1324,7 +1324,7 @@ impl<'b> BorrowRefMut<'b> {
         match borrow.get() {
             UNUSED => {
                 borrow.set(UNUSED - 1);
-                Some(BorrowRefMut { borrow: borrow })
+                Some(BorrowRefMut { borrow })
             },
             _ => None,
         }
@@ -1467,7 +1467,7 @@ impl<T> UnsafeCell<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub const fn new(value: T) -> UnsafeCell<T> {
-        UnsafeCell { value: value }
+        UnsafeCell { value }
     }
 
     /// Unwraps the value.
diff --git a/src/libcore/iter/iterator.rs b/src/libcore/iter/iterator.rs
@@ -507,7 +507,7 @@ pub trait Iterator {
     fn map<B, F>(self, f: F) -> Map<Self, F> where
         Self: Sized, F: FnMut(Self::Item) -> B,
     {
-        Map{iter: self, f: f}
+        Map { iter: self, f }
     }
 
     /// Calls a closure on each element of an iterator.
@@ -618,7 +618,7 @@ pub trait Iterator {
     fn filter<P>(self, predicate: P) -> Filter<Self, P> where
         Self: Sized, P: FnMut(&Self::Item) -> bool,
     {
-        Filter{iter: self, predicate: predicate}
+        Filter {iter: self, predicate }
     }
 
     /// Creates an iterator that both filters and maps.
@@ -675,7 +675,7 @@ pub trait Iterator {
     fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
         Self: Sized, F: FnMut(Self::Item) -> Option<B>,
     {
-        FilterMap { iter: self, f: f }
+        FilterMap { iter: self, f }
     }
 
     /// Creates an iterator which gives the current iteration count as well as
@@ -828,7 +828,7 @@ pub trait Iterator {
     fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
         Self: Sized, P: FnMut(&Self::Item) -> bool,
     {
-        SkipWhile{iter: self, flag: false, predicate: predicate}
+        SkipWhile { iter: self, flag: false, predicate }
     }
 
     /// Creates an iterator that yields elements based on a predicate.
@@ -908,7 +908,7 @@ pub trait Iterator {
     fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
         Self: Sized, P: FnMut(&Self::Item) -> bool,
     {
-        TakeWhile{iter: self, flag: false, predicate: predicate}
+        TakeWhile { iter: self, flag: false, predicate }
     }
 
     /// Creates an iterator that skips the first `n` elements.
@@ -930,7 +930,7 @@ pub trait Iterator {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     fn skip(self, n: usize) -> Skip<Self> where Self: Sized {
-        Skip{iter: self, n: n}
+        Skip { iter: self, n }
     }
 
     /// Creates an iterator that yields its first `n` elements.
@@ -962,7 +962,7 @@ pub trait Iterator {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     fn take(self, n: usize) -> Take<Self> where Self: Sized, {
-        Take{iter: self, n: n}
+        Take { iter: self, n }
     }
 
     /// An iterator adaptor similar to [`fold`] that holds internal state and
@@ -1007,7 +1007,7 @@ pub trait Iterator {
     fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
         where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
     {
-        Scan{iter: self, f: f, state: initial_state}
+        Scan { iter: self, f, state: initial_state }
     }
 
     /// Creates an iterator that works like map, but flattens nested structure.
@@ -1256,7 +1256,7 @@ pub trait Iterator {
     fn inspect<F>(self, f: F) -> Inspect<Self, F> where
         Self: Sized, F: FnMut(&Self::Item),
     {
-        Inspect{iter: self, f: f}
+        Inspect { iter: self, f }
     }
 
     /// Borrows an iterator, rather than consuming it.
diff --git a/src/libcore/num/dec2flt/parse.rs b/src/libcore/num/dec2flt/parse.rs
@@ -40,7 +40,7 @@ pub struct Decimal<'a> {
 
 impl<'a> Decimal<'a> {
     pub fn new(integral: &'a [u8], fractional: &'a [u8], exp: i64) -> Decimal<'a> {
-        Decimal { integral: integral, fractional: fractional, exp: exp }
+        Decimal { integral, fractional, exp }
     }
 }
 
diff --git a/src/libcore/num/dec2flt/rawfp.rs b/src/libcore/num/dec2flt/rawfp.rs
@@ -45,7 +45,7 @@ pub struct Unpacked {
 
 impl Unpacked {
     pub fn new(sig: u64, k: i16) -> Self {
-        Unpacked { sig: sig, k: k }
+        Unpacked { sig, k }
     }
 }
 
@@ -317,13 +317,13 @@ pub fn big_to_fp(f: &Big) -> Fp {
     // We cut off all bits prior to the index `start`, i.e., we effectively right-shift by
     // an amount of `start`, so this is also the exponent we need.
     let e = start as i16;
-    let rounded_down = Fp { f: leading, e: e }.normalize();
+    let rounded_down = Fp { f: leading, e }.normalize();
     // Round (half-to-even) depending on the truncated bits.
     match num::compare_with_half_ulp(f, start) {
         Less => rounded_down,
         Equal if leading % 2 == 0 => rounded_down,
         Equal | Greater => match leading.checked_add(1) {
-            Some(f) => Fp { f: f, e: e }.normalize(),
+            Some(f) => Fp { f, e }.normalize(),
             None => Fp { f: 1 << 63, e: e + 1 },
         }
     }
diff --git a/src/libcore/num/diy_float.rs b/src/libcore/num/diy_float.rs
@@ -42,7 +42,7 @@ impl Fp {
         let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
         let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
         let e = self.e + other.e + 64;
-        Fp { f: f, e: e }
+        Fp { f, e }
     }
 
     /// Normalizes itself so that the resulting mantissa is at least `2^63`.
@@ -74,7 +74,7 @@ impl Fp {
             e -= 1;
         }
         debug_assert!(f >= (1 >> 63));
-        Fp { f: f, e: e }
+        Fp { f, e }
     }
 
     /// Normalizes itself to have the shared exponent.
diff --git a/src/libcore/num/flt2dec/decoder.rs b/src/libcore/num/flt2dec/decoder.rs
@@ -77,8 +77,8 @@ pub fn decode<T: DecodableFloat>(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: mant, minus: 1, plus: 1,
-                                          exp: exp, inclusive: even })
+            FullDecoded::Finite(Decoded { mant, minus: 1, plus: 1,
+                                          exp, inclusive: even })
         }
         FpCategory::Normal => {
             let minnorm = <T as DecodableFloat>::min_pos_norm_value().integer_decode();
diff --git a/src/libcore/num/flt2dec/mod.rs b/src/libcore/num/flt2dec/mod.rs
@@ -424,20 +424,20 @@ pub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T,
     match full_decoded {
         FullDecoded::Nan => {
             parts[0] = Part::Copy(b"NaN");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Infinite => {
             parts[0] = Part::Copy(b"inf");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Zero => {
             if frac_digits > 0 { // [0.][0000]
                 parts[0] = Part::Copy(b"0.");
                 parts[1] = Part::Zero(frac_digits);
-                Formatted { sign: sign, parts: &parts[..2] }
+                Formatted { sign, parts: &parts[..2] }
             } else {
                 parts[0] = Part::Copy(b"0");
-                Formatted { sign: sign, parts: &parts[..1] }
+                Formatted { sign, parts: &parts[..1] }
             }
         }
         FullDecoded::Finite(ref decoded) => {
@@ -480,19 +480,19 @@ pub fn to_shortest_exp_str<'a, T, F>(mut format_shortest: F, v: T,
     match full_decoded {
         FullDecoded::Nan => {
             parts[0] = Part::Copy(b"NaN");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Infinite => {
             parts[0] = Part::Copy(b"inf");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Zero => {
             parts[0] = if dec_bounds.0 <= 0 && 0 < dec_bounds.1 {
                 Part::Copy(b"0")
             } else {
                 Part::Copy(if upper { b"0E0" } else { b"0e0" })
             };
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Finite(ref decoded) => {
             let (len, exp) = format_shortest(decoded, buf);
@@ -502,7 +502,7 @@ pub fn to_shortest_exp_str<'a, T, F>(mut format_shortest: F, v: T,
             } else {
                 digits_to_exp_str(&buf[..len], exp, 0, upper, parts)
             };
-            Formatted { sign: sign, parts: parts }
+            Formatted { sign, parts }
         }
     }
 }
@@ -558,21 +558,21 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T,
     match full_decoded {
         FullDecoded::Nan => {
             parts[0] = Part::Copy(b"NaN");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Infinite => {
             parts[0] = Part::Copy(b"inf");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Zero => {
             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" });
-                Formatted { sign: sign, parts: &parts[..3] }
+                Formatted { sign, parts: &parts[..3] }
             } else {
                 parts[0] = Part::Copy(if upper { b"0E0" } else { b"0e0" });
-                Formatted { sign: sign, parts: &parts[..1] }
+                Formatted { sign, parts: &parts[..1] }
             }
         }
         FullDecoded::Finite(ref decoded) => {
@@ -613,20 +613,20 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
     match full_decoded {
         FullDecoded::Nan => {
             parts[0] = Part::Copy(b"NaN");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Infinite => {
             parts[0] = Part::Copy(b"inf");
-            Formatted { sign: sign, parts: &parts[..1] }
+            Formatted { sign, parts: &parts[..1] }
         }
         FullDecoded::Zero => {
             if frac_digits > 0 { // [0.][0000]
                 parts[0] = Part::Copy(b"0.");
                 parts[1] = Part::Zero(frac_digits);
-                Formatted { sign: sign, parts: &parts[..2] }
+                Formatted { sign, parts: &parts[..2] }
             } else {
                 parts[0] = Part::Copy(b"0");
-                Formatted { sign: sign, parts: &parts[..1] }
+                Formatted { sign, parts: &parts[..1] }
             }
         }
         FullDecoded::Finite(ref decoded) => {
@@ -646,10 +646,10 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
                 if frac_digits > 0 { // [0.][0000]
                     parts[0] = Part::Copy(b"0.");
                     parts[1] = Part::Zero(frac_digits);
-                    Formatted { sign: sign, parts: &parts[..2] }
+                    Formatted { sign, parts: &parts[..2] }
                 } else {
                     parts[0] = Part::Copy(b"0");
-                    Formatted { sign: sign, parts: &parts[..1] }
+                    Formatted { sign, parts: &parts[..1] }
                 }
             } else {
                 Formatted { sign,
diff --git a/src/libcore/num/flt2dec/strategy/grisu.rs b/src/libcore/num/flt2dec/strategy/grisu.rs
@@ -129,7 +129,7 @@ pub fn cached_power(alpha: i16, gamma: i16) -> (i16, Fp) {
     let idx = ((gamma as i32) - offset) * range / domain;
     let (f, e, k) = CACHED_POW10[idx as usize];
     debug_assert!(alpha <= e && e <= gamma);
-    (k, Fp { f: f, e: e })
+    (k, Fp { f, e })
 }
 
 /// Given `x > 0`, returns `(k, 10^k)` such that `10^k <= x < 10^(k+1)`.
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
@@ -621,7 +621,7 @@ impl<T> [T] {
     #[inline]
     pub fn windows(&self, size: usize) -> Windows<T> {
         assert!(size != 0);
-        Windows { v: self, size: size }
+        Windows { v: self, size }
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a
@@ -652,7 +652,7 @@ impl<T> [T] {
     #[inline]
     pub fn chunks(&self, chunk_size: usize) -> Chunks<T> {
         assert!(chunk_size != 0);
-        Chunks { v: self, chunk_size: chunk_size }
+        Chunks { v: self, chunk_size }
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a time.
@@ -687,7 +687,7 @@ impl<T> [T] {
     #[inline]
     pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
         assert!(chunk_size != 0);
-        ChunksMut { v: self, chunk_size: chunk_size }
+        ChunksMut { v: self, chunk_size }
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a
@@ -724,7 +724,7 @@ impl<T> [T] {
         let rem = self.len() % chunk_size;
         let len = self.len() - rem;
         let (fst, snd) = self.split_at(len);
-        ExactChunks { v: fst, rem: snd, chunk_size: chunk_size}
+        ExactChunks { v: fst, rem: snd, chunk_size }
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a time.
@@ -766,7 +766,7 @@ impl<T> [T] {
         let rem = self.len() % chunk_size;
         let len = self.len() - rem;
         let (fst, snd) = self.split_at_mut(len);
-        ExactChunksMut { v: fst, rem: snd, chunk_size: chunk_size}
+        ExactChunksMut { v: fst, rem: snd, chunk_size }
     }
 
     /// Divides one slice into two at an index.
@@ -916,7 +916,7 @@ impl<T> [T] {
     pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F>
         where F: FnMut(&T) -> bool
     {
-        SplitMut { v: self, pred: pred, finished: false }
+        SplitMut { v: self, pred, finished: false }
     }
 
     /// Returns an iterator over subslices separated by elements that match
diff --git a/src/libcore/task/context.rs b/src/libcore/task/context.rs
@@ -86,7 +86,7 @@ impl<'a> Context<'a> {
     {
         Context {
             local_waker: self.local_waker,
-            executor: executor,
+            executor,
         }
     }
 }
diff --git a/src/libcore/time.rs b/src/libcore/time.rs
@@ -91,7 +91,7 @@ impl Duration {
         let secs = secs.checked_add((nanos / NANOS_PER_SEC) as u64)
             .expect("overflow in Duration::new");
         let nanos = nanos % NANOS_PER_SEC;
-        Duration { secs: secs, nanos: nanos }
+        Duration { secs, nanos }
     }
 
     /// Creates a new `Duration` from the specified number of whole seconds.
@@ -109,7 +109,7 @@ impl Duration {
     #[stable(feature = "duration", since = "1.3.0")]
     #[inline]
     pub const fn from_secs(secs: u64) -> Duration {
-        Duration { secs: secs, nanos: 0 }
+        Duration { secs, nanos: 0 }
     }
 
     /// Creates a new `Duration` from the specified number of milliseconds.
@@ -387,7 +387,7 @@ impl Duration {
                 }
             };
             debug_assert!(nanos < NANOS_PER_SEC);
-            Some(Duration { secs: secs, nanos: nanos })
+            Some(Duration { secs, nanos })
         } else {
             None
         }
@@ -453,7 +453,7 @@ impl Duration {
             let extra_nanos = carry * (NANOS_PER_SEC as u64) / (rhs as u64);
             let nanos = self.nanos / rhs + (extra_nanos as u32);
             debug_assert!(nanos < NANOS_PER_SEC);
-            Some(Duration { secs: secs, nanos: nanos })
+            Some(Duration { secs, nanos })
         } else {
             None
         }

Original file line number	Diff line number	Diff line change
`@@ -1258,7 +1258,7 @@ impl<'b, T: ?Sized> RefMut<'b, T> {`
`1258`	`1258`	`let RefMut { value, borrow } = orig;`
`1259`	`1259`	`RefMut {`
`1260`	`1260`	`value: f(value),`
`1261`		`- borrow: borrow,`
	`1261`	`+ borrow,`
`1262`	`1262`	`}`
`1263`	`1263`	`}`
`1264`	`1264`
`@@ -1324,7 +1324,7 @@ impl<'b> BorrowRefMut<'b> {`
`1324`	`1324`	`match borrow.get() {`
`1325`	`1325`	`UNUSED => {`
`1326`	`1326`	`borrow.set(UNUSED - 1);`
`1327`		`- Some(BorrowRefMut { borrow: borrow })`
	`1327`	`+ Some(BorrowRefMut { borrow })`
`1328`	`1328`	`},`
`1329`	`1329`	`_ => None,`
`1330`	`1330`	`}`
`@@ -1467,7 +1467,7 @@ impl<T> UnsafeCell<T> {`
`1467`	`1467`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1468`	`1468`	`#[inline]`
`1469`	`1469`	`pub const fn new(value: T) -> UnsafeCell<T> {`
`1470`		`- UnsafeCell { value: value }`
	`1470`	`+ UnsafeCell { value }`
`1471`	`1471`	`}`
`1472`	`1472`
`1473`	`1473`	`/// Unwraps the value.`
Original file line number	Diff line number	Diff line change
`@@ -507,7 +507,7 @@ pub trait Iterator {`
`507`	`507`	`fn map<B, F>(self, f: F) -> Map<Self, F> where`
`508`	`508`	`Self: Sized, F: FnMut(Self::Item) -> B,`
`509`	`509`	`{`
`510`		`- Map{iter: self, f: f}`
	`510`	`+ Map { iter: self, f }`
`511`	`511`	`}`
`512`	`512`
`513`	`513`	`/// Calls a closure on each element of an iterator.`
`@@ -618,7 +618,7 @@ pub trait Iterator {`
`618`	`618`	`fn filter<P>(self, predicate: P) -> Filter<Self, P> where`
`619`	`619`	`Self: Sized, P: FnMut(&Self::Item) -> bool,`
`620`	`620`	`{`
`621`		`- Filter{iter: self, predicate: predicate}`
	`621`	`+ Filter {iter: self, predicate }`
`622`	`622`	`}`
`623`	`623`
`624`	`624`	`/// Creates an iterator that both filters and maps.`
`@@ -675,7 +675,7 @@ pub trait Iterator {`
`675`	`675`	`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where`
`676`	`676`	`Self: Sized, F: FnMut(Self::Item) -> Option<B>,`
`677`	`677`	`{`
`678`		`- FilterMap { iter: self, f: f }`
	`678`	`+ FilterMap { iter: self, f }`
`679`	`679`	`}`
`680`	`680`
`681`	`681`	`/// Creates an iterator which gives the current iteration count as well as`
`@@ -828,7 +828,7 @@ pub trait Iterator {`
`828`	`828`	`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where`
`829`	`829`	`Self: Sized, P: FnMut(&Self::Item) -> bool,`
`830`	`830`	`{`
`831`		`- SkipWhile{iter: self, flag: false, predicate: predicate}`
	`831`	`+ SkipWhile { iter: self, flag: false, predicate }`
`832`	`832`	`}`
`833`	`833`
`834`	`834`	`/// Creates an iterator that yields elements based on a predicate.`
`@@ -908,7 +908,7 @@ pub trait Iterator {`
`908`	`908`	`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where`
`909`	`909`	`Self: Sized, P: FnMut(&Self::Item) -> bool,`
`910`	`910`	`{`
`911`		`- TakeWhile{iter: self, flag: false, predicate: predicate}`
	`911`	`+ TakeWhile { iter: self, flag: false, predicate }`
`912`	`912`	`}`
`913`	`913`
`914`	`914`	/// Creates an iterator that skips the first `n` elements.
`@@ -930,7 +930,7 @@ pub trait Iterator {`
`930`	`930`	`#[inline]`
`931`	`931`	`#[stable(feature = "rust1", since = "1.0.0")]`
`932`	`932`	`fn skip(self, n: usize) -> Skip<Self> where Self: Sized {`
`933`		`- Skip{iter: self, n: n}`
	`933`	`+ Skip { iter: self, n }`
`934`	`934`	`}`
`935`	`935`
`936`	`936`	/// Creates an iterator that yields its first `n` elements.
`@@ -962,7 +962,7 @@ pub trait Iterator {`
`962`	`962`	`#[inline]`
`963`	`963`	`#[stable(feature = "rust1", since = "1.0.0")]`
`964`	`964`	`fn take(self, n: usize) -> Take<Self> where Self: Sized, {`
`965`		`- Take{iter: self, n: n}`
	`965`	`+ Take { iter: self, n }`
`966`	`966`	`}`
`967`	`967`
`968`	`968`	/// An iterator adaptor similar to [`fold`] that holds internal state and
`@@ -1007,7 +1007,7 @@ pub trait Iterator {`
`1007`	`1007`	`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>`
`1008`	`1008`	`where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,`
`1009`	`1009`	`{`
`1010`		`- Scan{iter: self, f: f, state: initial_state}`
	`1010`	`+ Scan { iter: self, f, state: initial_state }`
`1011`	`1011`	`}`
`1012`	`1012`
`1013`	`1013`	`/// Creates an iterator that works like map, but flattens nested structure.`
`@@ -1256,7 +1256,7 @@ pub trait Iterator {`
`1256`	`1256`	`fn inspect<F>(self, f: F) -> Inspect<Self, F> where`
`1257`	`1257`	`Self: Sized, F: FnMut(&Self::Item),`
`1258`	`1258`	`{`
`1259`		`- Inspect{iter: self, f: f}`
	`1259`	`+ Inspect { iter: self, f }`
`1260`	`1260`	`}`
`1261`	`1261`
`1262`	`1262`	`/// Borrows an iterator, rather than consuming it.`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ pub struct Decimal<'a> {`
`40`	`40`
`41`	`41`	`impl<'a> Decimal<'a> {`
`42`	`42`	`pub fn new(integral: &'a [u8], fractional: &'a [u8], exp: i64) -> Decimal<'a> {`
`43`		`- Decimal { integral: integral, fractional: fractional, exp: exp }`
	`43`	`+ Decimal { integral, fractional, exp }`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ pub struct Unpacked {`
`45`	`45`
`46`	`46`	`impl Unpacked {`
`47`	`47`	`pub fn new(sig: u64, k: i16) -> Self {`
`48`		`- Unpacked { sig: sig, k: k }`
	`48`	`+ Unpacked { sig, k }`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`@@ -317,13 +317,13 @@ pub fn big_to_fp(f: &Big) -> Fp {`
`317`	`317`	// We cut off all bits prior to the index `start`, i.e., we effectively right-shift by
`318`	`318`	// an amount of `start`, so this is also the exponent we need.
`319`	`319`	`let e = start as i16;`
`320`		`- let rounded_down = Fp { f: leading, e: e }.normalize();`
	`320`	`+ let rounded_down = Fp { f: leading, e }.normalize();`
`321`	`321`	`// Round (half-to-even) depending on the truncated bits.`
`322`	`322`	`match num::compare_with_half_ulp(f, start) {`
`323`	`323`	`Less => rounded_down,`
`324`	`324`	`Equal if leading % 2 == 0 => rounded_down,`
`325`	`325`	`Equal \| Greater => match leading.checked_add(1) {`
`326`		`- Some(f) => Fp { f: f, e: e }.normalize(),`
	`326`	`+ Some(f) => Fp { f, e }.normalize(),`
`327`	`327`	`None => Fp { f: 1 << 63, e: e + 1 },`
`328`	`328`	`}`
`329`	`329`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl Fp {`
`42`	`42`	`let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;`
`43`	`43`	`let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);`
`44`	`44`	`let e = self.e + other.e + 64;`
`45`		`- Fp { f: f, e: e }`
	`45`	`+ Fp { f, e }`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	/// Normalizes itself so that the resulting mantissa is at least `2^63`.
`@@ -74,7 +74,7 @@ impl Fp {`
`74`	`74`	`e -= 1;`
`75`	`75`	`}`
`76`	`76`	`debug_assert!(f >= (1 >> 63));`
`77`		`- Fp { f: f, e: e }`
	`77`	`+ Fp { f, e }`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`/// Normalizes itself to have the shared exponent.`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ pub fn cached_power(alpha: i16, gamma: i16) -> (i16, Fp) {`
`129`	`129`	`let idx = ((gamma as i32) - offset) * range / domain;`
`130`	`130`	`let (f, e, k) = CACHED_POW10[idx as usize];`
`131`	`131`	`debug_assert!(alpha <= e && e <= gamma);`
`132`		`- (k, Fp { f: f, e: e })`
	`132`	`+ (k, Fp { f, e })`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	/// Given `x > 0`, returns `(k, 10^k)` such that `10^k <= x < 10^(k+1)`.
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ impl<'a> Context<'a> {`
`86`	`86`	`{`
`87`	`87`	`Context {`
`88`	`88`	`local_waker: self.local_waker,`
`89`		`- executor: executor,`
	`89`	`+ executor,`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`}`