@atlisp/lint 0.2.16 → 0.2.18

package/dist/project.js

@@ -37,6 +37,7 @@ exports.lintProject = lintProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const parser_1 = require("@atlisp/parser");
+const fsp = __importStar(require("fs/promises"));
 const dangling_defun_1 = require("./checks/dangling-defun");
 const missing_export_1 = require("./checks/missing-export");
 const unused_package_dep_1 = require("./checks/unused-package-dep");
@@ -45,72 +46,52 @@ const builtin_arg_count_1 = require("./checks/builtin-arg-count");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const locale_2 = require("./locale");
-function collectDefunsFromAst(ast) {
-    const results = [];
-    const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
-    for (const node of defunNodes) {
-        if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
-            results.push({ name: node.children[1].name, line: node.pos.line });
+const shared_1 = require("./visitors/shared");
+function collectProjectMetadata(ast) {
+    const defuns = [];
+    const refs = [];
+    const allLists = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n));
+    for (const node of allLists) {
+        if (!(0, parser_1.astIsList)(node) || node.children.length === 0)
+            continue;
+        const car = node.children[0];
+        if (!(0, parser_1.astIsSymbol)(car))
+            continue;
+        const name = car.name;
+        if ((name === 'defun' || name === 'defun-q') && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            defuns.push({ name: node.children[1].name, line: node.pos.line });
         }
-    }
-    return results;
-}
-function collectReferencesFromAst(ast) {
-    const results = [];
-    const allCalls = (0, parser_1.astFindAll)(ast, n => {
-        if (n.type !== 'list' || !n.children || n.children.length === 0)
-            return false;
-        return (0, parser_1.astIsSymbol)(n.children[0]);
-    });
-    for (const call of allCalls) {
-        const name = call.children[0].name;
         if (name !== 'defun' && name !== 'defun-q' && !name.startsWith('c:') && !name.includes(':')) {
-            results.push({ name, line: call.pos.line });
+            refs.push({ name, line: node.pos.line });
         }
     }
-    return results;
+    return { defuns, refs };
 }
 function countFunctionArgsFromAst(ast) {
     const result = new Map();
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
-        if (!node.children || node.children.length < 3)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 3)
             continue;
         const name = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '';
         if (!name)
             continue;
-        const paramList = node.children[2];
-        if (paramList.type !== 'list' || !paramList.children) {
-            result.set(name, 0);
-            continue;
-        }
-        let count = 0;
-        for (const child of paramList.children) {
-            if (child.type === 'symbol' && child.name && child.name !== '/') {
-                count++;
-            }
-            else if (child.type === 'symbol' && child.name === '/') {
-                break;
-            }
-        }
-        result.set(name, count);
+        result.set(name, (0, shared_1.defunParams)(node).length);
     }
     return result;
 }
 function countCallArgsFromAst(ast) {
     const result = new Map();
-    const allCalls = (0, parser_1.astFindAll)(ast, n => {
-        if (n.type !== 'list' || !n.children || n.children.length === 0)
-            return false;
-        return (0, parser_1.astIsSymbol)(n.children[0]);
-    });
+    const allCalls = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n) && n.children.length > 0 && (0, parser_1.astIsSymbol)(n.children[0]));
     for (const call of allCalls) {
+        if (!(0, parser_1.astIsList)(call) || !(0, parser_1.astIsSymbol)(call.children[0]))
+            continue;
         const name = call.children[0].name;
         if (name === 'defun' || name === 'defun-q' || name.startsWith('c:') || name.includes(':'))
             continue;
         if (!result.has(name))
             result.set(name, []);
-        const argCount = call.children ? call.children.length - 1 : 0;
+        const argCount = call.children.length - 1;
         result.get(name).push({ line: call.pos.line, count: argCount });
     }
     return result;
