From 76f2e0ed8e30a0d1cde749f3444bd8a4c81bea87 Mon Sep 17 00:00:00 2001 From: Nora Widdecke Date: Wed, 7 Apr 2021 18:45:55 +0200 Subject: Lint: Remove redundant returns. - https://rust-lang.github.io/rust-clippy/master/index.html#needless_return --- buffered-reader/src/decompress_bzip2.rs | 22 ++++++++-------- buffered-reader/src/decompress_deflate.rs | 44 +++++++++++++++---------------- buffered-reader/src/dup.rs | 2 +- buffered-reader/src/eof.rs | 16 +++++------ buffered-reader/src/generic.rs | 12 ++++----- buffered-reader/src/lib.rs | 21 +++++++-------- buffered-reader/src/limitor.rs | 12 ++++----- buffered-reader/src/memory.rs | 8 +++--- buffered-reader/src/reserve.rs | 2 +- 9 files changed, 69 insertions(+), 70 deletions(-) (limited to 'buffered-reader/src') diff --git a/buffered-reader/src/decompress_bzip2.rs b/buffered-reader/src/decompress_bzip2.rs index febe37fc..d292390f 100644 --- a/buffered-reader/src/decompress_bzip2.rs +++ b/buffered-reader/src/decompress_bzip2.rs @@ -53,48 +53,48 @@ impl, C: fmt::Debug + Sync + Send> fmt::Display for Bzip, C: fmt::Debug + Send + Sync> BufferedReader for Bzip { fn buffer(&self) -> &[u8] { - return self.reader.buffer(); + self.reader.buffer() } fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); + self.reader.data(amount) } fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); + self.reader.data_hard(amount) } fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); + self.reader.data_eof() } fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); + self.reader.consume(amount) } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); + self.reader.data_consume(amount) } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); + self.reader.data_consume_hard(amount) } fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); + self.reader.read_be_u16() } fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); + self.reader.read_be_u32() } fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); + self.reader.steal(amount) } fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); + self.reader.steal_eof() } fn get_mut(&mut self) -> Option<&mut dyn BufferedReader> { diff --git a/buffered-reader/src/decompress_deflate.rs b/buffered-reader/src/decompress_deflate.rs index d1d1a16b..d713413a 100644 --- a/buffered-reader/src/decompress_deflate.rs +++ b/buffered-reader/src/decompress_deflate.rs @@ -54,48 +54,48 @@ impl, C: fmt::Debug + Sync + Send> fmt::Display for Deflate impl, C: fmt::Debug + Send + Sync> BufferedReader for Deflate { fn buffer(&self) -> &[u8] { - return self.reader.buffer(); + self.reader.buffer() } fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); + self.reader.data(amount) } fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); + self.reader.data_hard(amount) } fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); + self.reader.data_eof() } fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); + self.reader.consume(amount) } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); + self.reader.data_consume(amount) } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); + self.reader.data_consume_hard(amount) } fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); + self.reader.read_be_u16() } fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); + self.reader.read_be_u32() } fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); + self.reader.steal(amount) } fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); + self.reader.steal_eof() } fn get_mut(&mut self) -> Option<&mut dyn BufferedReader> { @@ -180,48 +180,48 @@ impl, C: fmt::Debug + Sync + Send> fmt::Debug for Zlib, C: fmt::Debug + Send + Sync> BufferedReader for Zlib { fn buffer(&self) -> &[u8] { - return self.reader.buffer(); + self.reader.buffer() } fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); + self.reader.data(amount) } fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); + self.reader.data_hard(amount) } fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); + self.reader.data_eof() } fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); + self.reader.consume(amount) } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); + self.reader.data_consume(amount) } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); + self.reader.data_consume_hard(amount) } fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); + self.reader.read_be_u16() } fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); + self.reader.read_be_u32() } fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); + self.reader.steal(amount) } fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); + self.reader.steal_eof() } fn get_mut(&mut self) -> Option<&mut dyn BufferedReader> { diff --git a/buffered-reader/src/dup.rs b/buffered-reader/src/dup.rs index d5ef6624..df4a6e2f 100644 --- a/buffered-reader/src/dup.rs +++ b/buffered-reader/src/dup.rs @@ -57,7 +57,7 @@ impl, C: fmt::Debug + Sync + Send> Dup { /// Returns the number of bytes that this reader has consumed. pub fn total_out(&self) -> usize { - return self.cursor; + self.cursor } /// Resets the cursor to the beginning of the stream. diff --git a/buffered-reader/src/eof.rs b/buffered-reader/src/eof.rs index b0312630..6298b52b 100644 --- a/buffered-reader/src/eof.rs +++ b/buffered-reader/src/eof.rs @@ -40,26 +40,26 @@ impl EOF { impl Read for EOF { fn read(&mut self, _buf: &mut [u8]) -> Result { - return Ok(0); + Ok(0) } } impl BufferedReader for EOF { fn buffer(&self) -> &[u8] { - return &b""[..]; + &b""[..] } fn data(&mut self, _amount: usize) -> Result<&[u8], io::Error> { - return Ok(&b""[..]); + Ok(&b""[..]) } fn consume(&mut self, amount: usize) -> &[u8] { assert_eq!(amount, 0); - return &b""[..]; + &b""[..] } fn data_consume(&mut self, _amount: usize) -> Result<&[u8], io::Error> { - return Ok(&b""[..]); + Ok(&b""[..]) } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { @@ -73,17 +73,17 @@ impl BufferedReader for EOF { fn into_inner<'a>(self: Box) -> Option + 'a>> where Self: 'a { - return None; + None } fn get_mut(&mut self) -> Option<&mut dyn BufferedReader> { - return None; + None } fn get_ref(&self) -> Option<&dyn BufferedReader> { - return None; + None } diff --git a/buffered-reader/src/generic.rs b/buffered-reader/src/generic.rs index 8d6ec104..19f799eb 100644 --- a/buffered-reader/src/generic.rs +++ b/buffered-reader/src/generic.rs @@ -213,7 +213,7 @@ impl Generic { impl io::Read for Generic { fn read(&mut self, buf: &mut [u8]) -> Result { - return buffered_reader_generic_read_impl(self, buf); + buffered_reader_generic_read_impl(self, buf) } } @@ -227,11 +227,11 @@ impl BufferedReader f } fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.data_helper(amount, false, false); + self.data_helper(amount, false, false) } fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.data_helper(amount, true, false); + self.data_helper(amount, true, false) } // Note: @@ -257,16 +257,16 @@ impl BufferedReader f return &self.buffer.as_ref().unwrap()[self.cursor - amount..]; } else { assert_eq!(amount, 0); - return &b""[..]; + &b""[..] } } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.data_helper(amount, false, true); + self.data_helper(amount, false, true) } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.data_helper(amount, true, true); + self.data_helper(amount, true, true) } fn get_mut(&mut self) -> Option<&mut dyn BufferedReader> { diff --git a/buffered-reader/src/lib.rs b/buffered-reader/src/lib.rs index 29a2afc2..18fdbaee 100644 --- a/buffered-reader/src/lib.rs +++ b/buffered-reader/src/lib.rs @@ -402,7 +402,7 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync "unexpected EOF")); } } - return result; + result } /// Returns all of the data until EOF. Like `data()`, this does not @@ -472,7 +472,7 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync let buffer = self.buffer(); assert_eq!(buffer.len(), s); - return Ok(buffer); + Ok(buffer) } /// Consumes some of the data. @@ -747,7 +747,7 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync }; self.consume(position); - return Ok(total + position); + Ok(total + position) } /// Discards the input until one of the bytes in `terminals` is @@ -785,7 +785,7 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync if data.len() > amount { data = &data[..amount]; } - return Ok(data.to_vec()); + Ok(data.to_vec()) } /// Like `steal()`, but instead of stealing a fixed number of @@ -793,7 +793,7 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync fn steal_eof(&mut self) -> Result, std::io::Error> { let len = self.data_eof()?.len(); let data = self.steal(len)?; - return Ok(data); + Ok(data) } /// Like `steal_eof()`, but instead of returning the data, the @@ -912,14 +912,13 @@ pub trait BufferedReader : io::Read + fmt::Debug + fmt::Display + Send + Sync /// implementations of trait `std::io::Read` for type `&mut _`"). pub fn buffered_reader_generic_read_impl, C: fmt::Debug + Sync + Send> (bio: &mut T, buf: &mut [u8]) -> Result { - match bio.data_consume(buf.len()) { - Ok(inner) => { + bio + .data_consume(buf.len()) + .map(|inner| { let amount = cmp::min(buf.len(), inner.len()); buf[0..amount].copy_from_slice(&inner[0..amount]); - return Ok(amount); - }, - Err(err) => return Err(err), - } + amount + }) } /// Make a `Box` look like a BufferedReader. diff --git a/buffered-reader/src/limitor.rs b/buffered-reader/src/limitor.rs index 539dee74..c20edced 100644 --- a/buffered-reader/src/limitor.rs +++ b/buffered-reader/src/limitor.rs @@ -76,11 +76,11 @@ impl, C: fmt::Debug + Sync + Send> BufferedReader for Li match result { Ok(ref buffer) => if buffer.len() as u64 > self.limit { - return Ok(&buffer[0..self.limit as usize]); + Ok(&buffer[0..self.limit as usize]) } else { - return Ok(buffer); + Ok(buffer) }, - Err(err) => return Err(err), + Err(err) => Err(err), } } @@ -88,7 +88,7 @@ impl, C: fmt::Debug + Sync + Send> BufferedReader for Li assert!(amount as u64 <= self.limit); self.limit -= amount as u64; let data = self.reader.consume(amount); - return &data[..cmp::min(self.limit + amount as u64, data.len() as u64) as usize]; + &data[..cmp::min(self.limit + amount as u64, data.len() as u64) as usize] } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { @@ -100,7 +100,7 @@ impl, C: fmt::Debug + Sync + Send> BufferedReader for Li return Ok(&buffer[ ..cmp::min(buffer.len() as u64, self.limit + amount as u64) as usize]); } - return result; + result } fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { @@ -114,7 +114,7 @@ impl, C: fmt::Debug + Sync + Send> BufferedReader for Li return Ok(&buffer[ ..cmp::min(buffer.len() as u64, self.limit + amount as u64) as usize]); } - return result; + result } fn consummated(&mut self) -> bool { diff --git a/buffered-reader/src/memory.rs b/buffered-reader/src/memory.rs index b469a652..a177c6c0 100644 --- a/buffered-reader/src/memory.rs +++ b/buffered-reader/src/memory.rs @@ -56,7 +56,7 @@ impl<'a, C: fmt::Debug + Sync + Send> Memory<'a, C> { /// Returns the number of bytes that have been consumed by this /// reader. pub fn total_out(&self) -> usize { - return self.cursor; + self.cursor } #[allow(dead_code)] @@ -71,7 +71,7 @@ impl<'a, C: fmt::Debug + Sync + Send> io::Read for Memory<'a, C> { buf[0..amount].copy_from_slice( &self.buffer[self.cursor..self.cursor+amount]); self.consume(amount); - return Ok(amount); + Ok(amount) } } @@ -82,7 +82,7 @@ impl<'a, C: fmt::Debug + Sync + Send> BufferedReader for Memory<'a, C> { fn data(&mut self, _amount: usize) -> Result<&[u8], io::Error> { assert!(self.cursor <= self.buffer.len()); - return Ok(&self.buffer[self.cursor..]); + Ok(&self.buffer[self.cursor..]) } fn consume(&mut self, amount: usize) -> &[u8] { @@ -92,7 +92,7 @@ impl<'a, C: fmt::Debug + Sync + Send> BufferedReader for Memory<'a, C> { amount, self.buffer.len() - self.cursor); self.cursor += amount; assert!(self.cursor <= self.buffer.len()); - return &self.buffer[self.cursor - amount..]; + &self.buffer[self.cursor - amount..] } fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> { diff --git a/buffered-reader/src/reserve.rs b/buffered-reader/src/reserve.rs index 6de46627..937abbae 100644 --- a/buffered-reader/src/reserve.rs +++ b/buffered-reader/src/reserve.rs @@ -66,7 +66,7 @@ impl, C: fmt::Debug + Sync + Send> io::Read for Reserve