wowlab_tidy/languages/rust/

mod.rs

// #t(file: rust_default_hasher) trusted rule-name keys in a cold dispatch set; fast-hasher dependency not warranted

//! Rust source parsing and rule execution.

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

mod rules;

use std::collections::HashSet;

use line_index::LineIndex;
use ra_ap_syntax::{
    AstNode, Edition, SourceFile, SyntaxNode,
    ast::{self, HasAttrs, HasName},
};

use crate::{
    FileCtx, Rule, RuleCheck, RuleFix, Violation,
    infra::{ignore, scanner},
    languages::Analysis,
    matches_ignore,
};

const DIRECTIVE_RULE: &str = "rust_tidy_directives";

#[derive(Debug)]
pub(crate) struct SuppressionAudit {
    pub suppressions: ignore::Suppressions,
    pub raw_violations: Vec<Violation>,
    pub workspace_file: crate::languages::workspace::WorkspaceRustFile,
}

#[derive(Debug)]
pub(crate) enum SuppressionAuditError {
    InvalidDirectives(Vec<Violation>),
    RustSyntax,
}

pub(crate) struct AstCtx<'a> {
    pub(crate) file: &'a FileCtx<'a>,
    pub(crate) root: &'a SourceFile,
    pub(crate) line_index: &'a LineIndex,
}

pub(crate) trait RustLocation {
    fn line_in(&self, ctx: &AstCtx<'_>) -> usize;
}

impl<N> RustLocation for &N
where
    N: AstNode,
{
    fn line_in(&self, ctx: &AstCtx<'_>) -> usize {
        ctx.line_index
            .line_col(self.syntax().text_range().start())
            .line as usize
            + 1
    }
}

#[expect(
    clippy::unused_self,
    reason = "context helper methods keep syntax analysis call sites cohesive"
)]
impl AstCtx<'_> {
    pub(crate) fn nodes<'a, N>(&'a self) -> impl Iterator<Item = N> + 'a
    where
        N: AstNode + 'a,
    {
        self.root.syntax().descendants().filter_map(N::cast)
    }

    pub(crate) fn is_in_test<N>(&self, node: &N) -> bool
    where
        N: AstNode,
    {
        node.syntax()
            .ancestors()
            .filter_map(ast::Item::cast)
            .any(|item| item.attrs().any(|attr| is_test_attribute(&attr)))
    }

    #[expect(
        clippy::needless_pass_by_value,
        reason = "RustLocation is implemented for AST references, so the generic value is already a cheap reference"
    )]
    pub(crate) fn line_of(&self, location: impl RustLocation) -> usize {
        location.line_in(self)
    }

    pub(crate) fn violation(
        &self,
        location: impl RustLocation,
        msg: impl Into<String>,
    ) -> Violation {
        crate::violation(self.file.rel, self.line_of(location), msg)
    }
}

impl std::fmt::Debug for AstCtx<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AstCtx")
            .field("file", &self.file)
            .field("root", &"<ra_ap_syntax::SourceFile>")
            .field("line_index", &self.line_index)
            .finish()
    }
}

