ran cargo clippy --fix -- -A clippy::all -W clippy::use_self

Author: adamnemecek

src/bufread.rs

@@ -29,8 +29,8 @@ pub struct BzDecoder<R> {
 impl<R: BufRead> BzEncoder<R> {
     /// Creates a new encoder which will read uncompressed data from the given
     /// stream and emit the compressed stream.
-    pub fn new(r: R, level: Compression) -> BzEncoder<R> {
-        BzEncoder {
+    pub fn new(r: R, level: Compression) -> Self {
+        Self {
             obj: r,
             data: Compress::new(level, 30),
             done: false,
@@ -127,16 +127,16 @@ impl<W: Write> Write for BzEncoder<W> {
 impl<R: BufRead> BzDecoder<R> {
     /// Creates a new decoder which will decompress data read from the given
     /// stream.
-    pub fn new(r: R) -> BzDecoder<R> {
-        BzDecoder {
+    pub fn new(r: R) -> Self {
+        Self {
             obj: r,
             data: Decompress::new(false),
             done: false,
             multi: false,
         }
     }
 
-    fn multi(mut self, flag: bool) -> BzDecoder<R> {
+    fn multi(mut self, flag: bool) -> Self {
         self.multi = flag;
         self
     }
@@ -240,8 +240,8 @@ pub struct MultiBzDecoder<R>(BzDecoder<R>);
 impl<R: BufRead> MultiBzDecoder<R> {
     /// Creates a new decoder from the given reader. If the bzip2 stream contains multiple members
     /// all will be decoded.
-    pub fn new(r: R) -> MultiBzDecoder<R> {
-        MultiBzDecoder(BzDecoder::new(r).multi(true))
+    pub fn new(r: R) -> Self {
+        Self(BzDecoder::new(r).multi(true))
     }
 }
 

src/lib.rs

@@ -88,35 +88,35 @@ impl Compression {
     /// A level outside of the `1..=9` range will throw a panic. Use [`Self::try_new`] to
     /// gracefully handle invalid levels (e.g. from user input).
     #[track_caller]
-    pub const fn new(level: u32) -> Compression {
+    pub const fn new(level: u32) -> Self {
         match Self::try_new(level) {
             Some(v) => v,
             None => panic!("expected a compression level in the range 1..=9"),
         }
     }
 
     /// Create a new compression spec with a specific numeric level in the range `1..=9`.
-    pub const fn try_new(level: u32) -> Option<Compression> {
+    pub const fn try_new(level: u32) -> Option<Self> {
         match level {
-            1..=9 => Some(Compression(level)),
+            1..=9 => Some(Self(level)),
             _ => None,
         }
     }
 
     /// Do not compress.
     #[deprecated(since = "0.5.1", note = "libbz2 does not support compression level 0")]
-    pub fn none() -> Compression {
-        Compression(0)
+    pub fn none() -> Self {
+        Self(0)
     }
 
     /// Optimize for the best speed of encoding.
-    pub const fn fast() -> Compression {
-        Compression(1)
+    pub const fn fast() -> Self {
+        Self(1)
     }
 
     /// Optimize for smallest output size.
-    pub const fn best() -> Compression {
-        Compression(9)
+    pub const fn best() -> Self {
+        Self(9)
     }
 
     /// Return the compression level as an integer.
@@ -127,8 +127,8 @@ impl Compression {
 
 impl Default for Compression {
     /// Choose the default compression, a balance between speed and size.
-    fn default() -> Compression {
-        Compression(6)
+    fn default() -> Self {
+        Self(6)
     }
 }
 

src/mem.rs

@@ -117,14 +117,14 @@ impl Compress {
     ///
     /// Allowable values range from 0 to 250 inclusive. 0 is a special case,
     /// equivalent to using the default value of 30.
-    pub fn new(lvl: Compression, work_factor: u32) -> Compress {
+    pub fn new(lvl: Compression, work_factor: u32) -> Self {
         unsafe {
             let mut raw = Box::new(mem::zeroed());
             assert_eq!(
                 ffi::BZ2_bzCompressInit(&mut *raw, lvl.level() as c_int, 0, work_factor as c_int),
                 0
             );
-            Compress {
+            Self {
                 inner: Stream {
                     raw,
                     _marker: marker::PhantomData,
@@ -163,7 +163,7 @@ impl Compress {
                 ffi::BZ_FINISH_OK => Ok(Status::FinishOk),
                 ffi::BZ_STREAM_END => Ok(Status::StreamEnd),
                 ffi::BZ_SEQUENCE_ERROR => Err(Error::Sequence),
-                c => panic!("unknown return status: {}", c),
+                c => panic!("unknown return status: {c}"),
             }
         }
     }
@@ -213,11 +213,11 @@ impl Decompress {
     /// decompression algorithm which uses less memory but at the cost of
     /// decompressing more slowly (roughly speaking, half the speed, but the
     /// maximum memory requirement drops to around 2300k).
-    pub fn new(small: bool) -> Decompress {
+    pub fn new(small: bool) -> Self {
         unsafe {
             let mut raw = Box::new(mem::zeroed());
             assert_eq!(ffi::BZ2_bzDecompressInit(&mut *raw, 0, small as c_int), 0);
-            Decompress {
+            Self {
                 inner: Stream {
                     raw,
                     _marker: marker::PhantomData,
@@ -241,7 +241,7 @@ impl Decompress {
                 ffi::BZ_DATA_ERROR => Err(Error::Data),
                 ffi::BZ_DATA_ERROR_MAGIC => Err(Error::DataMagic),
                 ffi::BZ_SEQUENCE_ERROR => Err(Error::Sequence),
-                c => panic!("wut: {}", c),
+                c => panic!("wut: {c}"),
             }
         }
     }
@@ -294,18 +294,18 @@ impl error::Error for Error {}
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let description = match self {
-            Error::Sequence => "bzip2: sequence of operations invalid",
-            Error::Data => "bzip2: invalid data",
-            Error::DataMagic => "bzip2: bz2 header missing",
-            Error::Param => "bzip2: invalid parameters",
+            Self::Sequence => "bzip2: sequence of operations invalid",
+            Self::Data => "bzip2: invalid data",
+            Self::DataMagic => "bzip2: bz2 header missing",
+            Self::Param => "bzip2: invalid parameters",
         };
         f.write_str(description)
     }
 }
 
 impl From<Error> for std::io::Error {
-    fn from(data: Error) -> std::io::Error {
-        std::io::Error::other(data)
+    fn from(data: Error) -> Self {
+        Self::other(data)
     }
 }
 

src/read.rs

@@ -21,8 +21,8 @@ pub struct BzDecoder<R> {
 impl<R: Read> BzEncoder<R> {
     /// Create a new compression stream which will compress at the given level
     /// to read compress output to the give output stream.
-    pub fn new(r: R, level: Compression) -> BzEncoder<R> {
-        BzEncoder {
+    pub fn new(r: R, level: Compression) -> Self {
+        Self {
             inner: bufread::BzEncoder::new(BufReader::new(r), level),
         }
     }
@@ -84,8 +84,8 @@ impl<W: Write + Read> Write for BzEncoder<W> {
 impl<R: Read> BzDecoder<R> {
     /// Create a new decompression stream, which will read compressed
     /// data from the given input stream and decompress it.
-    pub fn new(r: R) -> BzDecoder<R> {
-        BzDecoder {
+    pub fn new(r: R) -> Self {
+        Self {
             inner: bufread::BzDecoder::new(BufReader::new(r)),
         }
     }
@@ -153,8 +153,8 @@ impl<R: Read> MultiBzDecoder<R> {
     /// Creates a new decoder from the given reader, immediately parsing the
     /// (first) gzip header. If the gzip stream contains multiple members all will
     /// be decoded.
-    pub fn new(r: R) -> MultiBzDecoder<R> {
-        MultiBzDecoder {
+    pub fn new(r: R) -> Self {
+        Self {
             inner: bufread::MultiBzDecoder::new(BufReader::new(r)),
         }
     }

src/write.rs

@@ -28,8 +28,8 @@ pub struct BzDecoder<W: Write> {
 impl<W: Write> BzEncoder<W> {
     /// Create a new compression stream which will compress at the given level
     /// to write compress output to the give output stream.
-    pub fn new(obj: W, level: Compression) -> BzEncoder<W> {
-        BzEncoder {
+    pub fn new(obj: W, level: Compression) -> Self {
+        Self {
             data: Compress::new(level, 30),
             obj: Some(obj),
             buf: Vec::with_capacity(32 * 1024),
@@ -162,8 +162,8 @@ impl<W: Write> Write for BzEncoder<W> {
 impl<W: Write> BzDecoder<W> {
     /// Create a new decoding stream which will decompress all data written
     /// to it into `obj`.
-    pub fn new(obj: W) -> BzDecoder<W> {
-        BzDecoder {
+    pub fn new(obj: W) -> Self {
+        Self {
             data: Decompress::new(false),
             obj: Some(obj),
             buf: Vec::with_capacity(32 * 1024),