Automatically rename more files with cargo dev rename_lint

Author: Jarcho

clippy_dev/src/update_lints.rs

@@ -5,7 +5,7 @@ use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs;
-use std::io::Write as _;
+use std::io::{self, Read as _, Seek as _, Write as _};
 use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
 
@@ -189,7 +189,7 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     };
 
     // Renamed lints and deprecated lints shouldn't have been found in the lint list, but check just in
-    // case.)
+    // case.
     assert!(
         !renamed_lints.iter().any(|l| lint.old_name == l.old_name),
         "`{}` has already been renamed",
@@ -207,18 +207,15 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
         .map(Result::unwrap)
         .filter(|f| {
             let name = f.path().file_name();
-            f.path().extension() == Some(OsStr::new("rs"))
+            let ext = f.path().extension();
+            (ext == Some(OsStr::new("rs")) || ext == Some(OsStr::new("fixed")))
                 && name != Some(OsStr::new("rename.rs"))
                 && name != Some(OsStr::new("renamed_lints.rs"))
         })
     {
-        let path = file.path();
-        let contents =
-            fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {}", path.display(), e));
-        if let Some(contents) = replace_ident_like(&contents, &[(&lint.old_name, &lint.new_name)]) {
-            fs::write(path, contents.as_bytes())
-                .unwrap_or_else(|e| panic!("Cannot write to `{}`: {}", path.display(), e));
-        }
+        rewrite_file(file.path(), |s| {
+            replace_ident_like(s, &[(&lint.old_name, &lint.new_name)])
+        });
     }
 
     renamed_lints.push(lint);
@@ -230,72 +227,75 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
             .then_with(|| lhs.old_name.cmp(&rhs.old_name))
     });
 
+    write_file(
+        Path::new("clippy_lints/src/renamed_lints.rs"),
+        &gen_renamed_lints_list(&renamed_lints),
+    );
+
     if uplift {
+        write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_list(&renamed_lints));
         println!(
-            "`{}` has be uplifted. Please remove all the code inside `clippy_lints` related to it.",
+            "`{}` has be uplifted. All the code inside `clippy_lints` related to it needs to be removed manually.",
             old_name
         );
-        let contents = gen_renamed_lints_test(&renamed_lints);
-        fs::write("tests/ui/rename.rs", contents.as_bytes())
-            .unwrap_or_else(|e| panic!("error writing file `tests/ui/rename.rs`: {}", e));
     } else if found_new_name {
+        write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_list(&renamed_lints));
         println!(
-            "`{}` is already defined. The old linting code inside `clippy_lints` has to be updated/removed manually",
+            "`{}` is already defined. The old linting code inside `clippy_lints` needs to be updated/removed manually.",
             new_name
         );
-        let contents = gen_renamed_lints_test(&renamed_lints);
-        fs::write("tests/ui/rename.rs", contents.as_bytes())
-            .unwrap_or_else(|e| panic!("error writing file `tests/ui/rename.rs`: {}", e));
     } else {
         // Rename the lint struct and the containing module if it shares the lint name across all files.
         let lint = &mut lints[old_lint_index];
         let old_name_upper = old_name.to_uppercase();
         let new_name_upper = new_name.to_uppercase();
-        let new_module_path = PathBuf::from(format!("clippy_lints/src/{}.rs", new_name));
-        let replacements;
 
-        let (replacements, mut renamed_file) = if lint.module == lint.name
-            // Only rename the module if the file doesn't already exist.
-            && let Ok(file) = fs::OpenOptions::new().create_new(true).write(true).open(&new_module_path)
-        {
+        if try_rename_file(
+            Path::new(&format!("tests/ui/{}.rs", old_name)),
+            Path::new(&format!("tests/ui/{}.rs", new_name)),
+        ) {
+            try_rename_file(
+                Path::new(&format!("tests/ui/{}.stderr", old_name)),
+                Path::new(&format!("tests/ui/{}.stderr", new_name)),
+            );
+            try_rename_file(
+                Path::new(&format!("tests/ui/{}.fixed", old_name)),
+                Path::new(&format!("tests/ui/{}.fixed", new_name)),
+            );
+        }
+
+        let replacements;
+        let replacements = if lint.module == lint.name
+            && try_rename_file(
+                Path::new(&format!("clippy_lints/src/{}.rs", old_name)),
+                Path::new(&format!("clippy_lints/src/{}.rs", new_name)),
+            ) {
             lint.module = new_name.into();
             replacements = [(&*old_name_upper, &*new_name_upper), (old_name, new_name)];
-            (replacements.as_slice(), Some(file))
+            replacements.as_slice()
+        } else if !lint.module.contains("::")
+            && try_rename_file(
+                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, old_name)),
+                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, new_name)),
+            )
+        {
+            replacements = [(&*old_name_upper, &*new_name_upper), (old_name, new_name)];
+            replacements.as_slice()
         } else {
             replacements = [(&*old_name_upper, &*new_name_upper), ("", "")];
-            (&replacements[0..1], None)
+            &replacements[0..1]
         };
         lint.name = new_name.into();
 
