@atlisp/lint 0.2.12 → 0.2.14

package/dist/cli/parser.d.ts

@@ -0,0 +1,30 @@
+export interface CliOptions {
+    src: string[];
+    test: string[];
+    config?: string;
+    staged: boolean;
+    diff: boolean;
+    changed: string;
+    format: 'default' | 'json' | 'sarif' | 'html';
+    init: boolean;
+    installHook: boolean;
+    fix: boolean;
+    hookArgs: string;
+    cache: boolean;
+    clearCache: boolean;
+    parallel: boolean;
+    project: boolean;
+    watch: boolean;
+    help: boolean;
+    version: boolean;
+    formatCode: boolean;
+    formatCheck: boolean;
+    sbcl: boolean;
+    docs: boolean;
+    listRules: boolean;
+    explain: string;
+    dryRun: boolean;
+    maxWarnings: number;
+}
+export declare function parseArgs(): CliOptions;
+//# sourceMappingURL=parser.d.ts.map

package/dist/cli/parser.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+function parseArgs() {
+    const argv = process.argv.slice(2);
+    const opts = {
+        src: [],
+        test: [],
+        staged: false,
+        diff: false,
+        changed: '',
+        format: 'default',
+        init: false,
+        installHook: false,
+        fix: false,
+        hookArgs: '',
+        cache: false,
+        clearCache: false,
+        parallel: false,
+        project: false,
+        watch: false,
+        help: false,
+        version: false,
+        formatCode: false,
+        formatCheck: false,
+        sbcl: false,
+        docs: false,
+        listRules: false,
+        explain: '',
+        dryRun: false,
+        maxWarnings: -1,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        switch (argv[i]) {
+            case '--src':
+                opts.src.push(argv[++i]);
+                break;
+            case '--test':
+                opts.test.push(argv[++i]);
+                break;
+            case '--config':
+                opts.config = argv[++i];
+                break;
+            case '--staged':
+                opts.staged = true;
+                break;
+            case '--diff':
+                opts.diff = true;
+                break;
+            case '--changed':
+                opts.changed = argv[++i] || 'main';
+                break;
+            case '--format':
+                opts.format = argv[++i];
+                break;
+            case '--init':
+                opts.init = true;
+                break;
+            case '--install-hook':
+                opts.installHook = true;
+                break;
+            case '--fix':
+                opts.fix = true;
+                break;
+            case '--hook-args':
+                opts.hookArgs = argv[++i];
+                break;
+            case '--cache':
+                opts.cache = true;
+                break;
+            case '--clear-cache':
+                opts.clearCache = true;
+                break;
+            case '--parallel':
+                opts.parallel = true;
+                break;
+            case '--project':
+                opts.project = true;
+                break;
+            case '--watch':
+                opts.watch = true;
+                break;
+            case '--help':
+                opts.help = true;
+                break;
+            case '--version':
+                opts.version = true;
+                break;
+            case '--format-code':
+                opts.formatCode = true;
+                break;
+            case '--format-check':
+                opts.formatCheck = true;
+                break;
+            case '--sbcl':
+                opts.sbcl = true;
+                break;
+            case '--docs':
+                opts.docs = true;
+                break;
+            case '--list-rules':
+                opts.listRules = true;
+                break;
+            case '--explain':
+                opts.explain = argv[++i];
+                break;
+            case '--dry-run':
+                opts.dryRun = true;
+                break;
+            case '--max-warnings':
+                opts.maxWarnings = parseInt(argv[++i], 10);
+                break;
+            default:
+                break;
+        }
+    }
+    return opts;
+}
+//# sourceMappingURL=parser.js.map

package/dist/config.js

