change TidyFlags to Option and add git context

Author: simp4t7

src/tools/features-status-dump/src/main.rs

@@ -5,7 +5,6 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use tidy::TidyFlags;
 use tidy::diagnostics::RunningCheck;
 use tidy::features::{Feature, collect_lang_features, collect_lib_features};
 
@@ -32,7 +31,7 @@ fn main() -> Result<()> {
     let Cli { compiler_path, library_path, output_path } = Cli::parse();
 
     let lang_features_status = collect_lang_features(&compiler_path, &mut RunningCheck::new_noop());
-    let lib_features_status = collect_lib_features(&library_path, TidyFlags::default())
+    let lib_features_status = collect_lib_features(&library_path, None)
         .into_iter()
         .filter(|&(ref name, _)| !lang_features_status.contains_key(name))
         .collect();

src/tools/replace-version-placeholder/src/main.rs

@@ -16,6 +16,7 @@ fn main() {
             &root_path.join("src/doc/rustc"),
             &root_path.join("src/doc/rustdoc"),
         ],
+        None,
         |path, _is_dir| walk::filter_dirs(path),
         &mut |entry, contents| {
             if !contents.contains(VERSION_PLACEHOLDER) {

src/tools/tidy/src/alphabetical.rs

@@ -24,7 +24,7 @@ use std::fmt::Display;
 use std::iter::Peekable;
 use std::path::Path;
 
-use crate::TidyFlags;
+use crate::TidyCtx;
 use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
@@ -131,13 +131,13 @@ fn check_lines<'a>(
     }
 }
 
-pub fn check(path: &Path, tidy_flags: TidyFlags, diag_ctx: DiagCtx) {
+pub fn check(path: &Path, tidy_ctx: Option<&TidyCtx>, diag_ctx: DiagCtx) {
     let mut check = diag_ctx.start_check(CheckId::new("alphabetical").path(path));
 
     let skip =
         |path: &_, _is_dir| filter_dirs(path) || path.ends_with("tidy/src/alphabetical/tests.rs");
 
-    walk(path, tidy_flags, skip, &mut |entry, contents| {
+    walk(path, tidy_ctx, skip, &mut |entry, contents| {
         let file = &entry.path().display();
         let lines = contents.lines().enumerate();
         check_lines(file, lines, &mut check)

src/tools/tidy/src/bins.rs

@@ -29,7 +29,7 @@ mod os_impl {
     use std::process::{Command, Stdio};
 
     #[cfg(unix)]
-    use crate::TidyFlags;
+    use crate::TidyCtx;
     use crate::walk::{filter_dirs, walk_no_read};
 
     enum FilesystemSupport {
@@ -112,7 +112,7 @@ mod os_impl {
     }
 
     #[cfg(unix)]
-    pub fn check(path: &Path, tidy_flags: TidyFlags, diag_ctx: DiagCtx) {
+    pub fn check(path: &Path, tidy_ctx: Option<&TidyCtx>, diag_ctx: DiagCtx) {
         let mut check = diag_ctx.start_check("bins");
 
         use std::ffi::OsStr;
@@ -129,7 +129,7 @@ mod os_impl {
         // (e.g. using `git ls-files`).
         walk_no_read(
             &[path],
-            tidy_flags,
+            tidy_ctx,
             |path, _is_dir| {
                 filter_dirs(path)
                     || path.ends_with("src/etc")

src/tools/tidy/src/debug_artifacts.rs

@@ -2,18 +2,18 @@
 
 use std::path::Path;
 
-use crate::TidyFlags;
+use crate::TidyCtx;
 use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, filter_not_rust, walk};
 
 const GRAPHVIZ_POSTFLOW_MSG: &str = "`borrowck_graphviz_postflow` attribute in test";
 
-pub fn check(test_dir: &Path, tidy_flags: TidyFlags, diag_ctx: DiagCtx) {
+pub fn check(test_dir: &Path, tidy_ctx: Option<&TidyCtx>, diag_ctx: DiagCtx) {
     let mut check = diag_ctx.start_check(CheckId::new("debug_artifacts").path(test_dir));
 
     walk(
         test_dir,
-        tidy_flags,
+        tidy_ctx,
         |path, _is_dir| filter_dirs(path) || filter_not_rust(path),
         &mut |entry, contents| {
             for (i, line) in contents.lines().enumerate() {

src/tools/tidy/src/deps.rs

@@ -9,7 +9,7 @@ use build_helper::ci::CiEnv;
 use cargo_metadata::semver::Version;
 use cargo_metadata::{Metadata, Package, PackageId};
 
-use crate::TidyFlags;
+use crate::TidyCtx;
 use crate::diagnostics::{DiagCtx, RunningCheck};
 
 #[path = "../../../bootstrap/src/utils/proc_macro_deps.rs"]
@@ -667,12 +667,13 @@ const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
 ///
 /// `root` is path to the directory with the root `Cargo.toml` (for the workspace). `cargo` is path
 /// to the cargo executable.
-pub fn check(root: &Path, cargo: &Path, tidy_flags: TidyFlags, diag_ctx: DiagCtx) {
+pub fn check(root: &Path, cargo: &Path, tidy_ctx: Option<&TidyCtx>, diag_ctx: DiagCtx) {
     let mut check = diag_ctx.start_check("deps");
+    let bless = tidy_ctx.map(|flags| flags.bless).unwrap_or(false);
 
     let mut checked_runtime_licenses = false;
 
-    check_proc_macro_dep_list(root, cargo, tidy_flags.bless, &mut check);
+    check_proc_macro_dep_list(root, cargo, bless, &mut check);
 
     for &WorkspaceInfo { path, exceptions, crates_and_deps, submodules } in WORKSPACES {
         if has_missing_submodule(root, submodules) {

src/tools/tidy/src/edition.rs

@@ -2,13 +2,13 @@
 
 use std::path::Path;
 
-use crate::TidyFlags;
+use crate::TidyCtx;
 use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, walk};
 
-pub fn check(path: &Path, tidy_flags: TidyFlags, diag_ctx: DiagCtx) {
+pub fn check(path: &Path, tidy_ctx: Option<&TidyCtx>, diag_ctx: DiagCtx) {
     let mut check = diag_ctx.start_check(CheckId::new("edition").path(path));
-    walk(path, tidy_flags, |path, _is_dir| filter_dirs(path), &mut |entry, contents| {
+    walk(path, tidy_ctx, |path, _is_dir| filter_dirs(path), &mut |entry, contents| {
         let file = entry.path();
         let filename = file.file_name().unwrap();
         if filename != "Cargo.toml" {

src/tools/tidy/src/error_codes.rs

@@ -22,7 +22,7 @@ use std::path::Path;
 
 use regex::Regex;
 
-use crate::TidyFlags;
+use crate::TidyCtx;
 use crate::diagnostics::{DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk, walk_many};
 
@@ -41,7 +41,7 @@ pub fn check(
     root_path: &Path,
     search_paths: &[&Path],
     ci_info: &crate::CiInfo,
-    tidy_flags: TidyFlags,
+    tidy_ctx: Option<&TidyCtx>,
     diag_ctx: DiagCtx,
 ) {
     let mut check = diag_ctx.start_check("error_codes");
@@ -55,13 +55,13 @@ pub fn check(
     check.verbose_msg(format!("Highest error code: `{}`", error_codes.iter().max().unwrap()));
 
     // Stage 2: check list has docs
-    let no_longer_emitted = check_error_codes_docs(root_path, &error_codes, &mut check, tidy_flags);
+    let no_longer_emitted = check_error_codes_docs(root_path, &error_codes, &mut check, tidy_ctx);
 
     // Stage 3: check list has UI tests
     check_error_codes_tests(root_path, &error_codes, &mut check, &no_longer_emitted);
 
     // Stage 4: check list is emitted by compiler
-    check_error_codes_used(search_paths, &error_codes, &mut check, &no_longer_emitted, tidy_flags);
+    check_error_codes_used(search_paths, &error_codes, &mut check, &no_longer_emitted, tidy_ctx);
 }
 
 fn check_removed_error_code_explanation(ci_info: &crate::CiInfo, check: &mut RunningCheck) {
@@ -161,13 +161,13 @@ fn check_error_codes_docs(
     root_path: &Path,
     error_codes: &[String],
     check: &mut RunningCheck,
-    tidy_flags: TidyFlags,
+    tidy_ctx: Option<&TidyCtx>,
 ) -> Vec<String> {
     let docs_path = root_path.join(Path::new(ERROR_DOCS_PATH));
 
     let mut no_longer_emitted_codes = Vec::new();
 
-    walk(&docs_path, tidy_flags, |_, _| false, &mut |entry, contents| {
+    walk(&docs_path, tidy_ctx, |_, _| false, &mut |entry, contents| {
         let path = entry.path();
 
         // Error if the file isn't markdown.
@@ -339,48 +339,43 @@ fn check_error_codes_used(
     error_codes: &[String],
     check: &mut RunningCheck,
     no_longer_emitted: &[String],
-    tidy_flags: TidyFlags,
+    tidy_ctx: Option<&TidyCtx>,
 ) {
     // Search for error codes in the form `E0123`.
     let regex = Regex::new(r#"\bE\d{4}\b"#).unwrap();
 
     let mut found_codes = Vec::new();
 
-    walk_many(
-        search_paths,
-        tidy_flags,
-        |path, _is_dir| filter_dirs(path),
-        &mut |entry, contents| {
-            let path = entry.path();
-
-            // Return early if we aren't looking at a source file.
-            if path.extension() != Some(OsStr::new("rs")) {
-                return;
-            }
+    walk_many(search_paths, tidy_ctx, |path, _is_dir| filter_dirs(path), &mut |entry, contents| {
+        let path = entry.path();
 
-            for line in contents.lines() {
-                // We want to avoid parsing error codes in comments.
-                if line.trim_start().starts_with("//") {
-                    continue;
-                }
+        // Return early if we aren't looking at a source file.
+        if path.extension() != Some(OsStr::new("rs")) {
+            return;
+        }
 
-                for cap in regex.captures_iter(line) {
-                    if let Some(error_code) = cap.get(0) {
-                        let error_code = error_code.as_str().to_owned();
+        for line in contents.lines() {
+            // We want to avoid parsing error codes in comments.
+            if line.trim_start().starts_with("//") {
+                continue;
+            }
 
-                        if !error_codes.contains(&error_code) {
-                            // This error code isn't properly defined, we must error.
-                            check.error(format!("Error code `{error_code}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`."));
-                            continue;
-                        }
+            for cap in regex.captures_iter(line) {
+                if let Some(error_code) = cap.get(0) {
+                    let error_code = error_code.as_str().to_owned();
 
-                        // This error code can now be marked as used.
-                        found_codes.push(error_code);
+                    if !error_codes.contains(&error_code) {
+                        // This error code isn't properly defined, we must error.
+                        check.error(format!("Error code `{error_code}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`."));
+                        continue;
                     }
+
+                    // This error code can now be marked as used.
+                    found_codes.push(error_code);
                 }
             }
-        },
-    );
+        }
+    });
 
     for code in error_codes {
         if !found_codes.contains(code) && !no_longer_emitted.contains(code) {

src/tools/tidy/src/extra_checks/mod.rs

@@ -26,7 +26,7 @@ use std::{fmt, fs, io};
 use build_helper::git::get_git_untracked_files;
 
 use crate::diagnostics::DiagCtx;
-use crate::{CiInfo, TidyFlags};
+use crate::{CiInfo, TidyCtx};
 
 mod rustdoc_js;
 
@@ -56,7 +56,7 @@ pub fn check(
     cargo: &Path,
     extra_checks: Option<&str>,
     pos_args: &[String],
-    tidy_flags: TidyFlags,
+    tidy_ctx: Option<&TidyCtx>,
     diag_ctx: DiagCtx,
 ) {
     let mut check = diag_ctx.start_check("extra_checks");
@@ -71,7 +71,7 @@ pub fn check(
         cargo,
         extra_checks,
         pos_args,
-        tidy_flags,
+        tidy_ctx,
     ) {
         check.error(e);
     }
@@ -87,10 +87,11 @@ fn check_impl(
     cargo: &Path,
     extra_checks: Option<&str>,
     pos_args: &[String],
-    tidy_flags: TidyFlags,
+    tidy_ctx: Option<&TidyCtx>,
 ) -> Result<(), Error> {
     let show_diff =
         std::env::var("TIDY_PRINT_DIFF").is_ok_and(|v| v.eq_ignore_ascii_case("true") || v == "1");
+    let bless = tidy_ctx.map(|flags| flags.bless).unwrap_or(false);
 
     // Split comma-separated args up
     let mut lint_args = match extra_checks {
@@ -130,7 +131,7 @@ fn check_impl(
     }
 
     let rerun_with_bless = |mode: &str, action: &str| {
-        if !tidy_flags.bless {
+        if !bless {
             eprintln!("rerun tidy with `--extra-checks={mode} --bless` to {action}");
         }
     };
@@ -159,7 +160,7 @@ fn check_impl(
 
     if python_lint {
         let py_path = py_path.as_ref().unwrap();
-        let args: &[&OsStr] = if tidy_flags.bless {
+        let args: &[&OsStr] = if bless {
             eprintln!("linting python files and applying suggestions");
             &["check".as_ref(), "--fix".as_ref()]
         } else {
@@ -169,7 +170,7 @@ fn check_impl(
 
         let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
 
-        if res.is_err() && show_diff && !tidy_flags.bless {
+        if res.is_err() && show_diff && !bless {
             eprintln!("\npython linting failed! Printing diff suggestions:");
 
             let diff_res = run_ruff(
@@ -191,7 +192,7 @@ fn check_impl(
 
     if python_fmt {
         let mut args: Vec<&OsStr> = vec!["format".as_ref()];
-        if tidy_flags.bless {
+        if bless {
             eprintln!("formatting python files");
         } else {
             eprintln!("checking python file formatting");
@@ -201,7 +202,7 @@ fn check_impl(
         let py_path = py_path.as_ref().unwrap();
         let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &args);
 
-        if res.is_err() && !tidy_flags.bless {
+        if res.is_err() && !bless {
             if show_diff {
                 eprintln!("\npython formatting does not match! Printing diff:");
 
@@ -227,7 +228,7 @@ fn check_impl(
         let config_path = root_path.join(".clang-format");
         let config_file_arg = format!("file:{}", config_path.display());
         cfg_args_clang_format.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
-        if tidy_flags.bless {
+        if bless {
             eprintln!("formatting C++ files");
             cfg_args_clang_format.push("-i".as_ref());
         } else {
@@ -247,7 +248,7 @@ fn check_impl(
         let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
         let res = py_runner(py_path.as_ref().unwrap(), false, None, "clang-format", &args);
 
-        if res.is_err() && show_diff && !tidy_flags.bless {
+        if res.is_err() && show_diff && !bless {
             eprintln!("\nclang-format linting failed! Printing diff suggestions:");
 
             let mut cfg_args_clang_format_diff = cfg_args.clone();
@@ -312,7 +313,7 @@ fn check_impl(
 
         args.extend_from_slice(SPELLCHECK_DIRS);
 
-        if tidy_flags.bless {
+        if bless {
             eprintln!("spellchecking files and fixing typos");
             args.push("--write-changes");
         } else {
@@ -330,17 +331,17 @@ fn check_impl(
     }
 
     if js_lint {
-        if tidy_flags.bless {
+        if bless {
             eprintln!("linting javascript files");
         } else {
             eprintln!("linting javascript files and applying suggestions");
         }
-        let res = rustdoc_js::lint(outdir, librustdoc_path, tools_path, tidy_flags);
+        let res = rustdoc_js::lint(outdir, librustdoc_path, tools_path, tidy_ctx);
         if res.is_err() {
             rerun_with_bless("js:lint", "apply eslint suggestions");
         }
         res?;
-        rustdoc_js::es_check(outdir, librustdoc_path, tidy_flags)?;
+        rustdoc_js::es_check(outdir, librustdoc_path, tidy_ctx)?;
     }
 
     if js_typecheck {