wowlab_tidy/runner/

mod.rs

// #t(file: rust_default_hasher) trusted rule-name sets in the cold runner setup path; fast-hasher dependency not warranted

mod cache;
mod clean;
mod report;

use std::collections::HashSet;

use rayon::prelude::*;
use report::{print_dry_run, print_grouped};
use wowlab_common::output;
use wowlab_fs::{
    file,
    path::{Path, PathBuf},
};

use crate::{
    Config, FileCtx, Fix, Rule, Violation,
    infra::{
        fix::{self, TreeFix},
        walk,
    },
    languages::{self, workspace::WorkspaceCtx},
};

#[rustfmt::skip]
pub use clean::clean_suppressions;

#[rustfmt::skip]
pub use report::report_suppressions;

struct FileResult {
    path: PathBuf,
    analysis: languages::Analysis,
}
type CollectedAnalysis = (Vec<Violation>, Vec<(String, Fix)>, Vec<TreeFix>);
type AnalysisResult = Result<CollectedAnalysis, AnalysisError>;
type FileAnalysis = Result<Option<FileResult>, String>;
type CollectedResults = (
    Vec<Violation>,
    Vec<(String, Fix)>,
    Vec<TreeFix>,
    Vec<languages::workspace::WorkspaceRustFile>,
    Vec<languages::workspace::WorkspaceManifest>,
);

#[derive(Debug, thiserror::Error)]
pub(crate) enum AnalysisError {
    #[error(transparent)]
    Discovery(#[from] walk::PathDiscoveryError),
    #[error("failed to read source files: {0}")]
    Read(Box<str>),
}

const MAX_FIX_ITERATIONS: usize = 10;

/// Resolve the target directory Cargo uses for workspace tooling.
#[must_use]
pub fn cargo_target_dir(root: &Path, crates_dir: &Path) -> PathBuf {
    resolve_cargo_target_dir(
        root,
        crates_dir,
        std::env::var_os("CARGO_TARGET_DIR").map(PathBuf::from),
    )
}

fn resolve_cargo_target_dir(
    root: &Path,
    crates_dir: &Path,
    configured: Option<PathBuf>,
) -> PathBuf {
    match configured {
        Some(path) if path.is_absolute() => path,
        Some(path) => root.join(path),
        None => crates_dir.join("target"),
    }
}

fn matches_rule_filter(name: &str, filter: &[String]) -> bool {
    filter.is_empty() || filter.iter().any(|r| r == name)
}

/// How the runner should handle auto-fixable violations.
#[derive(Clone, Copy, Debug)]
// #t(rust_non_exhaustive_on_public) internal enum used only by the tidy binary
pub enum FixMode {
    Off,
    Apply,
    DryRun,
}

/// Inputs needed by `run` and `collect_violations`.
#[derive(Debug)]
pub struct RunCtx<'a> {
    pub rule_filter: &'a [String],
    pub crate_filter: &'a [String],
    pub config: &'a Config,
    pub root: &'a Path,
    pub crates_dir: &'a Path,
    pub quiet: bool,
    pub dirty: bool,
}

/// Run tidy rules with human-readable terminal output. Returns `true` if clean.
#[must_use]
pub fn run(ctx: &RunCtx<'_>, fix: FixMode) -> bool {
    let total = enabled_rules(ctx).len();

    if total == 0 {
        if !ctx.quiet {
            output::error("no rules matched (check tidy.toml and --rule filter)");
        }

        return false;
    }

    if !ctx.quiet {
        output::detail(&format!("running {total} rule(s)"));
        output::blank();
    }

    let collect_fixes = !matches!(fix, FixMode::Off);
    let (all_violations, fixes, tree_fixes) = match collect_violations(ctx, collect_fixes, None) {
        Ok(result) => result,
        Err(error) => {
            if !ctx.quiet {
                output::error(&format!("tidy analysis aborted: {error}"));
            }

            return false;
        }
    };

    if collect_fixes && (!fixes.is_empty() || !tree_fixes.is_empty()) {
        return apply_and_verify(ctx, fix, fixes, tree_fixes, total);
    }

    if all_violations.is_empty() {
        if !ctx.quiet {
            output::success(&format!("all {total} rule(s) passed"));
            output::blank();
        }

        true
    } else {
        if !ctx.quiet {
            print_grouped(&all_violations);
        }

        false
    }
}

