@slippy-lint/slippy/dist/linter.js

A simple but powerful linter for Solidity

import { filterByCommentDirectives } from "./comment-directives.js";
import { compilationUnitFromContent } from "./slang/compilation-unit.js";
import { SlippyRuleConfigError, SlippyRuleNotRegisteredError, } from "./errors.js";
import { getAllRules } from "./rules/get-all-rules.js";
import * as z from "zod";
export class Linter {
    constructor(configLoader) {
        this.configLoader = configLoader;
        this.ruleNameToRule = new Map();
        this.registerBuiltInRules();
    }
    async lintFiles(files) {
        const results = [];
        for (const file of files) {
            results.push(...(await this.lintText(file.content, file.filePath)));
        }
        return results;
    }
    async lintText(content, filePath) {
        const config = this.configLoader.loadConfig(filePath);
        const results = [];
        const unit = await compilationUnitFromContent({ content, filePath });
        const file = unit.file(filePath);
        if (file.errors().length > 0) {
            results.push({
                sourceId: file.id,
                rule: null,
                line: file.errors()[0].textRange.start.line,
                column: file.errors()[0].textRange.start.column,
                message: "Parsing error",
                severity: "error",
            });
            return results;
        }
        for (const [ruleName, ruleConfig] of Object.entries(config.rules)) {
            const Rule = this.ruleNameToRule.get(ruleName);
            if (Rule === undefined) {
                throw new SlippyRuleNotRegisteredError(ruleName);
            }
            const severity = ruleConfig[0];
            if (severity === "off")
                continue;
            let rule;
            if ("parseConfig" in Rule) {
                try {
                    const config = Rule.parseConfig(ruleConfig[1]);
                    rule = Rule.create(config);
                }
                catch (error) {
                    if (error instanceof z.ZodError) {
                        const problem = z.prettifyError(error);
                        throw new SlippyRuleConfigError(Rule.name, `\n\n${problem}`);
                    }
                    throw error;
                }
            }
            else {
                if (ruleConfig.length > 1) {
                    throw new SlippyRuleConfigError(Rule.name, "Rule requires no configuration, but received an array with more than one element.");
                }
                rule = Rule.create();
            }
            const ruleResults = rule.run({
                unit,
                file,
            });
            const ruleResultsToReport = ruleResults.map((result) => {
                return {
                    ...result,
                    severity,
                };
            });
            results.push(...ruleResultsToReport);
        }
        const filteredResults = filterByCommentDirectives(content, results, file, unit.languageVersion);
        return filteredResults;
    }
    registerBuiltInRules() {
        const rules = getAllRules();
        for (const rule of rules) {
            this.ruleNameToRule.set(rule.name, rule);
        }
    }
}
//# sourceMappingURL=linter.js.map