-        for (rel_path, file) in clippy_lints_src_files() {
-            let path = file.path();
-            let contents =
-                fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {}", path.display(), e));
-            let new_contents = replace_ident_like(&contents, replacements);
-
-            if let Some(ref mut file) = renamed_file
-                // Make sure the file is directly in the src directory and not a sub-directory.
-                && rel_path.parent().map_or(false, |p| p.as_os_str().is_empty())
-                && rel_path.file_stem() == Some(OsStr::new(old_name))
-            {
-                let contents = new_contents.as_ref().unwrap_or(&contents);
-                file.write_all(contents.as_bytes())
-                    .unwrap_or_else(|e| panic!("Cannot write to `{}`: {}", new_module_path.display(), e));
-                renamed_file = None;
-                fs::remove_file(path)
-                    .unwrap_or_else(|e| panic!("Cannot delete file `{}`: {}", path.display(), e));
-            } else if let Some(contents) = new_contents {
-                fs::write(path, contents.as_bytes())
-                    .unwrap_or_else(|e| panic!("Cannot write to `{}`: {}", path.display(), e));
-            }
+        for (_, file) in clippy_lints_src_files() {
+            rewrite_file(file.path(), |s| replace_ident_like(s, replacements));
         }
 
         generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
+        println!("{} has been successfully renamed", old_name);
     }
 
-    let contents = gen_renamed_lints_list(&renamed_lints);
-    fs::write("clippy_lints/src/renamed_lints.rs", contents.as_bytes())
-        .unwrap_or_else(|e| panic!("error writing file `clippy_lints/src/renamed_lints.rs`: {}", e));
+    println!("note: `cargo uitest` still needs to be run to update the test results");
 }
 
 /// Replace substrings if they aren't bordered by identifier characters. Returns `None` if there
@@ -741,6 +741,52 @@ fn replace_region_in_text<'a>(
     Ok(res)
 }
 
+fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
+    match fs::OpenOptions::new().create_new(true).write(true).open(new_name) {
+        Ok(file) => drop(file),
+        Err(e) if e.kind() == io::ErrorKind::AlreadyExists => return false,
+        Err(e) => panic_file(e, new_name, "create"),
+    };
+    match fs::rename(old_name, new_name) {
+        Ok(()) => true,
+        Err(e) => {
+            drop(fs::remove_file(new_name));
+            if e.kind() == io::ErrorKind::NotFound {
+                false
+            } else {
+                panic_file(e, old_name, "rename");
+            }
+        },
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+fn panic_file(error: io::Error, name: &Path, action: &str) -> ! {
+    panic!("failed to {} file `{}`: {}", action, name.display(), error)
+}
+
+fn rewrite_file(path: &Path, f: impl FnOnce(&str) -> Option<String>) {
+    let mut file = fs::OpenOptions::new()
+        .write(true)
+        .read(true)
+        .open(path)
+        .unwrap_or_else(|e| panic_file(e, path, "open"));
+    let mut buf = String::new();
+    file.read_to_string(&mut buf)
+        .unwrap_or_else(|e| panic_file(e, path, "read"));
+    if let Some(new_contents) = f(&buf) {
+        file.rewind().unwrap_or_else(|e| panic_file(e, path, "write"));
+        file.write_all(new_contents.as_bytes())
+            .unwrap_or_else(|e| panic_file(e, path, "write"));
+        file.set_len(new_contents.len() as u64)
+            .unwrap_or_else(|e| panic_file(e, path, "write"));
+    }
+}
+
+fn write_file(path: &Path, contents: &str) {
+    fs::write(path, contents).unwrap_or_else(|e| panic_file(e, path, "write"));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;