// #t(fn: rust_cyclomatic_complexity) the adapter coordinates parse, suppression, line, AST, workspace, and fix paths
pub(crate) fn analyze(
    file: &FileCtx<'_>,
    rules: &[&Rule],
    registered_names: &HashSet<&str>,
    fix_mode: bool,
) -> Analysis {
    let mut analysis = Analysis::default();
    let mut ignore_errors = Vec::new();
    let ra_parse = SourceFile::parse(file.contents, Edition::Edition2024);
    let ra_root = ra_parse.errors().is_empty().then(|| ra_parse.tree());
    let visible_lines = ra_root.as_ref().map_or_else(
        || file.lines.to_vec(),
        |syntax| line_rule_view(file.lines, syntax, file.contents, file.rel),
    );
    let line_file = FileCtx {
        rel: file.rel,
        path: file.path,
        lines: &visible_lines,
        contents: file.contents,
        config: file.config,
    };
    let directive_lines = scanner::directive_source_lines(file.contents, &visible_lines);
    let suppressed = ignore::suppressed_lines(
        line_file.rel,
        &directive_lines,
        &mut ignore_errors,
        Some(registered_names),
    );
    let workspace_suppressions = suppressed.clone();

    analysis.violations.extend(
        ignore_errors
            .into_iter()
            .map(|violation| violation.with_rule(DIRECTIVE_RULE)),
    );

    for rule in rules {
        let RuleCheck::RustLine(check) = rule.check else {
            continue;
        };

        if is_suppressed(&line_file, rule, &suppressed) {
            continue;
        }

        let violations = ignore::filter(&suppressed, tagged(rule, check(&line_file)));

        if fix_mode {
            if let Some(RuleFix::RustLine(fix)) = rule.fix {
                collect_fixes(&mut analysis, file.rel, &violations, |violation| {
                    fix(&line_file, violation)
                });
            }
        }

        analysis.violations.extend(violations);
    }

    if let Some(root) = ra_root {
        let line_index = LineIndex::new(file.contents);
        let ctx = AstCtx {
            file,
            root: &root,
            line_index: &line_index,
        };

        for rule in rules {
            let RuleCheck::RustAst(check) = rule.check else {
                continue;
            };

            if is_suppressed(file, rule, &suppressed) {
                continue;
            }

            let violations = ignore::filter(&suppressed, tagged(rule, check(&ctx)));

            if fix_mode {
                match rule.fix {
                    Some(RuleFix::RustAst(fix)) => {
                        collect_fixes(&mut analysis, file.rel, &violations, |violation| {
                            fix(&ctx, violation)
                        });
                    }
                    Some(RuleFix::RustAstTree(fix)) => {
                        if !violations.is_empty()
                            && let Some(replacement) = fix(&ctx, &violations)
                        {
                            analysis.tree_fixes.push(crate::infra::fix::TreeFix {
                                rel: file.rel.to_owned(),
                                rule: rule.info.name,
                                replacement,
                            });
                        }
                    }
                    _ => {}
                }
            }

            analysis.violations.extend(violations);
        }

        if rules.iter().any(|rule| {
            matches!(
                rule.check,
                RuleCheck::RustWorkspace(_) | RuleCheck::Workspace(_)
            )
        }) {
            analysis
                .workspace_files
                .push(crate::languages::workspace::extract(
                    file,
                    &root,
                    workspace_suppressions,
                ));
        }
    }

    analysis
}

/// Analyze directive usage without applying source suppressions or config path ignores.
pub(crate) fn audit_suppressions(
    file: &FileCtx<'_>,
    rules: &[&Rule],
    registered_names: &HashSet<&str>,
) -> Result<SuppressionAudit, SuppressionAuditError> {
    let ra_parse = SourceFile::parse(file.contents, Edition::Edition2024);

    if !ra_parse.errors().is_empty() {
        return Err(SuppressionAuditError::RustSyntax);
    }

    let root = ra_parse.tree();
    let visible_lines = line_rule_view(file.lines, &root, file.contents, file.rel);
    let audit_lines = scanner::directive_source_lines(file.contents, &visible_lines);
    let audit_file = FileCtx {
        rel: file.rel,
        path: file.path,
        lines: &audit_lines,
        contents: file.contents,
        config: file.config,
    };
    let mut directive_errors = Vec::new();
    let suppressions = ignore::suppressed_lines(
        file.rel,
        &audit_lines,
        &mut directive_errors,
        Some(registered_names),
    );

    if !directive_errors.is_empty() {
        return Err(SuppressionAuditError::InvalidDirectives(directive_errors));
    }

    let ast = AstCtx {
        file: &audit_file,
        root: &root,
        line_index: &LineIndex::new(file.contents),
    };
    let mut raw_violations = Vec::new();

    for rule in rules {
        let violations = match rule.check {
            RuleCheck::RustLine(check) => check(&audit_file),
            RuleCheck::RustAst(check) => check(&ast),
            RuleCheck::RustWorkspace(_) | RuleCheck::Workspace(_) | RuleCheck::Toml(_) => continue,
        };

        raw_violations.extend(tagged(rule, violations));
    }

    raw_violations.sort_by(|a, b| a.line.cmp(&b.line).then(a.rule.cmp(&b.rule)));
    let workspace_file = crate::languages::workspace::extract(file, &root, suppressions.clone());

    Ok(SuppressionAudit {
        suppressions,
        raw_violations,
        workspace_file,
    })
}

