fix clippy warnings

src/lz4/block/api.rs

@@ -64,7 +64,7 @@ pub fn decompress_safe(src: &[u8], dst: &mut [u8]) -> Result<usize> {
             dst.as_mut_ptr() as *mut c_char,
             src.len() as c_int,
             dst.len() as c_int,
-        ) as i32
+        )
     };
     if result < 0 {
         Err(Error::new(ErrorKind::DecompressionFailed))
@@ -81,7 +81,7 @@ pub fn decompress_safe_partial(src: &[u8], dst: &mut [u8], original_size: usize)
             src.len() as c_int,
             original_size as c_int,
             dst.len() as c_int,
-        ) as i32
+        )
     };
     if result < 0 {
         Err(Error::new(ErrorKind::DecompressionFailed))
@@ -99,7 +99,7 @@ pub fn decompress_safe_using_dict(src: &[u8], dst: &mut [u8], dict: &[u8]) -> Re
             dst.len() as c_int,
             dict.as_ptr() as *const c_char,
             dict.len() as c_int,
-        ) as i32
+        )
     };
     if result < 0 {
         Err(Error::new(ErrorKind::DecompressionFailed))
@@ -123,7 +123,7 @@ pub fn decompress_safe_partial_using_dict(
             dst.len() as c_int,
             dict.as_ptr() as *const c_char,
             dict.len() as c_int,
-        ) as i32
+        )
     };
     if result < 0 {
         Err(Error::new(ErrorKind::DecompressionFailed))

src/lz4/stream/api.rs

@@ -30,7 +30,7 @@ impl CompressionContext {
         unsafe {
             let ptr = binding::LZ4_initStream(
                 stream.as_mut_ptr() as *mut c_void,
-                size_of::<LZ4Stream>() as usize,
+                size_of::<LZ4Stream>(),
             );
             if !ptr.is_null() {
                 return Ok(Self {
@@ -134,7 +134,7 @@ impl DecompressionContext {
                 dst as *mut c_char,
                 src.len() as c_int,
                 dst_len as c_int,
-            ) as i32
+            )
         };
         if result < 0 {
             Err(Error::new(ErrorKind::DecompressionFailed))

src/lz4_hc/stream/api.rs

@@ -28,12 +28,7 @@ impl CompressionContext {
     }
 
     pub fn set_favor_dec_speed(&mut self, flag: bool) {
-        unsafe {
-            binding::LZ4_favorDecompressionSpeed(
-                self.stream.as_ptr(),
-                if flag { 1 } else { 0 } as c_int,
-            )
-        }
+        unsafe { binding::LZ4_favorDecompressionSpeed(self.stream.as_ptr(), i32::from(flag)) }
     }
 
     pub fn load_dict(&mut self, dict: &[u8]) {

src/lz4f/api.rs

@@ -53,7 +53,7 @@ impl CompressionContext {
             } else {
                 binding::LZ4F_compressBegin(self.ctx.as_ptr(), dst as *mut c_void, dst_len, prefs)
             }
-        } as usize;
+        };
         result_from_code(code).map(|_| code)
     }
 
@@ -74,7 +74,7 @@ impl CompressionContext {
                 src.len(),
                 &opt as *const LZ4FCompressionOptions,
             )
-        } as usize;
+        };
         result_from_code(code).map(|_| code)
     }
 
@@ -87,7 +87,7 @@ impl CompressionContext {
                 dst_len,
                 &opt as *const LZ4FCompressionOptions,
             )
-        } as usize;
+        };
         result_from_code(code).map(|_| code)
     }
 
@@ -100,12 +100,12 @@ impl CompressionContext {
                 dst_len,
                 &opt as *const LZ4FCompressionOptions,
             )
-        } as usize;
+        };
         result_from_code(code).map(|_| code)
     }
 
     pub fn compress_bound(src_size: usize, prefs: &Preferences) -> usize {
-        unsafe { binding::LZ4F_compressBound(src_size as usize, prefs as *const Preferences) }
+        unsafe { binding::LZ4F_compressBound(src_size, prefs as *const Preferences) }
     }
 }
 
@@ -151,7 +151,7 @@ impl DecompressionContext {
                 &mut src_len as *mut usize,
             )
         };
-        result_from_code(code).map(|_| (unsafe { info.assume_init() }, src_len as usize))
+        result_from_code(code).map(|_| (unsafe { info.assume_init() }, src_len))
     }
 
     pub fn decompress_dict(
@@ -176,7 +176,7 @@ impl DecompressionContext {
                 &opt as *const LZ4FDecompressionOptions,
             )
         };