@@ -65,6 +65,18 @@ const DEFAULT_CONFIG = {
         missing_doc: 'info',
         trailing_whitespace: 'info',
         undeclared_setq: 'warn',
+        command_s: 'warn',
+        zerop_usage: 'info',
+        progn_in_body: 'info',
+        if_progn_both: 'info',
+        redundant_cond: 'info',
+        selection_set_leak: 'warn',
+        empty_branch_cond: 'warn',
+        function_reference: 'warn',
+        progn_in_cond: 'info',
+        redundant_car_cdr: 'info',
+        equal_nil: 'info',
+        redundant_and_or: 'info',
         module_registration: 'off',
         namespace_header: 'off',
         unused_parameter: 'warn',
@@ -152,6 +164,7 @@ const DEFAULT_CONFIG = {
         command_shell: 'warn',
         startapp: 'warn',
         vl_registry_write: 'warn',
+        eval: 'warn',
     },
     module_registration: {
         severity: 'off',
@@ -219,13 +232,22 @@ function getCheckSeverity(config, rule) {
     return config.checks[rule] || 'off';
 }
 function findOverrides(filepath) {
-    const dir = path.dirname(filepath);
-    const configPath = path.join(dir, '.atlisp-lint.json');
-    if (fs.existsSync(configPath)) {
-        const raw = fs.readFileSync(configPath, 'utf-8');
-        return JSON.parse(raw);
+    let dir = path.dirname(filepath);
+    for (;;) {
+        const configPath = path.join(dir, '.atlisp-lint.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
     }
-    return null;
 }
 function mergeOverrides(base, overrides) {
     const merged = JSON.parse(JSON.stringify(base));

package/dist/disable.js

@@ -7,6 +7,18 @@ function parseDisableComments(content, fileLine) {
     const lines = content.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
+        const disableFileM = line.match(/;\s*atlisp-lint:\s*disable-file=(.+)/i);
+        if (disableFileM) {
+            const rules = disableFileM[1]
+                .split(',')
+                .map(r => r.trim())
+                .filter(Boolean);
+            for (const rule of rules) {
+                if (!map.has(rule))
+                    map.set(rule, new Set());
+                map.get(rule).add(0);
+            }
+        }
         const m = line.match(/;\s*atlisp-lint:\s*disable=(.+)/i);
         if (!m)
             continue;

package/dist/fixes/index.d.ts

@@ -0,0 +1,8 @@
+import { Issue } from '../types';
+export type FixResult = string | null;
+export interface FixProvider {
+    (line: string): string;
+}
+export declare const FIXABLE_RULES: Set<string>;
+export declare function applyFixesFromProviders(issues: Issue[], content: string, filepath: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/fixes/index.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIXABLE_RULES = void 0;
+exports.applyFixesFromProviders = applyFixesFromProviders;
+const utils_1 = require("../utils");
+const nth_usage_1 = require("../checks/nth-usage");
+const FIX_PROVIDERS = {
+    redundant_quotes(line) {
+        return line.replace(/''(\S)/g, "'$1");
+    },
+    double_not(line) {
+        return line.replace(/\(not\s+\(not\s+/g, '(not ');
+    },
+    redundant_nil_else(line) {
+        return line.replace(/\s+nil\s*\)$/, ')');
+    },
+    single_arg_and_or(line) {
+        const m = line.match(/\((and|or)\s+([^)\s]+)\s*\)/);
+        return m ? m[2] : line;
+    },
+    redundant_progn(line) {
+        const proIdx = line.indexOf('(progn ');
+        if (proIdx === -1)
+            return line;
+        const beforePro = line.slice(0, proIdx);
+        const close = (0, utils_1.findMatchingParen)(line, proIdx);
+        if (close <= proIdx)
+            return line;
+        const inner = line.slice(proIdx + 7, close);
+        const rest = line.slice(close + 1);
+        return beforePro + inner + rest;
+    },
+    redundant_let(line) {
+        return line.replace(/\(let\s+\(\)\s*/, '(progn ');
+    },
+    quote_style(line) {
+        const qIdx = line.indexOf('(quote ');
+        if (qIdx === -1)
+            return line;
+        const beforeQ = line.slice(0, qIdx);
+        const close = (0, utils_1.findMatchingParen)(line, qIdx);
+        if (close <= qIdx)
+            return line;
+        const quoted = line.slice(qIdx + 7, close);
+        const rest = line.slice(close + 1);
+        return beforeQ + "'" + quoted + rest;
+    },
+    redundant_if(line) {
+        const pIdx = line.indexOf('(progn ');
+        if (pIdx === -1)
+            return line;
+        const beforeP = line.slice(0, pIdx);
+        const close = (0, utils_1.findMatchingParen)(line, pIdx);
+        if (close <= pIdx)
+            return line;
+        const inner = line.slice(pIdx + 7, close);
+        const rest = line.slice(close + 1);
+        return beforeP + inner + rest;
+    },
+    misplaced_else(line) {
+        const ifStart = line.indexOf('(if (not ');
+        if (ifStart === -1)
+            return line;
+        const notIdx = line.indexOf('(not ', ifStart);
+        if (notIdx === -1)
+            return line;
+        const notClose = (0, utils_1.findMatchingParen)(line, notIdx);
+        if (notClose <= notIdx)
+            return line;
+        const ifClose = (0, utils_1.findMatchingParen)(line, ifStart);
+        if (ifClose <= ifStart)
+            return line;
+        const indent = line.slice(0, ifStart);
+        const condVar = line.slice(notIdx + 5, notClose);
+        const branchContent = line.slice(notClose + 1, ifClose).trim();
+        const [thenForm, thenEnd] = (0, utils_1.extractForm)(branchContent, 0);
+        const elseForm = branchContent.slice(thenEnd).trim();
+        if (!thenForm || !elseForm)
+            return line;
+        const rest = line.slice(ifClose + 1);
+        return indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
+    },
+    setq_multiple(line) {
+        const fixed = line.replace(/\)\(setq\s+/g, ' ');
+        if (fixed === line)
+            return line;
+        const merged = line.replace(/^\(\s*setq\s+/, '(setq ');
+        if (merged.includes('setq') && !merged.match(/\)\(/))
+            return merged;
+        return line.replace(/\)\(setq\s+/g, '\n');
+    },
+    append_single(line) {
+        const aIdx = line.indexOf('(append ');
+        if (aIdx === -1)
+            return line;
+        const close = (0, utils_1.findMatchingParen)(line, aIdx);
+        if (close <= aIdx)
+            return line;
+        const inner = line.slice(aIdx + 8, close);
+        const listMatch = inner.match(/^\(list\s+(.*)\)\s*$/);
+        if (!listMatch)
+            return line;
+        return line.slice(0, aIdx) + '(cons ' + listMatch[1] + ')' + line.slice(close + 1);
+    },
+    nth_usage(line) {
+        return (0, nth_usage_1.replaceNthUsage)(line) || line;
+    },
+    setq_single_arg(line) {
+        return line;
+    },
+    extra_parens(line) {
+        return line.replace(/\){2,}/g, ')');
+    },
+    empty_branch(line) {
+        return line.replace(/\(if\s+\S+\s*\)/g, m => m.slice(0, -1) + ' nil)');
+    },
+    comment_style(line) {
+        return line.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
+    },
+    eq_usage(line) {
+        return line.replace(/\(eq\s+(\S+)\s+(\d+)\s*\)/g, '(= $1 $2)');
+    },
+    cond_simplify(line) {
+        const condIdx = line.indexOf('(cond ');
+        if (condIdx === -1)
+            return line;
+        const condEnd = (0, utils_1.findMatchingParen)(line, condIdx);
+        if (condEnd <= condIdx)
+            return line;
+        const inner = line.slice(condIdx + 6, condEnd).trim();
+        const branchOpen = inner.indexOf('(');
+        if (branchOpen === -1)
+            return line;
+        const branchEnd = (0, utils_1.findMatchingParen)(inner, branchOpen);
+        if (branchEnd <= branchOpen)
+            return line;
+        const indent = line.slice(0, condIdx);
+        const branchContent = inner.slice(branchOpen + 1, branchEnd).trim();
+        const space = branchContent.search(/\s+/);
+        if (space === -1)
+            return line;
+        const testExpr = branchContent.slice(0, space);
+        const bodyExpr = branchContent.slice(space).trim();
+        const rest = line.slice(condEnd + 1);
+        return indent + '(if ' + testExpr + ' ' + bodyExpr + ')' + rest;
+    },
+    self_compare(line) {
+        return line.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
+    },
+    while_constant(line) {
+        const trimmed = line.trim();
+        const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
+        if (!nilMatch)
+            return line;
+        return line.replace(trimmed, 'nil');
+    },
+    redundant_list(line) {
+        return line.replace(/\(\s*list\s*\)/g, 'nil');
+    },
+    zerop_usage(line) {
+        return line.replace(/\(=\s+(\S+)\s+0\s*\)/g, '(zerop $1)').replace(/\(=\s+0\s+(\S+)\s*\)/g, '(zerop $1)');
+    },
+    redundant_cond(line) {
+        const m = line.match(/^(\s*)\(cond\s+\(\(([^)]+)\)\s+\(([^)]*)\)\s*\)\s*\)$/);
+        if (!m)
+            return line;
+        return `${m[1]}(if (${m[2]}) (${m[3]}))`;
+    },
+};
+exports.FIXABLE_RULES = new Set(Object.keys(FIX_PROVIDERS));
+function applyFixesFromProviders(issues, content, filepath) {
+    const lines = content.split('\n');
+    const fixedLines = new Set();
+    const fixesByRule = new Map();
+    for (const iss of issues) {
+        if (iss.file !== filepath)
+            continue;
+        const set = fixesByRule.get(iss.rule) || new Set();
+        set.add(iss.line);
+        fixesByRule.set(iss.rule, set);
+    }
+    for (const [rule, lineSet] of fixesByRule) {
+        const provider = FIX_PROVIDERS[rule];
+        if (!provider)
+            continue;
+        const sortedLines = Array.from(lineSet).sort((a, b) => b - a);
+        for (const line of sortedLines) {
+            const idx = line - 1;
+            if (idx < 0 || idx >= lines.length)
+                continue;
+            const fixed = provider(lines[idx]);
+            if (fixed !== lines[idx]) {
+                lines[idx] = fixed;
+                fixedLines.add(idx);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=index.js.map