/// Evaluate raw Rust workspace-rule violations once without applying source suppressions.
pub(crate) fn audit_workspace_suppressions(
    files: &[crate::languages::workspace::WorkspaceRustFile],
    rules: &[&Rule],
    config: &crate::Config,
) -> Vec<Violation> {
    let ctx = crate::languages::workspace::WorkspaceCtx {
        files,
        manifests: &[],
        config,
    };
    let mut violations = Vec::new();

    for rule in rules {
        let RuleCheck::RustWorkspace(check) = rule.check else {
            continue;
        };

        violations.extend(
            check(&ctx)
                .into_iter()
                .map(|violation| violation.with_rule(rule.info.name)),
        );
    }

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

    violations
}

fn line_rule_view<'a>(
    lines: &[&'a str],
    syntax: &SourceFile,
    contents: &str,
    rel: &str,
) -> Vec<&'a str> {
    let mut excluded = vec![false; lines.len()];
    let line_index = LineIndex::new(contents);
    let rule_implementation =
        rel.starts_with("crates/tidy/src/languages/") && rel.contains("/rules/");

    for item in syntax.syntax().descendants().filter_map(ast::Item::cast) {
        if is_line_rule_metadata(&item, rule_implementation)
            || item.attrs().any(|attr| is_test_attribute(&attr))
        {
            exclude_item(&mut excluded, &line_index, item.syntax());
        }
    }

    lines
        .iter()
        .zip(excluded)
        .map(|(&line, excluded)| if excluded { "" } else { line })
        .collect()
}

fn exclude_item(excluded: &mut [bool], line_index: &LineIndex, node: &SyntaxNode) {
    let start = line_index.line_col(node.text_range().start()).line as usize;
    let end = line_index.line_col(node.text_range().end()).line as usize + 1;
    let range_start = start.min(excluded.len());
    let range_end = end.min(excluded.len());

    if let Some(region) = excluded.get_mut(range_start..range_end) {
        region.fill(true);
    }
}

fn is_line_rule_metadata(item: &ast::Item, rule_implementation: bool) -> bool {
    if let ast::Item::Const(item_const) = item {
        if item_const.name().is_some_and(|name| {
            let text = name.text();

            text == "EXAMPLES" || rule_implementation && text.contains("PATTERN")
        }) {
            return true;
        }
    }

    let ast::Item::MacroCall(item_macro) = item else {
        return false;
    };

    let macro_token = item_macro
        .path()
        .and_then(|path| path.segment())
        .and_then(|segment| segment.syntax().last_token());

    macro_token.is_some_and(|token| {
        matches!(
            token.text(),
            "line_rule"
                | "ast_rule"
                | "toml_rule"
                | "tidy_test"
                | "tidy_ast_test"
                | "tidy_toml_test"
        )
    })
}

fn is_test_attribute(attr: &ast::Attr) -> bool {
    match attr.simple_name().as_deref() {
        Some("test") => true,
        Some("cfg" | "cfg_attr") => attr
            .syntax()
            .descendants_with_tokens()
            .filter_map(ra_ap_syntax::NodeOrToken::into_token)
            .any(|token| token.text() == "test"),
        _ => false,
    }
}

fn is_suppressed(file: &FileCtx<'_>, rule: &Rule, suppressed: &ignore::Suppressions) -> bool {
    matches_ignore(file.rel, file.config.ignore_patterns(rule.info.name))
        || ignore::is_file_suppressed(suppressed, rule.info.name)
}

fn tagged(rule: &Rule, violations: Vec<Violation>) -> Vec<Violation> {
    violations
        .into_iter()
        .map(|violation| violation.with_rule(rule.info.name))
        .collect()
}

fn collect_fixes(
    analysis: &mut Analysis,
    rel: &str,
    violations: &[Violation],
    fix: impl Fn(&Violation) -> Option<crate::Fix>,
) {
    analysis.fixes.extend(
        violations
            .iter()
            .filter_map(fix)
            .map(|fix| (rel.to_owned(), fix)),
    );
}

#[cfg(test)]
mod tests {
    use wowlab_fs::path::Path;

    use super::*;
    use crate::infra::config::Config;

    fn analyze_all(source: &str) -> Analysis {
        let metadata = crate::all_rules();
        let registered_meta: Vec<_> = metadata
            .iter()
            .map(|rule| (rule.name, rule.params))
            .collect();
        let config = Config::generate_default(&registered_meta);
        let lines: Vec<&str> = source.lines().collect();
        let file = FileCtx {
            rel: "adapter.rs",
            path: Path::new("adapter.rs"),
            lines: &lines,
            contents: source,
            config: &config,
        };
        let rules: Vec<&Rule> = inventory::iter::<Rule>
            .into_iter()
            .filter(|rule| config.is_enabled(rule.info.name))
            .collect();
        let registered = rules.iter().map(|rule| rule.info.name).collect();

        analyze(&file, &rules, &registered, false)
    }

