@atlisp/lint 0.1.5 → 0.1.8

package/dist/checks/arg-count.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArgCount = checkArgCount;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkArgCount(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const defuns = [];
+    // Collect all defun definitions
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const m = stripped.match(/\(defun\s+(\S+)\s+\(([^)]*)\)/);
+        if (m) {
+            const all = m[2];
+            const slashIdx = all.indexOf('/');
+            const paramStr = slashIdx >= 0 ? all.slice(0, slashIdx).trim() : all;
+            const params = paramStr.split(/\s+/).filter(Boolean);
+            defuns.push({ name: m[1], line: i + 1, paramCount: params.length });
+        }
+    }
+    // Check calls against definitions
+    for (const fn of defuns) {
+        if (fn.name.startsWith('c:') || fn.name.includes('/'))
+            continue;
+        if (fn.paramCount === 0)
+            continue;
+        for (let i = 0; i < lines.length; i++) {
+            const stripped = (0, utils_1.stripLine)(lines[i]);
+            const re = new RegExp('\\(\\s*' + fn.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s+');
+            // Don't match the definition line
+            if (stripped.includes('defun') && stripped.includes(fn.name))
+                continue;
+            const callMatch = re.exec(stripped);
+            if (callMatch) {
+                // Collect all text from the call across lines
+                let callText = stripped.slice(callMatch.index);
+                let parenDepth = 0;
+                for (const ch of callText) {
+                    if (ch === '(')
+                        parenDepth++;
+                    else if (ch === ')')
+                        parenDepth--;
+                }
+                // If not closed on this line, read next lines
+                let lineIdx = i + 1;
+                while (parenDepth > 0 && lineIdx < lines.length) {
+                    const nextStripped = (0, utils_1.stripLine)(lines[lineIdx]);
+                    callText += ' ' + nextStripped;
+                    for (const ch of nextStripped) {
+                        if (ch === '(')
+                            parenDepth++;
+                        else if (ch === ')')
+                            parenDepth--;
+                    }
+                    lineIdx++;
+                }
+                // Extract args: remove the function call prefix
+                const afterName = callText.slice(callMatch[0].length - 1); // keep the leading (
+                // Find matching closing paren
+                let closeIdx = -1;
+                let pd = 1;
+                for (let j = 0; j < afterName.length; j++) {
+                    if (afterName[j] === '(')
+                        pd++;
+                    else if (afterName[j] === ')') {
+                        pd--;
+                        if (pd === 0) {
+                            closeIdx = j;
+                            break;
+                        }
+                    }
+                }
+                const argsStr = closeIdx >= 0 ? afterName.slice(0, closeIdx).trim() : afterName.trim();
+                if (!argsStr)
+                    continue;
+                // Count space-delimited args at depth 0
+                let argCount = 0;
+                let depth = 0;
+                let inArg = false;
+                for (const ch of argsStr) {
+                    if (ch === '(') {
+                        depth++;
+                        if (!inArg) {
+                            inArg = true;
+                        }
+                    }
+                    else if (ch === ')') {
+                        depth--;
+                        if (depth === 0) {
+                            if (inArg) {
+                                argCount++;
+                                inArg = false;
+                            }
+                        }
+                    }
+                    else if (depth === 0 && (ch === ' ' || ch === '\t')) {
+                        if (inArg) {
+                            argCount++;
+                            inArg = false;
+                        }
+                    }
+                    else if (!inArg) {
+                        inArg = true;
+                    }
+                }
+                if (inArg)
+                    argCount++;
+                if (argCount !== fn.paramCount) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        severity: 'warn',
+                        rule: 'arg_count',
+                        message: (0, locale_1.t)('arg_count', fn.name, argCount, fn.paramCount),
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=arg-count.js.map

package/dist/checks/assoc-without-cdr.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkAssocWithoutCdr(content: string, file: string): Issue[];
+export declare function checkAssocWithoutCdrAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=assoc-without-cdr.d.ts.map

package/dist/checks/assoc-without-cdr.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAssocWithoutCdr = checkAssocWithoutCdr;
+exports.checkAssocWithoutCdrAst = checkAssocWithoutCdrAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkAssocWithoutCdr(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkAssocWithoutCdrAst(ast, file);
+}
+function checkAssocWithoutCdrAst(ast, file) {
+    const issues = [];
+    const assocNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'assoc'));
+    for (const node of assocNodes) {
+        if (!node.parent)
+            continue;
+        // Check if parent is not a cdr or cadr call
+        const parent = node.parent;
+        const isWrapped = (0, parser_1.astIsList)(parent, 'cdr') || (0, parser_1.astIsList)(parent, 'cadr');
+        if (!isWrapped) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'assoc_without_cdr',
+                message: (0, locale_1.t)('assoc_without_cdr'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=assoc-without-cdr.js.map

package/dist/checks/comment-style.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkCommentStyle(content: string, file: string): Issue[];
+//# sourceMappingURL=comment-style.d.ts.map

package/dist/checks/comment-style.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommentStyle = checkCommentStyle;
+const locale_1 = require("../locale");
+function checkCommentStyle(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Detect ; not followed by space (except ;; and ;|)
+        if (/^;[^ ;|]/.test(trimmed)) {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'comment_style',
+                message: (0, locale_1.t)('comment_style'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=comment-style.js.map

package/dist/checks/cond-duplicate.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkCondDuplicate(content: string, file: string): Issue[];
+export declare function checkCondDuplicateAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=cond-duplicate.d.ts.map

package/dist/checks/cond-duplicate.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCondDuplicate = checkCondDuplicate;
+exports.checkCondDuplicateAst = checkCondDuplicateAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function condKey(node) {
+    if (node.type === 'symbol')
+        return `s:${node.name}`;
+    if (node.type === 'number')
+        return `n:${node.value}`;
+    if (node.type === 'string')
+        return `str:${node.value}`;
+    if (node.type === 'list') {
+        const children = node.children || [];
+        return `list(${children.map(condKey).join(',')})`;
+    }
+    return '';
+}
+function checkCondDuplicate(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkCondDuplicateAst(ast, file);
+}
+function checkCondDuplicateAst(ast, file) {
+    const issues = [];
+    const condNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'cond'));
+    for (const node of condNodes) {
+        if (!node.children)
+            continue;
+        const seen = new Map();
+        for (let i = 1; i < node.children.length; i++) {
+            const clause = node.children[i];
+            if (!clause.children || clause.children.length < 1)
+                continue;
+            const condition = clause.children[0];
+            const key = condKey(condition);
+            if (seen.has(key)) {
+                issues.push({
+                    file,
+                    line: node.pos.line,
+                    severity: 'warn',
+                    rule: 'cond_duplicate',
+                    message: (0, locale_1.t)('cond_duplicate'),
+                });
+                break;
+            }
+            seen.set(key, i);
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=cond-duplicate.js.map

package/dist/checks/cond-simplify.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkCondSimplify(content: string, file: string): Issue[];
+//# sourceMappingURL=cond-simplify.d.ts.map

package/dist/checks/cond-simplify.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCondSimplify = checkCondSimplify;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkCondSimplify(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        // Match (cond (t ...)) or (cond (expr ...)) - single branch cond
+        // A single-branch cond typically looks like: (cond (expr body)) on one line
+        const m = stripped.match(/\(cond\s+\(/);
+        if (m) {
+            // Count how many top-level branches inside this cond
+            const condStart = stripped.indexOf('(cond');
+            const afterCond = stripped.slice(condStart + 5).trim();
+            let branchCount = 0;
+            let parenDepth = 0;
+            for (const ch of afterCond) {
+                if (ch === '(') {
+                    if (parenDepth === 0)
+                        branchCount++;
+                    parenDepth++;
+                }
+                else if (ch === ')') {
+                    parenDepth--;
+                    if (parenDepth < 0)
+                        break;
+                }
+            }
+            if (branchCount === 1) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'cond_simplify',
+                    message: (0, locale_1.t)('cond_simplify'),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=cond-simplify.js.map

package/dist/checks/constant-condition.js

@@ -14,7 +14,7 @@ function checkConstantConditionAst(ast, file) {
     const issues = [];
     // Check if / while with constant condition
     for (const form of CONDITION_FORMS) {
-        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, form));
         for (const node of nodes) {
             if (!node.children || node.children.length < 2)
                 continue;
@@ -31,7 +31,7 @@ function checkConstantConditionAst(ast, file) {
         }
     }
     // Check (cond (T ...))
-    const condNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'cond'));
+    const condNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'cond'));
     for (const condNode of condNodes) {
         if (!condNode.children)
             continue;
@@ -52,7 +52,7 @@ function checkConstantConditionAst(ast, file) {
         }
     }
     // Check (or T ...) — first arg is T, always short-circuits to T
-    const orNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'or'));
+    const orNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'or'));
     for (const node of orNodes) {
         if (!node.children || node.children.length < 2)
             continue;
@@ -68,7 +68,7 @@ function checkConstantConditionAst(ast, file) {
         }
     }
     // Check (and nil ...) — first arg is nil, always short-circuits to nil
-    const andNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'and'));
+    const andNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'and'));
     for (const node of andNodes) {
         if (!node.children || node.children.length < 2)
             continue;

package/dist/checks/dangerous-calls.js

@@ -47,7 +47,7 @@ function checkDangerousCallsAst(ast, file, config) {
             continue;
         if (pattern.commandShell) {
             // Find (command "shell" ...) calls
-            const commandCalls = (0, parser_1.astFindAll)(ast, (n) => isFunctionCall(n, 'command'));
+            const commandCalls = (0, parser_1.astFindAll)(ast, n => isFunctionCall(n, 'command'));
             for (const call of commandCalls) {
                 if (isInQuote(call))
                     continue;
@@ -67,7 +67,7 @@ function checkDangerousCallsAst(ast, file, config) {
         }
         else if (pattern.functionCall) {
             // Find actual function calls
-            const calls = (0, parser_1.astFindAll)(ast, (n) => isFunctionCall(n, pattern.rule));
+            const calls = (0, parser_1.astFindAll)(ast, n => isFunctionCall(n, pattern.rule));
             for (const call of calls) {
                 if (isInQuote(call))
                     continue;

package/dist/checks/dangling-defun.d.ts

@@ -2,5 +2,8 @@ import { Issue } from '../types';
 export declare function checkDanglingDefun(file: string, allDefuns: Map<string, {
     file: string;
     line: number;
+}[]>, allReferences: Map<string, {
+    file: string;
+    line: number;
 }[]>): Issue[];
 //# sourceMappingURL=dangling-defun.d.ts.map

package/dist/checks/dangling-defun.js

@@ -37,46 +37,28 @@ exports.checkDanglingDefun = checkDanglingDefun;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const fs = __importStar(require("fs"));
-function checkDanglingDefun(file, allDefuns) {
+function checkDanglingDefun(file, allDefuns, allReferences) {
     const issues = [];
     const content = fs.readFileSync(file, 'utf-8');
     const ast = (0, parser_1.parseAst)(content);
     const localDefuns = [];
-    const defunNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
+    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])) {
-            localDefuns.push(node.children[1].name);
+            localDefuns.push({ name: node.children[1].name, line: node.pos.line });
         }
     }
-    const calledSymbols = new Set();
-    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(':')) {
-            calledSymbols.add(name);
-        }
-    }
-    for (const defunName of localDefuns) {
-        let isCalled = calledSymbols.has(defunName);
-        if (!isCalled) {
-            for (const [, defs] of allDefuns) {
-                if (defs.some((d) => d.file !== file)) {
-                    isCalled = true;
-                    break;
-                }
-            }
-        }
-        if (!isCalled) {
+    for (const defun of localDefuns) {
+        const refs = allReferences.get(defun.name) || [];
+        const calledElsewhere = refs.some(r => r.file !== file);
+        const calledLocally = refs.some(r => r.file === file);
+        if (!calledLocally && !calledElsewhere) {
             issues.push({
                 file,
-                line: defunNodes.find((n) => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === defunName).pos.line,
+                line: defun.line,
                 severity: 'warn',
                 rule: 'dangling_defun',
-                message: (0, locale_1.t)('dangling_defun', defunName),
+                message: (0, locale_1.t)('dangling_defun', defun.name),
             });
         }
     }

package/dist/checks/double-not.js

@@ -10,7 +10,7 @@ function checkDoubleNot(content, file) {
 }
 function checkDoubleNotAst(ast, file) {
     const issues = [];
-    const notNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'not'));
+    const notNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'not'));
     for (const node of notNodes) {
         if (!node.children || node.children.length < 2)
             continue;

package/dist/checks/duplicate-defun.d.ts

@@ -0,0 +1,6 @@
+import { Issue } from '../types';
+export declare function checkDuplicateDefun(filepath: string, allDefuns: Map<string, {
+    file: string;
+    line: number;
+}[]>): Issue[];
+//# sourceMappingURL=duplicate-defun.d.ts.map

package/dist/checks/duplicate-defun.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDuplicateDefun = checkDuplicateDefun;
+const locale_1 = require("../locale");
+function checkDuplicateDefun(filepath, allDefuns) {
+    const issues = [];
+    const defunsInFile = new Map();
+    // Collect defuns in this file
+    for (const [name, locations] of allDefuns) {
+        for (const loc of locations) {
+            if (loc.file === filepath) {
+                const lines = defunsInFile.get(name) || [];
+                lines.push(loc.line);
+                defunsInFile.set(name, lines);
+            }
+        }
+    }
+    // Check for duplicates within this file
+    for (const [name, lines] of defunsInFile) {
+        if (lines.length > 1) {
+            for (const line of lines.slice(1)) {
+                issues.push({
+                    file: filepath,
+                    line,
+                    severity: 'warn',
+                    rule: 'duplicate_defun',
+                    message: (0, locale_1.t)('duplicate_defun', name),
+                });
+            }
+        }
+    }
+    // Check for duplicates across files
+    for (const [name, locations] of allDefuns) {
+        const matchingFiles = locations.filter(l => l.file !== filepath);
+        if (matchingFiles.length > 0) {
+            const thisFileLoc = locations.find(l => l.file === filepath);
+            if (thisFileLoc) {
+                issues.push({
+                    file: filepath,
+                    line: thisFileLoc.line,
+                    severity: 'warn',
+                    rule: 'duplicate_defun',
+                    message: (0, locale_1.t)('duplicate_defun', name),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=duplicate-defun.js.map

package/dist/checks/dynamic-doc.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkDynamicDoc(content: string, file: string): Issue[];
+//# sourceMappingURL=dynamic-doc.d.ts.map

package/dist/checks/dynamic-doc.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDynamicDoc = checkDynamicDoc;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkDynamicDoc(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const m = stripped.match(/\(defun\s+(C:\S+)\b/);
+        if (m) {
+            const body = lines.slice(i + 1).join('\n');
+            if (!body.includes('(princ)')) {
+                issues.push({ file, line: i + 1, severity: 'warn', rule: 'dynamic_doc', message: (0, locale_1.t)('dynamic_doc', m[1]) });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=dynamic-doc.js.map

package/dist/checks/empty-branch.js

@@ -13,7 +13,7 @@ function checkEmptyBranch(content, file) {
 function checkEmptyBranchAst(ast, file) {
     const issues = [];
     for (const form of BRANCH_FORMS) {
-        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, form));
         for (const node of nodes) {
             if (!node.children)
                 continue;

package/dist/checks/empty-catch.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkEmptyCatch(content: string, file: string): Issue[];
+//# sourceMappingURL=empty-catch.d.ts.map

package/dist/checks/empty-catch.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmptyCatch = checkEmptyCatch;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkEmptyCatch(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        // Detect (vl-catch-all-apply ...) not inside (vl-catch-all-error-p ...) check
+        if (stripped.includes('vl-catch-all-apply')) {
+            // Check subsequent lines for error-p check
+            let hasErrorCheck = false;
+            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+                if ((0, utils_1.stripLine)(lines[j]).includes('vl-catch-all-error-p')) {
+                    hasErrorCheck = true;
+                    break;
+                }
+            }
+            if (!hasErrorCheck) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'empty_catch',
+                    message: (0, locale_1.t)('empty_catch'),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=empty-catch.js.map

package/dist/checks/eq-usage.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkEqUsage(content: string, file: string): Issue[];
+//# sourceMappingURL=eq-usage.d.ts.map

package/dist/checks/eq-usage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEqUsage = checkEqUsage;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkEqUsage(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        // Detect (eq num ...) where num is literal number
+        const m = stripped.match(/\(eq\s+\S+\s+(\d+)/);
+        if (m) {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'eq_usage',
+                message: (0, locale_1.t)('eq_usage'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=eq-usage.js.map

package/dist/checks/error-handling.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkErrorHandling(content: string, file: string): Issue[];
+//# sourceMappingURL=error-handling.d.ts.map