RuleVisitor.cs

// Copyright (c) 2024, 2026 James Draycott <me@racci.dev>. All Rights Reserved.
// Licensed under the AGPL-3.0-or-later License, See LICENSE in the project root
// for license information.

using System.Diagnostics.CodeAnalysis;
using System.Management.Automation.Language;
using Compiler.Module.Compiled;
using LanguageExt;

namespace Compiler.Analyser.Rules;

public sealed class RuleVisitor(
    IEnumerable<Rule> rules,
    IEnumerable<Compiled> imports) : AstVisitor {

    private readonly IEnumerable<Rule> Rules = rules;
    private readonly IEnumerable<Compiled> Imports = imports;
    private readonly Dictionary<int, Dictionary<Rule, bool>> ThreadLocalCache = [];
    public readonly List<Issue> Issues = [];

    public void VisitModule([NotNull] CompiledLocalModule compiledModule) {
        this.ThreadLocalCache.Add(Environment.CurrentManagedThreadId, []);
        try {
            foreach (var rule in this.Rules) {
                this.ThreadLocalCache[Environment.CurrentManagedThreadId].Add(rule, rule.SupportsModule(compiledModule));
            }

            compiledModule.Document.Ast.Visit(this);
        } finally {
            this.ThreadLocalCache.Remove(Environment.CurrentManagedThreadId);
        }
    }

    public override AstVisitAction DefaultVisit(Ast ast) {
        if (GetSuppressions(ast).IsErr(out var err, out var suppressions)) {
            if (err is Issue issue) {
                this.Issues.Add(issue);
            } else if (err is ManyErrors errors) {
                this.Issues.AddRange(errors.Errors.Cast<Issue>());
            }

            return AstVisitAction.SkipChildren;
        }

        foreach (var rule in this.Rules) {
            // If the key doesn't exist assume we support it, this allows for usage outside of the visitor like in tests.
            if (this.ThreadLocalCache.TryGetValue(Environment.CurrentManagedThreadId, out var threadCache)
                && threadCache.TryGetValue(rule, out var supports)
                && !supports
            ) continue;

            if (!rule.ShouldProcess(ast, suppressions)) continue;
            foreach (var issue in rule.Analyse(ast, this.Imports)) {
                this.Issues.Add(issue);
            }
        }

        return AstVisitAction.Continue;
    }

    public static Fin<IEnumerable<Suppression>> GetSuppressions(Ast ast) {
        var paramBlock = AstHelper.FindClosestParamBlock(ast);
        IEnumerable<AttributeAst> attributes;
        if (paramBlock != null) {
            attributes = paramBlock.Attributes;
        } else {
            // Check script-level attributes if no param block found
            var root = AstHelper.FindRoot(ast);
            if (root is ScriptBlockAst scriptBlock && scriptBlock.ParamBlock == null) {
                attributes = scriptBlock.Attributes;
            } else {
                return Fin.Succ(Enumerable.Empty<Suppression>());
            }
        }
        return SuppressAnalyserAttributeExt.FromAttributes(attributes)
            .Map(suppressions => suppressions.Select(suppression => suppression.GetSuppression()));
    }
}