@atlisp/lint 0.1.21 → 0.1.23

package/dist/checks/empty-catch.js

@@ -61,19 +61,30 @@ function getSetqVarName(node) {
     return null;
 }
 function hasErrorCheckInSiblings(node, varName) {
-    const parent = node.parent;
+    let parent = node.parent;
     if (!parent || !parent.children)
         return false;
     const idx = parent.children.indexOf(node);
     for (let i = idx + 1; i < parent.children.length; i++) {
-        const sibling = parent.children[i];
-        if ((0, parser_1.astIsList)(sibling, 'vl-catch-all-error-p')) {
-            if (sibling.children && sibling.children.length >= 2 &&
-                (0, parser_1.astIsSymbol)(sibling.children[1], varName)) {
-                return true;
+        if (containsErrorCheck(parent.children[i], varName))
+            return true;
+    }
+    if ((0, parser_1.astIsList)(parent, 'setq')) {
+        const grandparent = parent.parent;
+        if (grandparent && grandparent.children) {
+            const parentIdx = grandparent.children.indexOf(parent);
+            for (let i = parentIdx + 1; i < grandparent.children.length; i++) {
+                if (containsErrorCheck(grandparent.children[i], varName))
+                    return true;
             }
         }
     }
     return false;
 }
+function containsErrorCheck(node, varName) {
+    const matches = (0, parser_1.astFindAll)(node, n => (0, parser_1.astIsList)(n, 'vl-catch-all-error-p') &&
+        n.children && n.children.length >= 2 &&
+        (0, parser_1.astIsSymbol)(n.children[1], varName));
+    return matches.length > 0;
+}
 //# sourceMappingURL=empty-catch.js.map

package/dist/checks/unused-catch-result.js

@@ -2,27 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkUnusedCatchResult = checkUnusedCatchResult;
 const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
 function checkUnusedCatchResult(content, file) {
     const issues = [];
-    const lines = content.split('\n');
-    const catchRe = /\(vl-catch-all-apply\s+'[^)]+\)/g;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        let match;
-        while ((match = catchRe.exec(line)) !== null) {
-            const col = match.index;
-            const after = line.slice(col + match[0].length).trim();
-            if (!after.startsWith(')')) {
-                issues.push({
-                    file,
-                    line: i + 1,
-                    severity: 'warn',
-                    rule: 'unused_catch_result',
-                    message: (0, locale_1.t)('unused_catch_result'),
-                });
-            }
-        }
+    const ast = (0, parser_1.parseAst)(content);
+    const catchNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'vl-catch-all-apply'));
+    for (const node of catchNodes) {
+        if (isInQuote(node))
+            continue;
+        if (isWrappedByCatchError(node))
+            continue;
+        if (isSetqStored(node))
+            continue;
+        issues.push({
+            file,
+            line: node.pos.line,
+            severity: 'warn',
+            rule: 'unused_catch_result',
+            message: (0, locale_1.t)('unused_catch_result'),
+        });
     }
     return issues;
 }
+function isInQuote(node) {
+    let p = node.parent;
+    while (p) {
+        if ((0, parser_1.astIsList)(p, 'quote'))
+            return true;
+        p = p.parent;
+    }
+    return false;
+}
+function isWrappedByCatchError(node) {
+    const parent = node.parent;
+    return !!(parent && (0, parser_1.astIsList)(parent, 'vl-catch-all-error-p'));
+}
+function isSetqStored(node) {
+    const parent = node.parent;
+    if (!parent || !(0, parser_1.astIsList)(parent, 'setq'))
+        return false;
+    if (!parent.children || parent.children.length < 3)
+        return false;
+    const idx = parent.children.indexOf(node);
+    return idx >= 2 && idx % 2 === 0;
+}
 //# sourceMappingURL=unused-catch-result.js.map

package/dist/runner.d.ts

@@ -3,6 +3,7 @@ export declare function runChecks(content: string, file: string, config: LintCon
 export declare function runChecksWithVisitorWrapper(content: string, file: string, config: LintConfig): Issue[];
 export declare function lintFiles(files: string[], config: LintConfig, rootDir: string): Issue[];
 export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
+export declare const FIXABLE_RULES: Set<string>;
 export declare function applyFixes(issues: Issue[], content: string, filepath: string): string;
 export declare function parseIgnoreFile(rootDir: string): string[];
 export declare function fixFile(filepath: string): string[];

package/dist/runner.js

@@ -33,6 +33,7 @@ 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;
@@ -308,6 +309,16 @@ 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 fixesByRule = new Map();
@@ -318,13 +329,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',
-    ]);
+    const fixableRules = exports.FIXABLE_RULES;
     let result = content;
     for (const [rule, lineSet] of fixesByRule) {
         if (!fixableRules.has(rule))
@@ -503,6 +508,67 @@ function applyFixes(issues, content, filepath) {
                         result = replaceLine(result, idx, fixed);
                     break;
                 }
+                case 'comment_style': {
+                    const fixed = lineContent.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    break;
+                }
+                case 'eq_usage': {
+                    const fixed = lineContent.replace(/\(eq\s+(\S+)\s+(\d+)\s*\)/g, '(= $1 $2)');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    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)
+                                            result = replaceLine(result, idx, fixed);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'self_compare': {
+                    const fixed = lineContent.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    break;
+                }
+                case 'while_constant': {
+                    const allLines = result.split('\n');
+                    const trimmed = allLines[idx].trim();
+                    const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
+                    if (nilMatch) {
+                        allLines[idx] = allLines[idx].replace(trimmed, 'nil');
+                        result = allLines.join('\n');
+                    }
+                    break;
+                }
+                case 'redundant_list': {
+                    const fixed = lineContent.replace(/\(\s*list\s*\)/g, 'nil');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    break;
+                }
             }
         }
     }

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.21",
+  "version": "0.1.23",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",