@atlisp/lint 0.2.16 → 0.2.17

package/dist/formatter.d.ts

@@ -1,3 +1,2 @@
 export declare function formatCode(content: string, indentSize?: number): string;
-export declare function formatCodeStable(content: string, indentSize?: number): string;
 //# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCode = formatCode;
-exports.formatCodeStable = formatCodeStable;
 const utils_1 = require("./utils");
 function isCommentLine(line) {
     const trimmed = line.trim();
@@ -56,9 +55,4 @@ function formatCode(content, indentSize = 2) {
     }
     return output;
 }
-function formatCodeStable(content, indentSize = 2) {
-    const first = formatCode(content, indentSize);
-    const second = formatCode(first, indentSize);
-    return second;
-}
 //# sourceMappingURL=formatter.js.map

package/dist/index.js

@@ -215,7 +215,7 @@ async function main() {
             if (!opts.staged)
                 return;
         }
-        // Filter cached files (pre-read content to avoid double I/O)
+        // Filter cached files (pre-read content to avoid double I/O for linting and display)
         const contentCache = new Map();
         const filesToLint = opts.cache
             ? files.filter(f => {
@@ -234,70 +234,67 @@ async function main() {
                 }
                 return !cached;
             })
-            : files;
+            : files.filter(f => {
+                try {
+                    const content = fs.readFileSync(f, 'utf-8');
+                    contentCache.set(f, content);
+                }
+                catch {
+                    /* ignore */
+                }
+                return true;
+            });
         if (filesToLint.length === 0) {
             console.log((0, locale_1.t)('index.all_cached'));
             return;
         }
         // Phase 1: Static checks (parallel or sequential)
-        const contentArg = opts.cache && contentCache.size > 0 ? contentCache : undefined;
+        const contentArg = contentCache.size > 0 ? contentCache : undefined;
         const issues = opts.parallel
-            ? await (0, runner_1.lintFilesParallel)(filesToLint, config, rootDir)
+            ? await (0, runner_1.lintFilesParallel)(filesToLint, config, rootDir, contentArg)
             : (0, runner_1.lintFiles)(filesToLint, config, rootDir, contentArg);
         // Phase 1b: Project-level cross-file checks
         if (opts.project) {
-            const projectIssues = (0, project_1.lintProject)(filesToLint, config, rootDir);
+            const projectIssues = await (0, project_1.lintProject)(filesToLint, config, rootDir);
             issues.push(...projectIssues);
         }
-        // Apply rule-based fixes (after lint, when --fix is set)
+        // Apply rule-based fixes + format_indent (merged single pass, when --fix is set)
         if (opts.fix) {
+            const indentSize = config.line_length.tab_width;
+            const formatEnabled = config.checks['format_indent'] !== 'off';
             for (const f of filesToLint) {
                 const relPath = path.relative(rootDir, f);
                 const fileIssues = issues.filter(i => i.file === relPath);
-                if (fileIssues.length > 0) {
-                    try {
-                        const content = fs.readFileSync(f, 'utf-8');
-                        const fixed = (0, runner_1.applyFixes)(fileIssues, content, relPath);
-                        if (fixed !== content) {
-                            if (opts.dryRun) {
-                                console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — would apply ${fileIssues.length} fix(es)`);
-                            }
-                            else {
-                                fs.writeFileSync(f, fixed, 'utf-8');
-                                console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
-                            }
-                        }
-                    }
-                    catch (e) {
-                        console.warn(`[lint] applyFixes failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                const hasFormatIssue = formatEnabled && issues.some(i => i.file === relPath && i.rule === 'format_indent');
+                if (fileIssues.length === 0 && !hasFormatIssue)
+                    continue;
+                try {
+                    const content = fs.readFileSync(f, 'utf-8');
+                    let changed = content;
+                    if (fileIssues.length > 0) {
+                        changed = (0, runner_1.applyFixes)(fileIssues, changed, relPath);
                     }
-                }
-            }
-            // format_indent fix: apply formatCode to files with format_indent issues
-            if (config.checks['format_indent'] !== 'off') {
-                const indentSize = config.line_length.tab_width;
-                for (const f of filesToLint) {
-                    const relPath = path.relative(rootDir, f);
-                    const hasFormatIssue = issues.some(i => i.file === relPath && i.rule === 'format_indent');
                     if (hasFormatIssue) {
-                        try {
-                            const content = fs.readFileSync(f, 'utf-8');
-                            const formatted = (0, formatter_1.formatCode)(content, indentSize);
-                            if (formatted !== content) {
-                                if (opts.dryRun) {
-                                    console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — would fix format_indent`);
-                                }
-                                else {
-                                    fs.writeFileSync(f, formatted, 'utf-8');
-                                    console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed', 'format_indent')}`);
-                                }
-                            }
+                        changed = (0, formatter_1.formatCode)(changed, indentSize);
+                    }
+                    if (changed !== content) {
+                        if (opts.dryRun) {
+                            const parts = [];
+                            if (fileIssues.length > 0)
+                                parts.push(`would apply ${fileIssues.length} fix(es)`);
+                            if (hasFormatIssue)
+                                parts.push('would fix format_indent');
+                            console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — ${parts.join('; ')}`);
                         }
-                        catch (e) {
-                            console.warn(`[lint] format_indent fix failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                        else {
+                            fs.writeFileSync(f, changed, 'utf-8');
+                            console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
                         }
                     }
                 }
+                catch (e) {
+                    console.warn(`[lint] fix failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                }
             }
         }
         // Mark as cached
@@ -324,22 +321,33 @@ async function main() {
                 });
             }
         }
-        // Build file content map for code line display
+        // Build file content map for code line display (reuse pre-read content)
         const fileContents = new Map();
         for (const iss of issues) {
             if (!fileContents.has(iss.file)) {
                 const fp = path.resolve(rootDir, iss.file);
-                try {
-                    fileContents.set(iss.file, fs.readFileSync(fp, 'utf-8'));
+                const cached = contentCache.get(fp);
+                if (cached !== undefined) {
+                    fileContents.set(iss.file, cached);
                 }
-                catch (e) {
-                    console.warn(`[lint] failed to read ${fp} for display: ${e instanceof Error ? e.message : String(e)}`);
+                else {
+                    try {
+                        fileContents.set(iss.file, fs.readFileSync(fp, 'utf-8'));
+                    }
+                    catch (e) {
+                        console.warn(`[lint] failed to read ${fp} for display: ${e instanceof Error ? e.message : String(e)}`);
+                    }
                 }
             }
         }
         // Format & output
-        const errorCount = issues.filter(i => i.severity === 'error').length;
-        const warningCount = issues.filter(i => i.severity === 'warn').length;
+        let errorCount = 0, warningCount = 0;
+        for (const i of issues) {
+            if (i.severity === 'error')
+                errorCount++;
+            else if (i.severity === 'warn')
+                warningCount++;
+        }
         if (opts.format === 'json') {
             console.log((0, formatters_1.formatJson)(issues, errorCount, warningCount));
         }

package/dist/project.d.ts

@@ -1,3 +1,3 @@
 import { Issue, LintConfig } from './types';
-export declare function lintProject(files: string[], config: LintConfig, rootDir: string): Issue[];
+export declare function lintProject(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
 //# sourceMappingURL=project.d.ts.map

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))