@atlisp/lint 0.1.22 → 0.1.24

package/dist/runner.js

@@ -33,8 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIXABLE_RULES = void 0;
 exports.runChecks = runChecks;
-exports.runChecksWithVisitorWrapper = runChecksWithVisitorWrapper;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
 exports.applyFixes = applyFixes;
@@ -99,12 +99,17 @@ function runChecks(content, file, config) {
         const severity = checks[rule];
         if (!severity || severity === 'off')
             return;
-        const results = fn();
-        for (const r of results) {
-            if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
-                issues.push(r);
+        try {
+            const results = fn();
+            for (const r of results) {
+                if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
+                    issues.push(r);
+                }
             }
         }
+        catch {
+            // Check failed, continue with remaining checks
+        }
     }
     function addIssues(ruleIssues) {
         for (const r of ruleIssues) {
@@ -172,17 +177,17 @@ function runChecks(content, file, config) {
     ]);
     const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
     if (needsAst) {
-        const ast = (0, parser_1.parseAst)(content);
-        const visitorIssues = (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
-        addIssues(visitorIssues);
+        try {
+            const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+            const visitorIssues = (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
+            addIssues(visitorIssues);
+        }
+        catch {
+            // AST-based checks are skipped, text-based checks above still report issues
+        }
     }
     return issues;
 }
-function runChecksWithVisitorWrapper(content, file, config) {
-    const disableMap = (0, disable_1.parseDisableComments)(content);
-    const ast = (0, parser_1.parseAst)(content);
-    return (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
-}
 function lintFiles(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
@@ -308,8 +313,19 @@ function extractForm(s, start) {
     const end = findMatchingParen(s, i);
     return [s.slice(i, end + 1), end + 1];
 }
+// ===== FIX APPLICATION =====
+exports.FIXABLE_RULES = new Set([
+    'redundant_quotes', 'double_not', 'redundant_nil_else',
+    'single_arg_and_or', 'redundant_setq', 'redundant_progn',
+    'redundant_let', 'quote_style', 'redundant_if', 'misplaced_else',
+    'setq_multiple', 'append_single', 'nth_usage', 'setq_single_arg',
+    'extra_parens', 'empty_branch',
+    'comment_style', 'eq_usage', 'cond_simplify', 'self_compare',
+    'while_constant', 'redundant_list',
+]);
 function applyFixes(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)
@@ -318,14 +334,7 @@ function applyFixes(issues, content, filepath) {
         set.add(iss.line);
         fixesByRule.set(iss.rule, set);
     }
-    const fixableRules = new Set([
-        'redundant_quotes', 'double_not', 'redundant_nil_else',
-        'single_arg_and_or', 'redundant_setq', 'redundant_progn',
-        'redundant_let', 'quote_style', 'redundant_if', 'misplaced_else',
-        'setq_multiple', 'append_single', 'nth_usage', 'setq_single_arg',
-        'extra_parens', 'empty_branch',
-    ]);
-    let result = content;
+    const fixableRules = exports.FIXABLE_RULES;
     for (const [rule, lineSet] of fixesByRule) {
         if (!fixableRules.has(rule))
             continue;
@@ -334,30 +343,38 @@ function applyFixes(issues, content, filepath) {
             const idx = line - 1;
             if (idx < 0 || idx >= lines.length)
                 continue;
-            const lineContent = result.split('\n')[idx];
+            const lineContent = lines[idx];
             switch (rule) {
                 case 'redundant_quotes': {
                     const fixed = lineContent.replace(/''(\S)/g, "'$1");
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'double_not': {
                     const fixed = lineContent.replace(/\(not\s+\(not\s+/g, '(not ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'redundant_nil_else': {
                     const fixed = lineContent.replace(/\s+nil\s*\)$/, ')');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'single_arg_and_or': {
                     const m = lineContent.match(/\((and|or)\s+([^)\s]+)\s*\)/);
-                    if (m)
-                        result = replaceLine(result, idx, m[2]);
+                    if (m) {
+                        lines[idx] = m[2];
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'redundant_progn': {
@@ -369,16 +386,20 @@ function applyFixes(issues, content, filepath) {
                             const inner = lineContent.slice(proIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforePro + inner + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
                 }
                 case 'redundant_let': {
                     const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'quote_style': {
@@ -390,8 +411,10 @@ function applyFixes(issues, content, filepath) {
                             const quoted = lineContent.slice(qIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforeQ + "'" + quoted + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -405,8 +428,10 @@ function applyFixes(issues, content, filepath) {
                             const inner = lineContent.slice(pIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforeP + inner + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -431,18 +456,18 @@ function applyFixes(issues, content, filepath) {
                         if (thenForm && elseForm) {
                             const rest = lineContent.slice(ifClose + 1);
                             const fixed = indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
                 }
                 case 'redundant_setq': {
-                    const allLines = result.split('\n');
-                    const trimmed = allLines[idx].trim();
+                    const trimmed = lines[idx].trim();
                     if (/^\(setq\s+(\S+)\s+\1\s*\)$/.test(trimmed)) {
-                        allLines.splice(idx, 1);
-                        result = allLines.join('\n');
+                        lines.splice(idx, 1);
                     }
                     break;
                 }
@@ -451,12 +476,15 @@ function applyFixes(issues, content, filepath) {
                     if (fixed !== lineContent) {
                         const merged = lineContent.replace(/^\(\s*setq\s+/, '(setq ');
                         if (merged.includes('setq') && !merged.match(/\)\(/)) {
-                            result = replaceLine(result, idx, merged);
+                            lines[idx] = merged;
+                            fixedLines.add(idx);
                         }
                         else {
                             const simplified = lineContent.replace(/\)\(setq\s+/g, '\n');
-                            if (simplified !== lineContent)
-                                result = replaceLine(result, idx, simplified);
+                            if (simplified !== lineContent) {
+                                lines[idx] = simplified;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -470,8 +498,10 @@ function applyFixes(issues, content, filepath) {
                             const listMatch = inner.match(/^\(list\s+(.*)\)\s*$/);
                             if (listMatch) {
                                 const fixed = lineContent.slice(0, aIdx) + '(cons ' + listMatch[1] + ')' + lineContent.slice(close + 1);
-                                if (fixed !== lineContent)
-                                    result = replaceLine(result, idx, fixed);
+                                if (fixed !== lineContent) {
+                                    lines[idx] = fixed;
+                                    fixedLines.add(idx);
+                                }
                             }
                         }
                     }
@@ -479,38 +509,106 @@ function applyFixes(issues, content, filepath) {
                 }
                 case 'nth_usage': {
                     const fixed = lineContent.replace(/\(nth\s+0\s+/g, '(car ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'setq_single_arg': {
-                    const allLines = result.split('\n');
-                    if (/^\s*\(setq\s+\S+\s*\)\s*$/.test(allLines[idx])) {
-                        allLines.splice(idx, 1);
-                        result = allLines.join('\n');
+                    if (/^\s*\(setq\s+\S+\s*\)\s*$/.test(lines[idx])) {
+                        lines.splice(idx, 1);
                     }
                     break;
                 }
                 case 'extra_parens': {
                     const fixed = lineContent.replace(/\){2,}/g, ')');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'empty_branch': {
                     const fixed = lineContent.replace(/\(if\s+\S+\s*\)/g, m => m.slice(0, -1) + ' nil)');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
+                    break;
+                }
+                case 'comment_style': {
+                    const fixed = lineContent.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
+                    break;
+                }
+                case 'eq_usage': {
+                    const fixed = lineContent.replace(/\(eq\s+(\S+)\s+(\d+)\s*\)/g, '(= $1 $2)');
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
+                    break;
+                }
+                case 'cond_simplify': {
+                    const condIdx = lineContent.indexOf('(cond ');
+                    if (condIdx !== -1) {
+                        const condEnd = findMatchingParen(lineContent, condIdx);
+                        if (condEnd > condIdx) {
+                            const inner = lineContent.slice(condIdx + 6, condEnd).trim();
+                            const branchOpen = inner.indexOf('(');
+                            if (branchOpen !== -1) {
+                                const branchEnd = findMatchingParen(inner, branchOpen);
+                                if (branchEnd > branchOpen) {
+                                    const indent = lineContent.slice(0, condIdx);
+                                    const branchContent = inner.slice(branchOpen + 1, branchEnd).trim();
+                                    const space = branchContent.search(/\s+/);
+                                    if (space !== -1) {
+                                        const testExpr = branchContent.slice(0, space);
+                                        const bodyExpr = branchContent.slice(space).trim();
+                                        const rest = lineContent.slice(condEnd + 1);
+                                        const fixed = indent + '(if ' + testExpr + ' ' + bodyExpr + ')' + rest;
+                                        if (fixed !== lineContent) {
+                                            lines[idx] = fixed;
+                                            fixedLines.add(idx);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'self_compare': {
+                    const fixed = lineContent.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
+                    break;
+                }
+                case 'while_constant': {
+                    const trimmed = lines[idx].trim();
+                    const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
+                    if (nilMatch) {
+                        lines[idx] = lines[idx].replace(trimmed, 'nil');
+                    }
+                    break;
+                }
+                case 'redundant_list': {
+                    const fixed = lineContent.replace(/\(\s*list\s*\)/g, 'nil');
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
             }
         }
     }
-    return result;
-}
-function replaceLine(content, lineIdx, newLine) {
-    const lines = content.split('\n');
-    lines[lineIdx] = newLine;
     return lines.join('\n');
 }
 function parseIgnoreFile(rootDir) {
@@ -527,23 +625,51 @@ const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
     let content = fs.readFileSync(filepath, 'utf-8');
-    const wsFixed = content
-        .split('\n')
-        .map(l => l.replace(/[ \t]+$/, ''))
-        .join('\n');
-    if (wsFixed !== content) {
-        content = wsFixed;
-        fixes.push('trailing_whitespace');
-    }
+    // 1. Remove BOM
     if (content.charCodeAt(0) === UTF8_BOM) {
         content = content.slice(1);
         fixes.push('encoding (BOM)');
     }
+    // 2. Single line pass: trailing whitespace + empty comment lines
+    const origLines = content.split('\n');
+    let wsChanged = false;
+    let ecChanged = false;
+    const processed = origLines.map(l => {
+        const stripped = l.replace(/[ \t]+$/, '');
+        if (stripped !== l)
+            wsChanged = true;
+        if (/^\s*;\s*$/.test(stripped)) {
+            ecChanged = true;
+            return '';
+        }
+        return stripped;
+    });
+    if (wsChanged)
+        fixes.push('trailing_whitespace');
+    if (ecChanged)
+        fixes.push('empty_comment');
+    if (wsChanged || ecChanged)
+        content = processed.join('\n');
+    // 3. Count parens (string/comment aware), fix trailing excess
     let openCount = 0;
     let closeCount = 0;
-    let fixContent = content;
-    for (let i = 0; i < fixContent.length; i++) {
-        const ch = fixContent[i];
+    let inStr = false;
+    for (let i = 0; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === '"') {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr) {
+            if (ch === '\\')
+                i++;
+            continue;
+        }
+        if (ch === ';') {
+            const nl = content.indexOf('\n', i);
+            i = nl !== -1 ? nl : content.length;
+            continue;
+        }
         if (ch === '(')
             openCount++;
         else if (ch === ')')
@@ -551,29 +677,17 @@ function fixFile(filepath) {
     }
     if (closeCount > openCount) {
         let excess = closeCount - openCount;
-        while (excess > 0 && fixContent.endsWith(')')) {
-            fixContent = fixContent.slice(0, -1);
+        let fixed = content;
+        while (excess > 0 && fixed.endsWith(')')) {
+            fixed = fixed.slice(0, -1);
             excess--;
         }
-        fixContent = fixContent.replace(/\n[ \t]*$/, '');
-        if (fixContent !== content) {
-            content = fixContent;
+        fixed = fixed.replace(/\n[ \t]*$/, '');
+        if (fixed !== content) {
+            content = fixed;
             fixes.push('trailing_paren');
         }
     }
-    const lines = content.split('\n');
-    let changed = false;
-    const fixedLines = lines.map(l => {
-        if (/^\s*;\s*$/.test(l)) {
-            changed = true;
-            return '';
-        }
-        return l;
-    });
-    if (changed) {
-        content = fixedLines.join('\n');
-        fixes.push('empty_comment');
-    }
     if (fixes.length > 0) {
         fs.writeFileSync(filepath, content, 'utf-8');
     }

package/dist/stub-packages.json

@@ -0,0 +1,41 @@
+((AUTOLISP ())
+ (@ (COMMON-LISP AUTOLISP))
+ (C ())
+ (JSON ())
+ (SIDEBAR ())
+ (FUN ())
+ (DCL ())
+ (BASE ())
+ (STRING ())
+ (BLOCK ())
+ (ENTITY ())
+ (LAYER ())
+ (LAYOUT ())
+ (CURVE ())
+ (LIST ())
+ (M ())
+ (P ())
+ (UI ())
+ (SYS ())
+ (EXCEL ())
+ (WORD ())
+ (RE ())
+ (VECTRA ())
+ (DOS ())
+ (AT-PM ())
+ (QRENCODE ())
+ (NETWORK ())
+ (PKGMAN ())
+ (DATETIME ())
+ (DICT ())
+ (@NLP ())
+ (AT-SIDEBAR ())
+ (S ())
+ (VL ())
+ (VLR ())
+ (VLAX ())
+ (THEME ())
+ (AJAX ())
+ (ATLISP ())
+ (LOG ())
+ (ATLISP-CORE ()))

package/dist/visitor-runner.js

@@ -17,7 +17,7 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
         openCount: 0,
         closeCount: 0,
         setqDefs: new Map(),
-        symbolRefs: new Set(),
+        symbolRefs: new Map(),
         condKeys: new Map(),
         defunScopes: [],
         letScopes: [],
@@ -379,9 +379,9 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
             const seen = new Set();
             for (let i = 1; i < node.children.length; i++) {
                 const clause = node.children[i];
-                if (clause.type !== 'list' || !clause.children || clause.children.length < 2)
+                if (clause.type !== 'list' || !clause.children || clause.children.length < 1)
                     continue;
-                const condTest = clause.children[1];
+                const condTest = clause.children[0];
                 const key = getCondKey(condTest);
                 if (seen.has(key)) {
                     addIssue('cond_duplicate', clause.pos.line, (0, locale_1.t)('cond_duplicate'));
@@ -574,7 +574,7 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
     if (checks['unused_variable'] !== 'off') {
         visitor.on('*', node => {
             if (node.type === 'symbol' && node.name) {
-                state.symbolRefs.add(node.name);
+                state.symbolRefs.set(node.name, (state.symbolRefs.get(node.name) || 0) + 1);
             }
         });
     }
@@ -672,11 +672,7 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
     if (checks['unused_variable'] !== 'off') {
         for (const [name, def] of state.setqDefs) {
             if (state.setqDefs.size > 1) {
-                let refCount = 0;
-                for (const ref of state.symbolRefs) {
-                    if (ref === name)
-                        refCount++;
-                }
+                const refCount = state.symbolRefs.get(name) || 0;
                 if (refCount <= 1) {
                     addIssue('unused_variable', def.line, (0, locale_1.t)('unused_variable', name));
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",
@@ -37,7 +37,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@atlisp/parser": "^0.1.2"
+    "@atlisp/parser": "^0.1.3"
   },
   "devDependencies": {
     "@types/jest": "^29",