wowlab_tidy/

registry.rs

use std::collections::BTreeMap;

use crate::{AstCtx, FileCtx, Fix, TomlCtx, Violation, languages::workspace::WorkspaceCtx};

/// A rule entry enriched with config data, consumed by docgen.
#[derive(Debug, serde::Deserialize, serde::Serialize)]
pub struct ConfigRule {
    pub name: String,
    pub description: String,
    pub severity: String,
    pub category: String,
    pub fixable: bool,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub ignore: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub params: Option<BTreeMap<String, ConfigValue>>,
}

/// JSON-compatible resolved configuration value.
#[derive(Debug, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct ConfigValue(serde_json::Value);

impl From<serde_json::Value> for ConfigValue {
    fn from(value: serde_json::Value) -> Self {
        Self(value)
    }
}

impl PartialEq<i32> for ConfigValue {
    fn eq(&self, other: &i32) -> bool {
        self.0.as_i64() == Some(i64::from(*other))
    }
}

/// Whether a rule operates on raw lines or parsed AST.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
// #t(rust_non_exhaustive_on_public) internal enum, all variants matched within this crate
pub enum RuleKind {
    RustLine,
    RustAst,
    RustWorkspace,
    Workspace,
    Toml,
}

impl RuleKind {
    #[must_use]
    pub fn as_str(&self) -> &'static str {
        match self {
            RuleKind::RustLine => "rust-line",
            RuleKind::RustAst => "rust-ast",
            RuleKind::RustWorkspace => "rust-workspace",
            RuleKind::Workspace => "workspace",
            RuleKind::Toml => "toml",
        }
    }
}

impl std::fmt::Display for RuleKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Unified metadata for a registered rule (line or AST).
#[derive(Debug)]
// #t(rust_similar_structs) public registry metadata is distinct from the contextual LLM report projection
pub struct RuleMeta {
    pub name: &'static str,
    pub description: &'static str,
    pub justification: &'static str,
    pub severity: Severity,
    pub kind: RuleKind,
    pub examples: &'static [Example],
    pub params: &'static [RuleParam],
    pub fixable: bool,
}

/// Collect all registered rules sorted by name.
#[must_use]
#[doc(alias = "lint registry", alias = "tidy rules")]
pub fn all_rules() -> Vec<RuleMeta> {
    let mut rules: Vec<RuleMeta> = inventory::iter::<Rule>
        .into_iter()
        .map(|rule| rule.info.to_meta(rule.check.kind(), rule.fix.is_some()))
        .collect();

    rules.sort_by_key(|r| r.name);

    rules
}

/// A code example that demonstrates a rule — used in `--detail` output and tests.
#[derive(Debug)]
pub struct Example {
    pub label: &'static str,
    pub code: &'static str,
    pub pass: bool,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
// #t(rust_non_exhaustive_on_public) internal enum, all variants matched within this crate
pub enum ParamType {
    Int,
    StringArray,
}

#[derive(Clone, Debug)]
// #t(rust_non_exhaustive_on_public) internal enum, all variants matched within this crate
pub enum ParamDefault {
    Int(i64),
    StringArray(&'static [&'static str]),
}

#[derive(Debug)]
pub struct RuleParam {
    pub name: &'static str,
    pub param_type: ParamType,
    pub default: ParamDefault,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
// #t(rust_non_exhaustive_on_public) severity levels are a fixed set
pub enum Severity {
    Low,
    Medium,
    High,
}

impl Severity {
    #[must_use]
    pub fn as_str(&self) -> &'static str {
        match self {
            Severity::Low => "low",
            Severity::Medium => "medium",
            Severity::High => "high",
        }
    }
}

impl std::fmt::Display for Severity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Shared metadata fields common to both line and AST rules.
#[derive(Debug)]
// #t(rust_similar_structs) static registration fields omit the derived rule kind and fixability metadata
pub(crate) struct RuleInfo {
    pub name: &'static str,
    pub description: &'static str,
    pub justification: &'static str,
    pub severity: Severity,
    pub examples: &'static [Example],
    pub params: &'static [RuleParam],
}

impl RuleInfo {
    fn to_meta(&self, kind: RuleKind, fixable: bool) -> RuleMeta {
        RuleMeta {
            name: self.name,
            description: self.description,
            justification: self.justification,
            severity: self.severity,
            kind,
            examples: self.examples,
            params: self.params,
            fixable,
        }
    }
}

/// Language-specific rule check function stored in the unified registry.
#[derive(Clone, Copy, Debug)]
pub(crate) enum RuleCheck {
    RustLine(fn(&FileCtx<'_>) -> Vec<Violation>),
    RustAst(fn(&AstCtx<'_>) -> Vec<Violation>),
    RustWorkspace(fn(&WorkspaceCtx<'_>) -> Vec<Violation>),
    Workspace(fn(&WorkspaceCtx<'_>) -> Vec<Violation>),
    Toml(fn(&TomlCtx<'_>) -> Vec<Violation>),
}

impl RuleCheck {
    pub(crate) const fn kind(self) -> RuleKind {
        match self {
            Self::RustLine(_) => RuleKind::RustLine,
            Self::RustAst(_) => RuleKind::RustAst,
            Self::RustWorkspace(_) => RuleKind::RustWorkspace,
            Self::Workspace(_) => RuleKind::Workspace,
            Self::Toml(_) => RuleKind::Toml,
        }
    }

    pub(crate) const fn extensions(self) -> &'static [&'static str] {
        match self {
            Self::RustLine(_) | Self::RustAst(_) | Self::RustWorkspace(_) => &["rs"],
            Self::Workspace(_) => &["rs", "toml"],
            Self::Toml(_) => &["toml"],
        }
    }
}

/// Language-specific fix function corresponding to [`RuleCheck`].
#[derive(Clone, Copy, Debug)]
pub(crate) enum RuleFix {
    RustLine(fn(&FileCtx<'_>, &Violation) -> Option<Fix>),
    RustAst(fn(&AstCtx<'_>, &Violation) -> Option<Fix>),
    RustAstTree(fn(&AstCtx<'_>, &[Violation]) -> Option<String>),
    Toml(fn(&TomlCtx<'_>, &Violation) -> Option<Fix>),
}

/// One lint rule in the language-neutral registry.
#[derive(Debug)]
pub(crate) struct Rule {
    pub info: RuleInfo,
    pub check: RuleCheck,
    pub fix: Option<RuleFix>,
}

inventory::collect!(Rule);