Improve internal documentation and code style

Fix some code layout, remove some unnecessary returns, fix typos,
punctuation, and comment consistency.

src/librustc_back/sha2.rs

@@ -25,11 +25,10 @@ fn write_u32_be(dst: &mut[u8], input: u32) {
 
 /// Read the value of a vector of bytes as a u32 value in big-endian format.
 fn read_u32_be(input: &[u8]) -> u32 {
-    return
-        (input[0] as u32) << 24 |
+    (input[0] as u32) << 24 |
         (input[1] as u32) << 16 |
         (input[2] as u32) << 8 |
-        (input[3] as u32);
+        (input[3] as u32)
 }
 
 /// Read a vector of bytes into a vector of u32s. The values are read in big-endian format.
@@ -50,7 +49,7 @@ trait ToBits: Sized {
 
 impl ToBits for u64 {
     fn to_bits(self) -> (u64, u64) {
-        return (self >> 61, self << 3);
+        (self >> 61, self << 3)
     }
 }
 
@@ -64,7 +63,7 @@ fn add_bytes_to_bits(bits: u64, bytes: u64) -> u64 {
     }
 
     match bits.checked_add(new_low_bits) {
-        Some(x) => return x,
+        Some(x) => x,
         None => panic!("numeric overflow occurred.")
     }
 }
@@ -113,10 +112,10 @@ struct FixedBuffer64 {
 impl FixedBuffer64 {
     /// Create a new FixedBuffer64
     fn new() -> FixedBuffer64 {
-        return FixedBuffer64 {
+        FixedBuffer64 {
             buffer: [0; 64],
             buffer_idx: 0
-        };
+        }
     }
 }
 
@@ -175,13 +174,13 @@ impl FixedBuffer for FixedBuffer64 {
 
     fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8] {
         self.buffer_idx += len;
-        return &mut self.buffer[self.buffer_idx - len..self.buffer_idx];
+        &mut self.buffer[self.buffer_idx - len..self.buffer_idx]
     }
 
     fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
         assert!(self.buffer_idx == 64);
         self.buffer_idx = 0;
-        return &self.buffer[..64];
+        &self.buffer[..64]
     }
 
     fn position(&self) -> usize { self.buffer_idx }
@@ -278,7 +277,7 @@ struct Engine256State {
 
 impl Engine256State {
     fn new(h: &[u32; 8]) -> Engine256State {
-        return Engine256State {
+        Engine256State {
             h0: h[0],
             h1: h[1],
             h2: h[2],
@@ -287,7 +286,7 @@ impl Engine256State {
             h5: h[5],
             h6: h[6],
             h7: h[7]
-        };
+        }
     }
 
     fn reset(&mut self, h: &[u32; 8]) {
@@ -433,7 +432,7 @@ struct Engine256 {
 
 impl Engine256 {
     fn new(h: &[u32; 8]) -> Engine256 {
-        return Engine256 {
+        Engine256 {
             length_bits: 0,
             buffer: FixedBuffer64::new(),
             state: Engine256State::new(h),
@@ -457,17 +456,15 @@ impl Engine256 {
     }
 
     fn finish(&mut self) {
-        if self.finished {
-            return;
+        if !self.finished {
+            let self_state = &mut self.state;
+            self.buffer.standard_padding(8, |input: &[u8]| { self_state.process_block(input) });
+            write_u32_be(self.buffer.next(4), (self.length_bits >> 32) as u32 );
+            write_u32_be(self.buffer.next(4), self.length_bits as u32);
+            self_state.process_block(self.buffer.full_buffer());
+
+            self.finished = true;
         }
-
-        let self_state = &mut self.state;
-        self.buffer.standard_padding(8, |input: &[u8]| { self_state.process_block(input) });
-        write_u32_be(self.buffer.next(4), (self.length_bits >> 32) as u32 );
-        write_u32_be(self.buffer.next(4), self.length_bits as u32);
-        self_state.process_block(self.buffer.full_buffer());
-
-        self.finished = true;
     }
 }