Fix clippy warnings

rafalh · rafalh · commit 641d896928ab · 2023-10-10T00:13:39.000+02:00
diff --git a/examples/ls.rs b/examples/ls.rs
@@ -29,7 +29,7 @@ fn main() -> io::Result<()> {
     let dir = match env::args().nth(1) {
         None => root_dir,
         Some(ref path) if path == "." => root_dir,
-        Some(ref path) => root_dir.open_dir(&path)?,
+        Some(ref path) => root_dir.open_dir(path)?,
     };
     for r in dir.iter() {
         let e = r?;
diff --git a/examples/mkfatfs.rs b/examples/mkfatfs.rs
@@ -7,7 +7,7 @@ use fscommon::BufStream;
 
 fn main() -> io::Result<()> {
     let filename = env::args().nth(1).expect("image path expected");
-    let file = fs::OpenOptions::new().read(true).write(true).open(&filename)?;
+    let file = fs::OpenOptions::new().read(true).write(true).open(filename)?;
     let buf_file = BufStream::new(file);
     format_volume(&mut StdIoWrapper::from(buf_file), FormatVolumeOptions::new())?;
     Ok(())
diff --git a/src/boot_sector.rs b/src/boot_sector.rs
@@ -875,7 +875,7 @@ mod tests {
         let total_sectors = total_sectors as u32;
 
         let sectors_per_cluster = (bytes_per_cluster / u32::from(bytes_per_sector)) as u8;
-        let root_dir_size = root_dir_entries * DIR_ENTRY_SIZE as u32;
+        let root_dir_size = root_dir_entries * DIR_ENTRY_SIZE;
         let root_dir_sectors = (root_dir_size + u32::from(bytes_per_sector) - 1) / u32::from(bytes_per_sector);
         let sectors_per_fat = determine_sectors_per_fat(
             total_sectors,
@@ -978,7 +978,7 @@ mod tests {
         total_sectors_vec.push(8227);
         for total_sectors in total_sectors_vec {
             let (boot, _) = format_boot_sector::<()>(&FormatVolumeOptions::new(), total_sectors, bytes_per_sector)
-                .expect(&format!("format_boot_sector total_sectors: {}", total_sectors));
+                .unwrap_or_else(|_| panic!("format_boot_sector total_sectors: {}", total_sectors));
             boot.validate::<()>().expect("validate");
         }
     }
diff --git a/src/dir_entry.rs b/src/dir_entry.rs
@@ -387,7 +387,7 @@ impl DirEntryData {
             Err(err) => {
                 return Err(err);
             }
-            Ok(_) => {}
+            Ok(()) => {}
         }
         let attrs = FileAttributes::from_bits_truncate(rdr.read_u8()?);
         if attrs & FileAttributes::LFN == FileAttributes::LFN {
@@ -744,7 +744,7 @@ mod tests {
     fn short_name_without_ext() {
         let oem_cp_conv = LossyOemCpConverter::new();
         assert_eq!(ShortName::new(b"FOO        ").to_string(&oem_cp_conv), "FOO");
-        assert_eq!(ShortName::new(&b"LOOK AT    ").to_string(&oem_cp_conv), "LOOK AT");
+        assert_eq!(ShortName::new(b"LOOK AT    ").to_string(&oem_cp_conv), "LOOK AT");
     }
 
     #[test]
diff --git a/src/file.rs b/src/file.rs
@@ -92,13 +92,11 @@ impl<'a, IO: ReadWriteSeek, TP, OCC> File<'a, IO, TP, OCC> {
     pub fn extents(&mut self) -> impl Iterator<Item = Result<Extent, Error<IO::Error>>> + 'a {
         let fs = self.fs;
         let cluster_size = fs.cluster_size();
-        let mut bytes_left = match self.size() {
-            Some(s) => s,
-            None => return None.into_iter().flatten(),
+        let Some(mut bytes_left) = self.size() else {
+            return None.into_iter().flatten();
         };
-        let first = match self.first_cluster {
-            Some(f) => f,
-            None => return None.into_iter().flatten(),
+        let Some(first) = self.first_cluster else {
+            return None.into_iter().flatten();
         };
 
         Some(
@@ -277,9 +275,8 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for File<'_, IO, TP, OCC> {
         } else {
             self.current_cluster
         };
-        let current_cluster = match current_cluster_opt {
-            Some(n) => n,
-            None => return Ok(0),
+        let Some(current_cluster) = current_cluster_opt else {
+            return Ok(0);
         };
         let offset_in_cluster = self.offset % cluster_size;
         let bytes_left_in_cluster = (cluster_size - offset_in_cluster) as usize;
@@ -421,9 +418,7 @@ impl<IO: ReadWriteSeek, TP, OCC> Seek for File<'_, IO, TP, OCC> {
                 .and_then(|s| i64::from(s).checked_add(o))
                 .and_then(|n| u32::try_from(n).ok()),
         };
-        let mut new_offset = if let Some(new_offset) = new_offset_opt {
-            new_offset
-        } else {
+        let Some(mut new_offset) = new_offset_opt else {
             error!("Invalid seek offset");
             return Err(Error::InvalidInput);
         };
diff --git a/src/table.rs b/src/table.rs
@@ -705,7 +705,7 @@ mod tests {
             let actual_cluster_numbers = iter.map(Result::ok).collect::<Vec<_>>();
             let expected_cluster_numbers = [0xA_u32, 0x14_u32, 0x15_u32, 0x16_u32, 0x19_u32, 0x1A_u32]
                 .iter()
-                .cloned()
+                .copied()
                 .map(Some)
                 .collect::<Vec<_>>();
             assert_eq!(actual_cluster_numbers, expected_cluster_numbers);
diff --git a/tests/read.rs b/tests/read.rs
@@ -13,7 +13,7 @@ const FAT32_IMG: &str = "resources/fat32.img";
 
 type FileSystem = fatfs::FileSystem<StdIoWrapper<BufStream<fs::File>>, DefaultTimeProvider, LossyOemCpConverter>;
 
-fn call_with_fs<F: Fn(FileSystem) -> ()>(f: F, filename: &str) {
+fn call_with_fs<F: Fn(FileSystem)>(f: F, filename: &str) {
     let _ = env_logger::builder().is_test(true).try_init();
     let file = fs::File::open(filename).unwrap();
     let buf_file = BufStream::new(file);
@@ -209,8 +209,8 @@ fn test_volume_metadata_fat32() {
 
 fn test_status_flags(fs: FileSystem) {
     let status_flags = fs.read_status_flags().unwrap();
-    assert_eq!(status_flags.dirty(), false);
-    assert_eq!(status_flags.io_error(), false);
+    assert!(!status_flags.dirty());
+    assert!(!status_flags.io_error());
 }
 
 #[test]
diff --git a/tests/write.rs b/tests/write.rs
@@ -17,36 +17,36 @@ const TEST_STR2: &str = "Rust is cool!\n";
 
 type FileSystem = fatfs::FileSystem<StdIoWrapper<BufStream<fs::File>>, DefaultTimeProvider, LossyOemCpConverter>;
 
-fn call_with_tmp_img<F: Fn(&str) -> ()>(f: F, filename: &str, test_seq: u32) {
+fn call_with_tmp_img<F: Fn(&str)>(f: F, filename: &str, test_seq: u32) {
     let _ = env_logger::builder().is_test(true).try_init();
     let img_path = format!("{}/{}", IMG_DIR, filename);
     let tmp_path = format!("{}/{}-{}", TMP_DIR, test_seq, filename);
     fs::create_dir(TMP_DIR).ok();
-    fs::copy(&img_path, &tmp_path).unwrap();
+    fs::copy(img_path, &tmp_path).unwrap();
     f(tmp_path.as_str());
     fs::remove_file(tmp_path).unwrap();
 }
 
 fn open_filesystem_rw(tmp_path: &str) -> FileSystem {
-    let file = fs::OpenOptions::new().read(true).write(true).open(&tmp_path).unwrap();
+    let file = fs::OpenOptions::new().read(true).write(true).open(tmp_path).unwrap();
     let buf_file = BufStream::new(file);
     let options = FsOptions::new().update_accessed_date(true);
     FileSystem::new(buf_file, options).unwrap()
 }
 
-fn call_with_fs<F: Fn(FileSystem) -> ()>(f: F, filename: &str, test_seq: u32) {
+fn call_with_fs<F: Fn(FileSystem)>(f: F, filename: &str, test_seq: u32) {
     let callback = |tmp_path: &str| {
         let fs = open_filesystem_rw(tmp_path);
         f(fs);
     };
-    call_with_tmp_img(&callback, filename, test_seq);
+    call_with_tmp_img(callback, filename, test_seq);
 }
 
 fn test_write_short_file(fs: FileSystem) {
     let root_dir = fs.root_dir();
     let mut file = root_dir.open_file("short.txt").expect("open file");
     file.truncate().unwrap();
-    file.write_all(&TEST_STR.as_bytes()).unwrap();
+    file.write_all(TEST_STR.as_bytes()).unwrap();
     file.seek(io::SeekFrom::Start(0)).unwrap();
     let mut buf = Vec::new();
     file.read_to_end(&mut buf).unwrap();
@@ -73,7 +73,7 @@ fn test_write_long_file(fs: FileSystem) {
     let mut file = root_dir.open_file("long.txt").expect("open file");
     file.truncate().unwrap();
     let test_str = TEST_STR.repeat(1000);
-    file.write_all(&test_str.as_bytes()).unwrap();
+    file.write_all(test_str.as_bytes()).unwrap();
     file.seek(io::SeekFrom::Start(0)).unwrap();
     let mut buf = Vec::new();
     file.read_to_end(&mut buf).unwrap();
@@ -147,7 +147,7 @@ fn test_create_file(fs: FileSystem) {
         let mut file = root_dir
             .create_file("very/long/path/new-file-with-long-name.txt")
             .unwrap();
-        file.write_all(&TEST_STR.as_bytes()).unwrap();
+        file.write_all(TEST_STR.as_bytes()).unwrap();
     }
     // check for dir entry
     names = dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
@@ -340,21 +340,21 @@ fn test_dirty_flag(tmp_path: &str) {
     // Open filesystem, make change, and forget it - should become dirty
     let fs = open_filesystem_rw(tmp_path);
     let status_flags = fs.read_status_flags().unwrap();
-    assert_eq!(status_flags.dirty(), false);
-    assert_eq!(status_flags.io_error(), false);
+    assert!(!status_flags.dirty());
+    assert!(!status_flags.io_error());
     fs.root_dir().create_file("abc.txt").unwrap();
     mem::forget(fs);
     // Check if volume is dirty now
     let fs = open_filesystem_rw(tmp_path);
     let status_flags = fs.read_status_flags().unwrap();
-    assert_eq!(status_flags.dirty(), true);
-    assert_eq!(status_flags.io_error(), false);
+    assert!(status_flags.dirty());
+    assert!(!status_flags.io_error());
     fs.unmount().unwrap();
     // Make sure remounting does not clear the dirty flag
     let fs = open_filesystem_rw(tmp_path);
     let status_flags = fs.read_status_flags().unwrap();
-    assert_eq!(status_flags.dirty(), true);
-    assert_eq!(status_flags.io_error(), false);
+    assert!(status_flags.dirty());
+    assert!(!status_flags.io_error());
 }
 
 #[test]
@@ -388,15 +388,15 @@ fn test_multiple_files_in_directory(fs: FileSystem) {
 
 #[test]
 fn test_multiple_files_in_directory_fat12() {
-    call_with_fs(&test_multiple_files_in_directory, FAT12_IMG, 8)
+    call_with_fs(test_multiple_files_in_directory, FAT12_IMG, 8)
 }
 
 #[test]
 fn test_multiple_files_in_directory_fat16() {
-    call_with_fs(&test_multiple_files_in_directory, FAT16_IMG, 8)
+    call_with_fs(test_multiple_files_in_directory, FAT16_IMG, 8)
 }
 
 #[test]
 fn test_multiple_files_in_directory_fat32() {
-    call_with_fs(&test_multiple_files_in_directory, FAT32_IMG, 8)
+    call_with_fs(test_multiple_files_in_directory, FAT32_IMG, 8)
 }

Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ impl DirEntryData {`
`387`	`387`	`Err(err) => {`
`388`	`388`	`return Err(err);`
`389`	`389`	`}`
`390`		`- Ok(_) => {}`
	`390`	`+ Ok(()) => {}`
`391`	`391`	`}`
`392`	`392`	`let attrs = FileAttributes::from_bits_truncate(rdr.read_u8()?);`
`393`	`393`	`if attrs & FileAttributes::LFN == FileAttributes::LFN {`
`@@ -744,7 +744,7 @@ mod tests {`
`744`	`744`	`fn short_name_without_ext() {`
`745`	`745`	`let oem_cp_conv = LossyOemCpConverter::new();`
`746`	`746`	`assert_eq!(ShortName::new(b"FOO ").to_string(&oem_cp_conv), "FOO");`
`747`		`- assert_eq!(ShortName::new(&b"LOOK AT ").to_string(&oem_cp_conv), "LOOK AT");`
	`747`	`+ assert_eq!(ShortName::new(b"LOOK AT ").to_string(&oem_cp_conv), "LOOK AT");`
`748`	`748`	`}`
`749`	`749`
`750`	`750`	`#[test]`