-        result_from_code(code).map(|_| (src_len as usize, dst_len as usize, code as usize))
+        result_from_code(code).map(|_| (src_len, dst_len, code))
     }
 
     pub fn reset(&mut self) {
@@ -195,11 +195,11 @@ impl Drop for DecompressionContext {
 }
 
 pub fn compress_frame_bound(src_size: usize, prefs: &Preferences) -> usize {
-    unsafe { binding::LZ4F_compressFrameBound(src_size as usize, prefs as *const Preferences) }
+    unsafe { binding::LZ4F_compressFrameBound(src_size, prefs as *const Preferences) }
 }
 
 pub fn header_size(src: &[u8]) -> usize {
-    unsafe { binding::LZ4F_headerSize(src.as_ptr() as *const c_void, src.len()) as usize }
+    unsafe { binding::LZ4F_headerSize(src.as_ptr() as *const c_void, src.len()) }
 }
 
 pub fn compress(src: &[u8], dst: *mut u8, dst_len: usize, prefs: &Preferences) -> Result<usize> {
@@ -210,7 +210,7 @@ pub fn compress(src: &[u8], dst: *mut u8, dst_len: usize, prefs: &Preferences) -
             src.as_ptr() as *const c_void,
             src.len(),
             prefs as *const Preferences,
-        ) as usize
+        )
     };
     result_from_code(code).map(|_| code)
 }

src/lz4f/binding.rs

@@ -29,7 +29,7 @@ pub struct LZ4FCompressionOptions {
 impl LZ4FCompressionOptions {
     pub fn stable(stable: bool) -> Self {
         Self {
-            stable_src: if stable { 1 } else { 0 },
+            stable_src: u32::from(stable),
             ..Default::default()
         }
     }
@@ -45,7 +45,7 @@ pub struct LZ4FDecompressionOptions {
 impl LZ4FDecompressionOptions {
     pub fn stable(stable: bool) -> Self {
         Self {
-            stable_dst: if stable { 1 } else { 0 },
+            stable_dst: u32::from(stable),
             ..Default::default()
         }
     }

src/lz4f/frame_info.rs

@@ -115,7 +115,7 @@ impl FrameInfo {
 
     /// Returns the dictionary id.
     pub const fn dict_id(&self) -> u32 {
-        self.dict_id as u32
+        self.dict_id
     }
 
     /// Returns the block checksum.

src/lz4f/preferences.rs

@@ -57,7 +57,7 @@ impl Preferences {
 
     /// Returns the compression level.
     pub const fn compression_level(&self) -> i32 {
-        self.compression_level as i32
+        self.compression_level
     }
 
     /// Returns the auto flush mode flag.

tests/common/mod.rs

@@ -70,8 +70,7 @@ fn preferences_set() -> impl Iterator<Item = Preferences> {
 
 pub fn lz4f_test_set() -> impl Iterator<Item = (Bytes, Preferences)> {
     generate_data()
-        .map(|data| preferences_set().map(move |prefs| (data.clone(), prefs)))
-        .flatten()
+        .flat_map(|data| preferences_set().map(move |prefs| (data.clone(), prefs)))
 }
 
 fn compression_acc_set() -> impl Iterator<Item = i32> {
@@ -80,8 +79,7 @@ fn compression_acc_set() -> impl Iterator<Item = i32> {
 
 pub fn lz4_test_set() -> impl Iterator<Item = (Bytes, i32)> {
     generate_data()
-        .map(|data| compression_acc_set().map(move |acc| (data.clone(), acc)))
-        .flatten()
+        .flat_map(|data| compression_acc_set().map(move |acc| (data.clone(), acc)))
 }
 
 pub fn lz4_stream_test_set() -> impl Iterator<Item = (Vec<Bytes>, i32)> {
@@ -102,8 +100,7 @@ fn compression_level_set() -> impl Iterator<Item = i32> {
 
 pub fn lz4_hc_test_set() -> impl Iterator<Item = (Bytes, i32)> {
     generate_data()
-        .map(|data| compression_level_set().map(move |level| (data.clone(), level)))
-        .flatten()
+        .flat_map(|data| compression_level_set().map(move |level| (data.clone(), level)))
 }
 
 pub fn lz4_hc_stream_test_set() -> impl Iterator<Item = (Vec<Bytes>, i32)> {

tests/lz4.rs

@@ -54,8 +54,7 @@ mod decompress {
     #[test]
     fn partial() {
         lz4_test_set()
-            .map(|(src, mode)| (0..20).map(move |n| (src.clone(), mode, 16 << n)))
-            .flatten()
+            .flat_map(|(src, mode)| (0..20).map(move |n| (src.clone(), mode, 16 << n)))
             .par_bridge()
             .for_each(|(src, mode, len)| {
                 let mut comp_buf = Vec::new();

tests/lz4_hc.rs

@@ -26,8 +26,7 @@ mod compress_partial {
     #[test]
     fn default() {
         lz4_hc_test_set()
-            .map(|(src, level)| (0..20).map(move |n| (src.clone(), level, 16 << n)))
-            .flatten()
+            .flat_map(|(src, level)| (0..20).map(move |n| (src.clone(), level, 16 << n)))
             .par_bridge()
             .for_each(|(src, level, len)| {
                 let mut comp_buf = vec![0; len];