fn enabled_rules(ctx: &RunCtx<'_>) -> Vec<&'static Rule> {
    inventory::iter::<Rule>
        .into_iter()
        .filter(|rule| {
            ctx.config.is_enabled(rule.info.name)
                && matches_rule_filter(rule.info.name, ctx.rule_filter)
        })
        .collect()
}

// #t(fn: rust_alloc_in_loop, rust_cyclomatic_complexity) fixpoint orchestration branches by edit kind and terminal state
fn apply_and_verify(
    ctx: &RunCtx<'_>,
    fix: FixMode,
    mut fixes: Vec<(String, Fix)>,
    mut tree_fixes: Vec<TreeFix>,
    total: usize,
) -> bool {
    if matches!(fix, FixMode::DryRun) {
        if !ctx.quiet {
            let mut previews = fixes;

            for tree_fix in tree_fixes {
                let line_count = file::read_text(&ctx.root.join(&tree_fix.rel))
                    .map_or(1, |contents| contents.lines().count().max(1));

                previews.push((
                    tree_fix.rel,
                    Fix {
                        start_line: 1,
                        end_line: line_count,
                        replacement: tree_fix.replacement,
                    },
                ));
            }

            print_dry_run(&previews);
            output::detail(&format!(
                "{} fix(es) would be applied (dry run, no files changed)",
                previews.len()
            ));
            output::blank();
        }

        return false;
    }

    let mut applied_total = 0;

    for _ in 0..MAX_FIX_ITERATIONS {
        let applied = if tree_fixes.is_empty() {
            fix::apply_fixes(&fixes, ctx.root)
        } else {
            tree_fixes.sort_by(|a, b| a.rule.cmp(b.rule).then(a.rel.cmp(&b.rel)));
            let rule = tree_fixes[0].rule;
            let selected: Vec<TreeFix> = tree_fixes
                .iter()
                .filter(|tree_fix| tree_fix.rule == rule)
                .cloned()
                .collect();

            fix::apply_tree_fixes(&selected, ctx.root)
        };

        applied_total += applied;
        let (remaining, next_fixes, next_tree_fixes) = match collect_violations(ctx, true, None) {
            Ok(result) => result,
            Err(error) => {
                if !ctx.quiet {
                    output::error(&format!("tidy analysis aborted after fixes: {error}"));
                }

                return false;
            }
        };

        if remaining.is_empty() {
            if !ctx.quiet {
                output::success(&format!("applied {applied_total} fix(es)"));
                output::blank();
                output::success(&format!("all {total} rule(s) passed after fixes"));
                output::blank();
            }

            return true;
        }

        if next_fixes.is_empty() && next_tree_fixes.is_empty() {
            if !ctx.quiet {
                output::success(&format!("applied {applied_total} fix(es)"));
                output::blank();
                print_grouped(&remaining);
            }

            return false;
        }

        if applied == 0 {
            if !ctx.quiet {
                output::error("fix conflict: fixable violations remain but no edit made progress");
                print_grouped(&remaining);
            }

            return false;
        }

        fixes = next_fixes;
        tree_fixes = next_tree_fixes;
    }

    let remaining = match collect_violations(ctx, false, None) {
        Ok((remaining, _, _)) => remaining,
        Err(error) => {
            if !ctx.quiet {
                output::error(&format!("tidy analysis aborted after fixes: {error}"));
            }

            return false;
        }
    };

    if !ctx.quiet {
        output::error("fix conflict: reached the 10-iteration fixpoint cap");
        print_grouped(&remaining);
    }

    false
}

/// Walk the target crates in parallel and collect all violations (and optional fixes) from every enabled rule.
pub(crate) fn collect_violations(
    ctx: &RunCtx<'_>,
    fix_mode: bool,
    paths_override: Option<Vec<PathBuf>>,
) -> AnalysisResult {
    let rules = enabled_rules(ctx);

    if rules.is_empty() {
        return Ok((Vec::new(), Vec::new(), Vec::new()));
    }

    let mut extensions: Vec<&str> = rules
        .iter()
        .flat_map(|rule| rule.check.extensions().iter().copied())
        .collect();

    extensions.sort_unstable();
    extensions.dedup();

    let (paths, target_rels) = analysis_paths(ctx, paths_override, &extensions)?;
    let registered_names: HashSet<&str> = inventory::iter::<Rule>
        .into_iter()
        .map(|rule| rule.info.name)
        .collect();
    let cache = (!fix_mode)
        .then(|| cache::Session::open(ctx, &rules))
        .flatten();

    if let Some(result) = complete_cache_result(cache.as_ref(), &rules, target_rels.as_ref()) {
        return Ok(result);
    }

    let analyzed = analyze_paths(
        &paths,
        cache.as_ref(),
        ctx,
        &rules,
        &registered_names,
        fix_mode,
    );
    let results = require_complete_analysis(analyzed)?;

    persist_file_cache(cache.as_ref(), ctx.root, &results);

    let (
        mut all_violations,
        mut all_fixes,
        mut all_tree_fixes,
        workspace_files,
        workspace_manifests,
    ) = merge_file_results(results);
    let workspace_ctx = WorkspaceCtx {
        files: &workspace_files,
        manifests: &workspace_manifests,
        config: ctx.config,
    };

    all_violations.extend(workspace_violations(cache.as_ref(), &rules, &workspace_ctx));
    persist_workspace_cache(cache.as_ref());
    persist_complete_cache(cache.as_ref(), &all_violations);
    retain_targets(
        target_rels.as_ref(),
        &mut all_violations,
        &mut all_fixes,
        &mut all_tree_fixes,
    );

    all_violations.sort_by(|a, b| a.rel.cmp(&b.rel).then(a.line.cmp(&b.line)));

    Ok((all_violations, all_fixes, all_tree_fixes))
}

fn complete_cache_result(
    cache: Option<&cache::Session>,
    rules: &[&'static Rule],
    target_rels: Option<&HashSet<String>>,
) -> Option<CollectedAnalysis> {
    let mut violations = cache?.complete(rules)?;

    if let Some(target_rels) = target_rels {
        violations.retain(|violation| target_rels.contains(&violation.rel));
    }

    violations.sort_by(|a, b| a.rel.cmp(&b.rel).then(a.line.cmp(&b.line)));

    Some((violations, Vec::new(), Vec::new()))
}

fn analyze_paths(
    paths: &[PathBuf],
    cache: Option<&cache::Session>,
    ctx: &RunCtx<'_>,
    rules: &[&'static Rule],
    registered_names: &HashSet<&str>,
    fix_mode: bool,
) -> Vec<FileAnalysis> {
    paths
        .par_iter()
        .map(|path| {
            if let Some(result) = cache.and_then(|cache| cache.restore(path, rules)) {
                return Ok(Some(result));
            }

            analyze_path(path, ctx, rules, registered_names, fix_mode)
        })
        .collect()
}

fn persist_file_cache(cache: Option<&cache::Session>, root: &Path, results: &[FileResult]) {
    if let Some(cache) = cache {
        cache.persist(root, results);
    }
}

fn persist_complete_cache(cache: Option<&cache::Session>, violations: &[Violation]) {
    if let Some(cache) = cache {
        cache.persist_complete(violations);
    }
}

fn persist_workspace_cache(cache: Option<&cache::Session>) {
    if let Some(cache) = cache {
        cache.persist_workspace();
    }
}

fn retain_targets(
    target_rels: Option<&HashSet<String>>,
    violations: &mut Vec<Violation>,
    fixes: &mut Vec<(String, Fix)>,
    tree_fixes: &mut Vec<TreeFix>,
) {
    let Some(target_rels) = target_rels else {
        return;
    };

    violations.retain(|violation| target_rels.contains(&violation.rel));
    fixes.retain(|(rel, _)| target_rels.contains(rel));
    tree_fixes.retain(|tree_fix| target_rels.contains(&tree_fix.rel));
}

fn analysis_paths(
    ctx: &RunCtx<'_>,
    paths_override: Option<Vec<PathBuf>>,
    extensions: &[&str],
) -> Result<(Vec<PathBuf>, Option<HashSet<String>>), AnalysisError> {
    let requested = match paths_override {
        Some(paths) => Some(paths),
        None if ctx.dirty => Some(walk::git_dirty_paths(
            ctx.root,
            ctx.crates_dir,
            ctx.crate_filter,
            extensions,
        )?),
        None if !ctx.crate_filter.is_empty() => Some(walk::source_paths(
            ctx.crates_dir,
            ctx.crate_filter,
            extensions,
        )?),
        None => None,
    };
    let Some(requested) = requested else {
        return Ok((walk::source_paths(ctx.crates_dir, &[], extensions)?, None));
    };
    let target_rels = requested
        .iter()
        .map(|path| {
            path.strip_prefix(ctx.root)
                .unwrap_or(path)
                .display()
                .to_string()
        })
        .collect();
    let paths = walk::source_paths(ctx.crates_dir, &[], extensions)?;

    Ok((paths, Some(target_rels)))
}

fn analyze_path(
    path: &Path,
    ctx: &RunCtx<'_>,
    rules: &[&'static Rule],
    registered_names: &HashSet<&str>,
    fix_mode: bool,
) -> FileAnalysis {
    let rel = path
        .strip_prefix(ctx.root)
        .unwrap_or(path)
        .display()
        .to_string();
    let contents = file::read_text(path).map_err(|error| format!("{rel}: {error}"))?;
    let lines: Vec<&str> = contents.lines().collect();
    let file = FileCtx {
        rel: &rel,
        path,
        lines: &lines,
        contents: &contents,
        config: ctx.config,
    };
    let analysis = match path.extension().and_then(|extension| extension.to_str()) {
        Some("rs") => languages::rust::analyze(&file, rules, registered_names, fix_mode),
        Some("toml") => languages::toml::analyze(&file, rules, fix_mode),
        _ => return Ok(None),
    };

    Ok(Some(FileResult {
        path: path.to_path_buf(),
        analysis,
    }))
}

fn require_complete_analysis(
    analyzed: Vec<FileAnalysis>,
) -> Result<Vec<FileResult>, AnalysisError> {
    let mut failures = Vec::new();
    let mut results = Vec::new();

    for result in analyzed {
        match result {
            Ok(Some(result)) => results.push(result),
            Ok(None) => {}
            Err(error) => failures.push(error),
        }
    }

    if failures.is_empty() {
        Ok(results)
    } else {
        failures.sort_unstable();
        failures.dedup();

        Err(AnalysisError::Read(failures.join("; ").into_boxed_str()))
    }
}

fn merge_file_results(results: Vec<FileResult>) -> CollectedResults {
    let mut all_violations = Vec::new();
    let mut all_fixes = Vec::new();
    let mut all_tree_fixes = Vec::new();
    let mut workspace_files = Vec::new();
    let mut workspace_manifests = Vec::new();

    for result in results {
        all_violations.extend(result.analysis.violations);
        all_fixes.extend(result.analysis.fixes);
        all_tree_fixes.extend(result.analysis.tree_fixes);
        workspace_files.extend(result.analysis.workspace_files);
        workspace_manifests.extend(result.analysis.workspace_manifests);
    }

    (
        all_violations,
        all_fixes,
        all_tree_fixes,
        workspace_files,
        workspace_manifests,
    )
}

fn workspace_violations(
    cache: Option<&cache::Session>,
    rules: &[&'static Rule],
    workspace_ctx: &WorkspaceCtx<'_>,
) -> Vec<Violation> {
    let mut violations = Vec::new();

    for rule in rules {
        let (crate::RuleCheck::RustWorkspace(check) | crate::RuleCheck::Workspace(check)) =
            rule.check
        else {
            continue;
        };
        let compute = || {
            check(workspace_ctx)
                .into_iter()
                .map(|violation| violation.with_rule(rule.info.name))
                .filter(|violation| {
                    workspace_ctx
                        .files
                        .iter()
                        .find(|file| file.rel == violation.rel)
                        .is_none_or(|file| {
                            !crate::infra::ignore::is_file_suppressed(
                                &file.suppressions,
                                rule.info.name,
                            ) && !file
                                .suppressions
                                .entries
                                .iter()
                                .any(|entry| entry.suppresses(violation))
                        })
                })
                .collect()
        };
        let rule_violations = if let Some(cache) = cache {
            cache.workspace_violations(rule, workspace_ctx, compute)
        } else {
            compute()
        };

        violations.extend(rule_violations);
    }

    violations
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    #[gtest]
    fn cargo_target_dir_honors_absolute_relative_and_default_paths() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let root = directory.path();
        let crates_dir = root.join("crates");
        let absolute = root.join("persistent-target");

        verify_eq!(
            resolve_cargo_target_dir(root, &crates_dir, Some(absolute.clone())),
            absolute
        )?;
        verify_eq!(
            resolve_cargo_target_dir(root, &crates_dir, Some(PathBuf::from("shared-target"))),
            root.join("shared-target")
        )?;

        verify_eq!(
            resolve_cargo_target_dir(root, &crates_dir, None),
            crates_dir.join("target")
        )
    }

    #[gtest]
    fn source_read_failures_are_fatal_and_deterministic() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let crates_dir = directory.path().join("crates");

        wowlab_fs::directory::create(&crates_dir).or_fail()?;
        let first = crates_dir.join("a.rs");
        let second = crates_dir.join("b.rs");

        file::write_bytes(&first, [0xff]).or_fail()?;
        file::write_bytes(&second, [0xff]).or_fail()?;

        let metadata = crate::all_rules();
        let registered: Vec<_> = metadata
            .iter()
            .map(|rule| (rule.name, rule.params))
            .collect();
        let config = Config::generate_default(&registered);
        let ctx = RunCtx {
            rule_filter: &[],
            crate_filter: &[],
            config: &config,
            root: directory.path(),
            crates_dir: &crates_dir,
            quiet: true,
            dirty: false,
        };
        let error = collect_violations(&ctx, false, Some(vec![second, first]))
            .unwrap_err()
            .to_string();

        verify_that!(error.as_str(), contains_substring("crates/a.rs"))?;
        verify_that!(error.as_str(), contains_substring("crates/b.rs"))?;

        verify_true!(error.find("crates/a.rs").or_fail()? < error.find("crates/b.rs").or_fail()?)
    }

    #[gtest]
    fn restricted_analysis_retains_complete_workspace_context() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let crates_dir = directory.path().join("crates");

        wowlab_fs::directory::create(&crates_dir).or_fail()?;
        let requested = crates_dir.join("changed.rs");
        let context_only = crates_dir.join("unchanged.rs");

        file::write_text(&requested, "fn changed() {}\n").or_fail()?;
        file::write_text(&context_only, "fn unchanged() {}\n").or_fail()?;

        let metadata = crate::all_rules();
        let registered: Vec<_> = metadata
            .iter()
            .map(|rule| (rule.name, rule.params))
            .collect();
        let config = Config::generate_default(&registered);
        let ctx = RunCtx {
            rule_filter: &[],
            crate_filter: &[],
            config: &config,
            root: directory.path(),
            crates_dir: &crates_dir,
            quiet: true,
            dirty: false,
        };
        let (paths, target_rels) = analysis_paths(&ctx, Some(vec![requested]), &["rs"])?;

        verify_that!(paths, len(eq(2)))?;

        verify_eq!(
            target_rels,
            Some(HashSet::from(["crates/changed.rs".to_string()]))
        )
    }

    #[gtest]
    fn crate_filtered_analysis_retains_complete_workspace_context() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let crates_dir = directory.path().join("crates");
        let selected_dir = crates_dir.join("selected");
        let context_dir = crates_dir.join("context");

        wowlab_fs::directory::ensure(&selected_dir).or_fail()?;
        wowlab_fs::directory::ensure(&context_dir).or_fail()?;
        file::write_text(&selected_dir.join("selected.rs"), "fn selected() {}\n").or_fail()?;
        file::write_text(&context_dir.join("context.rs"), "fn context() {}\n").or_fail()?;

        let metadata = crate::all_rules();
        let registered: Vec<_> = metadata
            .iter()
            .map(|rule| (rule.name, rule.params))
            .collect();
        let config = Config::generate_default(&registered);
        let crate_filter = vec!["selected".to_string()];
        let ctx = RunCtx {
            rule_filter: &[],
            crate_filter: &crate_filter,
            config: &config,
            root: directory.path(),
            crates_dir: &crates_dir,
            quiet: true,
            dirty: false,
        };
        let (paths, target_rels) = analysis_paths(&ctx, None, &["rs"])?;

        verify_that!(paths, len(eq(2)))?;

        verify_eq!(
            target_rels,
            Some(HashSet::from(["crates/selected/selected.rs".to_string()]))
        )
    }

    #[gtest]
    fn fixpoint_rechecks_unfixed_files_in_the_selected_scope() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let crates_dir = directory.path().join("crates");
        let crate_dir = crates_dir.join("demo");

        wowlab_fs::directory::ensure(&crate_dir).or_fail()?;
        let fixable = crate_dir.join("fixable.rs");

        file::write_text(
            &fixable,
            "pub fn value() {\n    let value = 1;\n    std::hint::black_box(value);\n}\n",
        )
        .or_fail()?;
        file::write_text(
            &crate_dir.join("unfixable.rs"),
            "pub fn explode() {\n    panic!();\n}\n",
        )
        .or_fail()?;

        let metadata = crate::all_rules();
        let registered: Vec<_> = metadata
            .iter()
            .map(|rule| (rule.name, rule.params))
            .collect();
        let config = Config::generate_default(&registered);
        let rule_filter = vec!["rust_padding".to_string(), "rust_panic".to_string()];
        let crate_filter = vec!["demo".to_string()];
        let ctx = RunCtx {
            rule_filter: &rule_filter,
            crate_filter: &crate_filter,
            config: &config,
            root: directory.path(),
            crates_dir: &crates_dir,
            quiet: true,
            dirty: false,
        };

        verify_false!(run(&ctx, FixMode::Apply))?;

        let fixed = file::read_text(&fixable).or_fail()?;

        verify_that!(
            fixed,
            contains_substring("let value = 1;\n\n    std::hint::black_box(value);")
        )
    }
}