    #[gtest]
    fn clean_fixture_has_no_violations() -> Result<()> {
        let analysis = analyze_all(include_str!("../../../tests/fixtures/clean.rs"));

        verify_true!(analysis.violations.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn dirty_source_reports_registered_rules() -> Result<()> {
        let analysis = analyze_all("fn f() { dbg!(1); let value = 42; }");
        let rules: Vec<_> = analysis
            .violations
            .iter()
            .filter_map(|violation| violation.rule)
            .collect();

        verify_true!(rules.contains(&"rust_dbg"))?;
        verify_true!(rules.contains(&"rust_magic_numbers"))?;

        Ok(())
    }

    #[gtest]
    fn adapter_applies_line_suppressions_after_tagging() -> Result<()> {
        let analysis =
            analyze_all("fn f() {\n    // #t(rust_dbg) intentional diagnostic\n    dbg!(1);\n}\n");

        verify_true!(
            analysis
                .violations
                .iter()
                .all(|violation| violation.rule != Some("rust_dbg"))
        )?;

        Ok(())
    }

    #[gtest]
    fn directive_lookalikes_do_not_suppress_ast_rules() -> Result<()> {
        let source = concat!(
            "const RAW: &str = r#\"\n",
            "// #t(file: rust_panic) raw string lookalike\n",
            "\"#;\n",
            "/*\n",
            "// #t(file: rust_panic) block comment lookalike\n",
            "*/\n",
            "fn production() { panic!(); }\n",
        );
        let analysis = analyze_all(source);

        verify_true!(
            analysis
                .violations
                .iter()
                .any(|violation| violation.rule == Some("rust_panic"))
        )?;

        Ok(())
    }

    #[gtest]
    fn line_rules_ignore_examples_and_test_literals() -> Result<()> {
        let source = r#"
use crate::Example;

const EXAMPLES: &[Example] = &[
    Example { label: "path", code: "const P: &str = \"/home/dev/file\";", pass: false },
    Example { label: "box", code: "type T = Box<Vec<u8>>;", pass: false },
    Example { label: "directive", code: "// #t(rust_unknown) fixture", pass: false },
];

#[cfg(test)]
mod tests {
    const URL: &str = "https://example.com";
    const BOXED: &str = "Box<Vec<u8>>";
}
"#;
        let config = Config::generate_default(&[]);
        let lines: Vec<&str> = source.lines().collect();
        let file = FileCtx {
            rel: "fixture_regions.rs",
            path: Path::new("fixture_regions.rs"),
            lines: &lines,
            contents: source,
            config: &config,
        };
        let rules: Vec<&Rule> = inventory::iter::<Rule>
            .into_iter()
            .filter(|rule| {
                matches!(
                    rule.info.name,
                    "rust_abs_home_path"
                        | "rust_box_vec"
                        | "rust_hardcoded_url"
                        | "rust_tidy_directives"
                )
            })
            .collect();
        let registered: HashSet<&str> = inventory::iter::<Rule>
            .into_iter()
            .map(|rule| rule.info.name)
            .collect();

        let analysis = analyze(&file, &rules, &registered, true);

        verify_true!(analysis.violations.is_empty())?;
        verify_true!(analysis.fixes.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn line_rules_still_analyze_production_source() -> Result<()> {
        let source = "const PATH: &str = \"/home/dev/file\";";
        let config = Config::generate_default(&[]);
        let lines: Vec<&str> = source.lines().collect();
        let file = FileCtx {
            rel: "production.rs",
            path: Path::new("production.rs"),
            lines: &lines,
            contents: source,
            config: &config,
        };
        let rules: Vec<&Rule> = inventory::iter::<Rule>
            .into_iter()
            .filter(|rule| rule.info.name == "rust_abs_home_path")
            .collect();
        let registered: HashSet<&str> = inventory::iter::<Rule>
            .into_iter()
            .map(|rule| rule.info.name)
            .collect();

        let analysis = analyze(&file, &rules, &registered, false);

        verify_eq!(analysis.violations.len(), 1)?;

        Ok(())
    }
}