@@ -120,26 +101,25 @@ function findModuleDepsFromAst(ast) {
     const exports = [];
     const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
     for (const node of inPackageNodes) {
-        if (node.children && node.children.length >= 3 && node.children[1].type === 'symbol') {
-            const useList = node.children[2];
-            if (useList.type === 'list' && useList.children) {
-                for (const use of useList.children) {
-                    if (use.type === 'symbol' && use.name)
-                        imports.push(use.name);
-                }
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 3)
+            continue;
+        const useList = node.children[2];
+        if ((0, parser_1.astIsList)(useList) && useList.children) {
+            for (const use of useList.children) {
+                if ((0, parser_1.astIsSymbol)(use) && use.name)
+                    imports.push(use.name);
             }
         }
     }
     const setqNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'setq'));
     for (const node of setqNodes) {
-        if (node.children &&
+        if ((0, parser_1.astIsList)(node) &&
             node.children.length >= 3 &&
-            node.children[1].type === 'symbol' &&
+            (0, parser_1.astIsSymbol)(node.children[1]) &&
             node.children[1].name === '@::*modules*' &&
-            node.children[2].type === 'list' &&
-            node.children[2].children) {
+            (0, parser_1.astIsList)(node.children[2])) {
             for (const exp of node.children[2].children) {
-                if (exp.type === 'string' && typeof exp.value === 'string') {
+                if (typeof exp.value === 'string') {
                     exports.push(exp.value);
                 }
             }
@@ -249,38 +229,52 @@ function checkModuleCycle(moduleDeps, rootDir, allIssues) {
         }
     }
 }
-function lintProject(files, config, rootDir) {
+async function lintProject(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
-    const symbols = { defuns: new Map(), references: new Map() };
+    const symbols = {
+        defuns: new Map(),
+        references: new Map(),
+        fileDefuns: new Map(),
+        fileRefs: new Map(),
+    };
     const maxFiles = config.project_analysis?.maxFiles ?? 500;
     if (files.length > maxFiles) {
         const msg = `${files.length} files exceeds project_analysis.maxFiles (${maxFiles}). Skipping cross-file analysis. To increase, set project_analysis.maxFiles in config.`;
         console.warn(`[atlisp-lint] ${msg}`);
         return [];
     }
-    const fileContents = new Map();
     const defunArgs = new Map();
     const callArgCounts = new Map();
     const moduleDeps = new Map();
-    // Phase A: Streaming collection — one file at a time, keep only metadata
-    for (const filepath of files) {
-        let content;
+    const checks = config.checks;
+    const needsContent = checks['unused_package_dep'] !== 'off';
+    // Phase A: Read all files in parallel, then process metadata sequentially
+    const processedFiles = [];
+    const contentStore = needsContent ? new Map() : undefined;
+    const readResults = await Promise.all(files.map(async (filepath) => {
         try {
-            content = fs.readFileSync(filepath, 'utf-8');
+            const content = await fsp.readFile(filepath, 'utf-8');
+            return { filepath, content, ok: true };
         }
         catch {
-            continue;
+            return { filepath, ok: false };
         }
+    }));
+    for (const result of readResults) {
+        if (!result.ok)
+            continue;
+        const { filepath, content } = result;
         const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
         // Extract all metadata from a single AST parse
-        const defunList = collectDefunsFromAst(ast);
+        const { defuns: defunList, refs: refList } = collectProjectMetadata(ast);
+        symbols.fileDefuns.set(filepath, defunList);
         for (const d of defunList) {
             const list = symbols.defuns.get(d.name) || [];
             list.push({ file: filepath, line: d.line });
             symbols.defuns.set(d.name, list);
         }
-        const refList = collectReferencesFromAst(ast);
+        symbols.fileRefs.set(filepath, refList);
         for (const r of refList) {
             const list = symbols.references.get(r.name) || [];
             list.push({ file: filepath, line: r.line });
@@ -289,31 +283,24 @@ function lintProject(files, config, rootDir) {
         defunArgs.set(filepath, countFunctionArgsFromAst(ast));
         callArgCounts.set(filepath, countCallArgsFromAst(ast));
         moduleDeps.set(filepath, findModuleDepsFromAst(ast));
-        // Cache file content for checks that still need it
-        fileContents.set(filepath, content);
-        // AST goes out of scope here → GC reclaims it
+        processedFiles.push(filepath);
+        if (contentStore)
+            contentStore.set(filepath, content);
     }
     // Phase B: Cross-file checks using only symbol tables
-    for (const [filepath] of fileContents) {
+    for (const filepath of processedFiles) {
         const relPath = path.relative(rootDir, filepath);
         const override = (0, config_1.findOverrides)(filepath);
-        const checks = override?.checks || config.checks;
-        if (checks['dangling_defun'] !== 'off') {
-            const defunList = [];
-            for (const [name, locations] of symbols.defuns) {
-                for (const loc of locations) {
-                    if (loc.file === filepath) {
-                        defunList.push({ name, line: loc.line });
-                    }
-                }
-            }
+        const fileChecks = override?.checks || checks;
+        if (fileChecks['dangling_defun'] !== 'off') {
+            const defunList = symbols.fileDefuns.get(filepath) || [];
             const danglingIssues = (0, dangling_defun_1.checkDanglingDefunFromDefs)(defunList, symbols.references, filepath);
             for (const iss of danglingIssues) {
                 iss.file = relPath;
                 allIssues.push(iss);
             }
         }
-        if (checks['missing_export'] !== 'off') {
+        if (fileChecks['missing_export'] !== 'off') {
             const pkgDir = findPackageDir(filepath);
             if (pkgDir) {
                 const missingIssues = (0, missing_export_1.checkMissingExport)(filepath, pkgDir, symbols.defuns);
@@ -323,8 +310,8 @@ function lintProject(files, config, rootDir) {
                 }
             }
         }
-        if (checks['unused_package_dep'] !== 'off') {
-            const content = fileContents.get(filepath);
+        if (fileChecks['unused_package_dep'] !== 'off') {
+            const content = contentStore?.get(filepath);
             if (content) {
                 const depIssues = (0, unused_package_dep_1.checkUnusedPackageDepFromContent)(filepath, content);
                 for (const iss of depIssues) {
@@ -333,65 +320,64 @@ function lintProject(files, config, rootDir) {
                 }
             }
         }
-        if (checks['duplicate_defun'] !== 'off') {
+        if (fileChecks['duplicate_defun'] !== 'off') {
             const dupIssues = (0, duplicate_defun_1.checkDuplicateDefun)(filepath, symbols.defuns);
             for (const iss of dupIssues) {
                 iss.file = relPath;
                 allIssues.push(iss);
             }
         }
-        if (checks['arg_count_project'] !== 'off') {
+        if (fileChecks['arg_count_project'] !== 'off') {
             const argIssues = checkArgCountProject(filepath, defunArgs, callArgCounts, symbols, relPath);
             allIssues.push(...argIssues);
         }
-        if (checks['function_reference'] !== 'off') {
-            const definedHere = new Set();
-            for (const [name, locations] of symbols.defuns) {
-                for (const loc of locations) {
-                    if (loc.file === filepath)
-                        definedHere.add(name);
-                }
-            }
-            for (const [name, refs] of symbols.references) {
-                if (builtin_arg_count_1.BUILTIN_FUNCTIONS.has(name))
+        if (fileChecks['function_reference'] !== 'off') {
+            const definedHere = new Set((symbols.fileDefuns.get(filepath) || []).map(d => d.name));
+            const fileRefs = symbols.fileRefs.get(filepath) || [];
+            for (const ref of fileRefs) {
+                if (builtin_arg_count_1.BUILTIN_FUNCTIONS.has(ref.name))
                     continue;
-                if (definedHere.has(name))
+                if (definedHere.has(ref.name))
                     continue;
-                if (symbols.defuns.has(name))
+                if (symbols.defuns.has(ref.name))
                     continue;
-                for (const ref of refs) {
-                    if (ref.file === filepath) {
-                        allIssues.push({
-                            file: relPath,
-                            line: ref.line,
-                            severity: 'warn',
-                            rule: 'function_reference',
-                            message: (0, locale_2.t)('function_reference', name),
-                        });
-                    }
-                }
+                allIssues.push({
+                    file: relPath,
+                    line: ref.line,
+                    severity: 'warn',
+                    rule: 'function_reference',
+                    message: (0, locale_2.t)('function_reference', ref.name),
+                });
             }
         }
     }
     // Module cycle check: run DFS once (not per file)
-    const cycleCheckFile = fileContents.keys().next().value;
-    if (cycleCheckFile) {
+    if (processedFiles.length > 0) {
+        const cycleCheckFile = processedFiles[0];
         const override = (0, config_1.findOverrides)(cycleCheckFile);
-        const checks = override?.checks || config.checks;
-        if (checks['module_cycle'] !== 'off') {
+        const fileChecks = override?.checks || checks;
+        if (fileChecks['module_cycle'] !== 'off') {
             checkModuleCycle(moduleDeps, rootDir, allIssues);
         }
     }
     return allIssues;
 }
+const packageDirCache = new Map();
 function findPackageDir(filepath) {
+    const cached = packageDirCache.get(filepath);
+    if (cached !== undefined)
+        return cached;
     let dir = path.dirname(filepath);
     for (;;) {
-        if (fs.existsSync(path.join(dir, 'pkg.lsp')))
+        if (fs.existsSync(path.join(dir, 'pkg.lsp'))) {
+            packageDirCache.set(filepath, dir);
             return dir;
+        }
         const parent = path.dirname(dir);
-        if (parent === dir)
+        if (parent === dir) {
+            packageDirCache.set(filepath, null);
             return null;
+        }
         dir = parent;
     }
 }

package/dist/runner.d.ts

@@ -1,7 +1,7 @@
 import { Issue, LintConfig } from './types';
 export declare function runChecks(content: string, file: string, config: LintConfig): Issue[];
 export declare function lintFiles(files: string[], config: LintConfig, rootDir: string, contentCache?: Map<string, string>): Issue[];
-export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
+export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string, contentCache?: Map<string, string>): Promise<Issue[]>;
 export { applyFixesFromProviders as applyFixes, FIXABLE_RULES } from './fixes/index';
 export declare function parseIgnoreFile(rootDir: string): string[];
 export declare function fixFile(filepath: string): string[];

package/dist/runner.js

@@ -138,15 +138,21 @@ function runChecks(content, file, config) {
     addIfEnabled('error_handling', () => (0, error_handling_1.checkErrorHandling)(content, file));
     addIfEnabled('global_naming', () => (0, global_naming_1.checkGlobalNaming)(content, file));
     addIfEnabled('extra_parens', () => (0, extra_parens_1.checkExtraParens)(content, file));
-    addIfEnabled('arg_count', () => (0, arg_count_1.checkArgCount)(content, file));
-    addIfEnabled('builtin_arg_count', () => (0, builtin_arg_count_1.checkBuiltinArgCount)(content, file));
+    // Early AST parse for checks that need AST but aren't visitor-based
+    let ast;
+    const needsEarlyAst = ['arg_count', 'builtin_arg_count', 'empty_catch', 'no_return', 'undeclared_setq'].some(r => checks[r] !== 'off');
+    if (needsEarlyAst) {
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    }
+    addIfEnabled('arg_count', () => (0, arg_count_1.checkArgCount)(content, file, ast));
+    addIfEnabled('builtin_arg_count', () => (0, builtin_arg_count_1.checkBuiltinArgCount)(content, file, ast));
     addIfEnabled('strcat_usage', () => (0, strcat_usage_1.checkStrcatUsage)(content, file));
     addIfEnabled('cond_simplify', () => (0, cond_simplify_1.checkCondSimplify)(content, file));
     addIfEnabled('quote_style', () => (0, quote_style_1.checkQuoteStyle)(content, file));
     addIfEnabled('eq_usage', () => (0, eq_usage_1.checkEqUsage)(content, file));
     addIfEnabled('lambda_syntax', () => (0, lambda_syntax_1.checkLambdaSyntax)(content, file));
     addIfEnabled('comment_style', () => (0, comment_style_1.checkCommentStyle)(content, file));
-    addIfEnabled('empty_catch', () => (0, empty_catch_1.checkEmptyCatch)(content, file));
+    addIfEnabled('empty_catch', () => (0, empty_catch_1.checkEmptyCatch)(content, file, ast));
     addIfEnabled('nth_usage', () => (0, nth_usage_1.checkNthUsage)(content, file));
     addIfEnabled('append_single', () => (0, append_single_1.checkAppendSingle)(content, file));
     addIfEnabled('setq_multiple', () => (0, setq_multiple_1.checkSetqMultiple)(content, file));
@@ -154,12 +160,12 @@ function runChecks(content, file, config) {
     addIfEnabled('magic_number', () => (0, magic_number_1.checkMagicNumber)(content, file));
     addIfEnabled('mixed_indent', () => (0, mixed_indent_1.checkMixedIndent)(content, file));
     addIfEnabled('long_function_call', () => (0, long_function_call_1.checkLongFunctionCall)(content, file, 6));
-    addIfEnabled('no_return', () => (0, no_return_1.checkNoReturn)(content, file));
+    addIfEnabled('no_return', () => (0, no_return_1.checkNoReturn)(content, file, ast));
     addIfEnabled('shadow_builtin', () => (0, shadow_builtin_1.checkShadowBuiltin)(content, file));
     addIfEnabled('dynamic_doc', () => (0, dynamic_doc_1.checkDynamicDoc)(content, file));
     addIfEnabled('loop_optimization', () => (0, loop_optimization_1.checkLoopOptimization)(content, file));
     addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
-    addIfEnabled('undeclared_setq', () => (0, undeclared_setq_1.checkUndeclaredSetq)(content, file));
+    addIfEnabled('undeclared_setq', () => (0, undeclared_setq_1.checkUndeclaredSetq)(content, file, ast));
     addIfEnabled('format_indent', () => (0, format_indent_1.checkFormatIndent)(content, file, config.line_length.tab_width));
     // New checks
     addIfEnabled('unused_catch_result', () => (0, unused_catch_result_1.checkUnusedCatchResult)(content, file));
@@ -212,7 +218,9 @@ function runChecks(content, file, config) {
     const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
     if (needsAst) {
         try {
-            const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+            if (!ast) {
+                ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+            }
             const visitorIssues = (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
             addIssues(visitorIssues);
         }
@@ -261,7 +269,7 @@ function lintFiles(files, config, rootDir, contentCache) {
     }
     return allIssues;
 }
-function lintFilesParallel(files, config, rootDir) {
+function lintFilesParallel(files, config, rootDir, contentCache) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     return new Promise(resolve => {
         const allIssues = [];
@@ -274,8 +282,9 @@ function lintFilesParallel(files, config, rootDir) {
             const idx = nextIndex++;
             const filepath = files[idx];
             const relPath = path.relative(rootDir, filepath);
+            const content = contentCache?.get(filepath);
             const worker = new worker_threads_1.Worker(path.join(__dirname, 'worker.js'), {
-                workerData: { filepath, relPath, config },
+                workerData: { filepath, relPath, config, content },
             });
             worker.on('message', (msg) => {
                 if (completed.has(idx))

package/dist/utils.js

@@ -6,8 +6,7 @@ exports.codeLines = codeLines;
 exports.findMatchingParen = findMatchingParen;
 exports.extractForm = extractForm;
 exports.extractStrings = extractStrings;
-/** Strip string contents and comments from a line of AutoLISP code */
-function stripLine(line) {
+function stripLineInternal(line, keepQuotes) {
     const out = [];
     let inStr = false;
     let i = 0;
@@ -17,46 +16,38 @@ function stripLine(line) {
             break;
         if (ch === '"') {
             inStr = !inStr;
+            if (keepQuotes)
+                out.push(ch);
             i++;
             continue;
         }
         if (ch === '\\' && inStr) {
-            i += 2;
+            if (keepQuotes) {
+                out.push(ch);
+                if (i + 1 < line.length) {
+                    out.push(line[i + 1]);
+                    i++;
+                }
+            }
+            else {
+                if (i + 1 < line.length)
+                    i++;
+            }
+            i++;
             continue;
         }
-        if (!inStr)
+        if (keepQuotes || !inStr)
             out.push(ch);
         i++;
     }
     return out.join('');
 }
+/** Strip string contents and comments from a line of AutoLISP code */
+function stripLine(line) {
+    return stripLineInternal(line, false);
+}
 function stripLineRaw(line) {
-    const out = [];
-    let inStr = false;
-    let i = 0;
-    while (i < line.length) {
-        const ch = line[i];
-        if (ch === ';' && !inStr)
-            break;
-        if (ch === '"') {
-            inStr = !inStr;
-            out.push(ch);
-            i++;
-            continue;
-        }
-        if (ch === '\\' && inStr) {
-            out.push(ch);
-            if (i + 1 < line.length) {
-                out.push(line[i + 1]);
-                i++;
-            }
-            i++;
-            continue;
-        }
-        out.push(ch);
-        i++;
-    }
-    return out.join('');
+    return stripLineInternal(line, true);
 }
 /** Iterate lines with string-aware content */
 function* codeLines(content) {

package/dist/validate.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateConfig = validateConfig;
-const VALID_RULES = [
+const VALID_RULES = new Set([
     'append_single',
     'arg_count',
     'assoc_without_cdr',
@@ -101,7 +101,7 @@ const VALID_RULES = [
     'redundant_car_cdr',
     'equal_nil',
     'redundant_and_or',
-];
+]);
 const VALID_SEVERITIES = ['off', 'info', 'warn', 'error'];
 function validateConfig(config) {
     const errors = [];
@@ -110,7 +110,7 @@ function validateConfig(config) {
     }
     if (config.checks) {
         for (const [rule, sev] of Object.entries(config.checks)) {
-            if (!VALID_RULES.includes(rule)) {
+            if (!VALID_RULES.has(rule)) {
                 errors.push({ path: `checks.${rule}`, message: `Unknown rule '${rule}'` });
             }
             if (!VALID_SEVERITIES.includes(sev)) {

package/dist/visitor-runner.d.ts

@@ -1,32 +1,4 @@
 import { Issue, LintConfig } from './types';
 import { AstNode } from '@atlisp/parser';
-export interface CollectState {
-    openCount: number;
-    closeCount: number;
-    setqDefs: Map<string, {
-        line: number;
-        file: string;
-    }>;
-    symbolRefs: Map<string, number>;
-    condKeys: Map<number, Set<string>>;
-    defunScopes: Array<{
-        name: string;
-        params: string[];
-        body: AstNode[];
-        line: number;
-        file: string;
-    }>;
-    letScopes: Array<{
-        bindings: string[];
-        body: AstNode[];
-        line: number;
-    }>;
-    dangerousCalls: Array<{
-        name: string;
-        node: AstNode;
-    }>;
-    ssgetCount: number;
-    sssetCount: number;
-}
 export declare function runChecksWithVisitor(ast: AstNode, file: string, config: LintConfig, disableMap: Map<string, Set<number>>): Issue[];
 //# sourceMappingURL=visitor-runner.d.ts.map