@atlisp/lint 0.1.3 → 0.1.5

package/dist/checks/function-complexity.js

@@ -1,57 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkFunctionComplexity = checkFunctionComplexity;
+exports.checkFunctionComplexityAst = checkFunctionComplexityAst;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkFunctionComplexity(content, file, maxLines, maxNesting) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkFunctionComplexityAst(ast, file, maxLines, maxNesting);
+}
+function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {
     const issues = [];
-    const lines = content.split('\n');
-    let inDefun = false;
-    let defunName = '';
-    let defunStart = 0;
-    let defunLines = 0;
-    let maxDepth = 0;
-    let depth = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        if (!inDefun) {
-            const m = stripped.match(/\(defun\s+(\S+)/);
-            if (m) {
-                inDefun = true;
-                defunName = m[1];
-                defunStart = i + 1;
-                defunLines = 0;
-                maxDepth = 0;
-                depth = 0;
-            }
+    // Check defun forms
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || !defun.end)
+            continue;
+        if (defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        const name = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '<unknown>';
+        const bodyLines = (defun.end ? defun.end.line : defun.pos.line) - defun.pos.line + 1;
+        const depth = computeNestingDepth(defun, 1);
+        if (bodyLines > maxLines) {
+            issues.push({
+                file,
+                line: defun.pos.line,
+                severity: 'warn',
+                rule: 'function_complexity',
+                message: (0, locale_1.t)('function_complexity.lines', name, bodyLines, maxLines),
+            });
         }
-        if (inDefun) {
-            defunLines++;
-            for (const ch of stripped) {
-                if (ch === '(')
-                    depth++;
-                else if (ch === ')')
-                    depth--;
-            }
-            if (depth > maxDepth)
-                maxDepth = depth;
-            if (depth === 0 && defunLines > 1) {
-                if (defunLines > maxLines) {
-                    issues.push({
-                        file, line: defunStart, severity: 'warn', rule: 'function_complexity',
-                        message: (0, locale_1.t)('function_complexity.lines', defunName, defunLines, maxLines),
-                    });
-                }
-                if (maxDepth > maxNesting) {
-                    issues.push({
-                        file, line: defunStart, severity: 'warn', rule: 'function_complexity',
-                        message: (0, locale_1.t)('function_complexity.nesting', defunName, maxDepth, maxNesting),
-                    });
-                }
-                inDefun = false;
-            }
+        if (depth > maxNesting) {
+            issues.push({
+                file,
+                line: defun.pos.line,
+                severity: 'warn',
+                rule: 'function_complexity',
+                message: (0, locale_1.t)('function_complexity.nesting', name, depth, maxNesting),
+            });
+        }
+    }
+    // Check lambda forms: (lambda (args) body...)
+    const lambdas = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'lambda'));
+    for (const lam of lambdas) {
+        if (!lam.children || !lam.end)
+            continue;
+        // Skip quoted lambdas: (quote (lambda ...)) — data, not code
+        if (isInsideQuote(lam))
+            continue;
+        const bodyLines = (lam.end ? lam.end.line : lam.pos.line) - lam.pos.line + 1;
+        const depth = computeNestingDepth(lam, 1);
+        if (bodyLines > maxLines) {
+            issues.push({
+                file,
+                line: lam.pos.line,
+                severity: 'warn',
+                rule: 'function_complexity',
+                message: (0, locale_1.t)('function_complexity.lines', '(lambda)', bodyLines, maxLines),
+            });
+        }
+        if (depth > maxNesting) {
+            issues.push({
+                file,
+                line: lam.pos.line,
+                severity: 'warn',
+                rule: 'function_complexity',
+                message: (0, locale_1.t)('function_complexity.nesting', '(lambda)', depth, maxNesting),
+            });
         }
     }
     return issues;
 }
+function isInsideQuote(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'list' &&
+            cur.children &&
+            cur.children.length > 0 &&
+            cur.children[0].type === 'symbol' &&
+            cur.children[0].name === 'quote') {
+            return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
+function computeNestingDepth(node, depth) {
+    if (node.type !== 'list' || !node.children)
+        return depth;
+    let max = depth;
+    for (const child of node.children) {
+        if (child.type === 'list' && child.children) {
+            const childDepth = computeNestingDepth(child, depth + 1);
+            if (childDepth > max)
+                max = childDepth;
+        }
+    }
+    return max;
+}
 //# sourceMappingURL=function-complexity.js.map

package/dist/checks/line-length.js

@@ -9,7 +9,10 @@ function checkLineLength(content, file, max, tabWidth) {
         const displayLen = lines[i].replace(/\t/g, ' '.repeat(tabWidth)).length;
         if (displayLen > max) {
             issues.push({
-                file, line: i + 1, severity: 'warn', rule: 'line_length',
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'line_length',
                 message: (0, locale_1.t)('line_length', displayLen, max),
             });
         }

package/dist/checks/misplaced-else.d.ts

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

package/dist/checks/misplaced-else.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMisplacedElse = checkMisplacedElse;
+exports.checkMisplacedElseAst = checkMisplacedElseAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkMisplacedElse(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkMisplacedElseAst(ast, file);
+}
+function checkMisplacedElseAst(ast, file) {
+    const issues = [];
+    const ifNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'if'));
+    for (const node of ifNodes) {
+        if (!node.children || node.children.length !== 4)
+            continue;
+        const cond = node.children[1];
+        if (!(0, parser_1.astIsList)(cond, 'not'))
+            continue;
+        const innerName = cond.children && cond.children[1] && cond.children[1].name;
+        issues.push({
+            file,
+            line: node.pos.line,
+            severity: 'warn',
+            rule: 'misplaced_else',
+            message: (0, locale_1.t)('misplaced_else', innerName || ''),
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=misplaced-else.js.map

package/dist/checks/missing-doc.js

@@ -18,19 +18,22 @@ function checkMissingDoc(content, file) {
             continue;
         if (name === 'T' || name === 'nil')
             continue;
-        // Check if previous non-empty line is a comment
+        // Check if previous non-empty line is a comment (use raw line, not stripped)
         let hasDoc = false;
         for (let j = i - 1; j >= 0; j--) {
             const prev = lines[j].trim();
             if (!prev)
                 continue;
-            if (prev.startsWith(';') || prev.startsWith(';|'))
+            if (prev.startsWith(';'))
                 hasDoc = true;
             break;
         }
         if (!hasDoc) {
             issues.push({
-                file, line: i + 1, severity: 'warn', rule: 'missing_doc',
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'missing_doc',
                 message: (0, locale_1.t)('missing_doc', name),
             });
         }

package/dist/checks/missing-export.d.ts

@@ -0,0 +1,13 @@
+import { Issue } from '../types';
+export interface MissingExportResult {
+    issues: Issue[];
+    allDefuns: Map<string, {
+        file: string;
+        line: number;
+    }[]>;
+}
+export declare function checkMissingExport(file: string, pkgDir: string, _allDefuns: Map<string, {
+    file: string;
+    line: number;
+}[]>): Issue[];
+//# sourceMappingURL=missing-export.d.ts.map

package/dist/checks/missing-export.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMissingExport = checkMissingExport;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function checkMissingExport(file, pkgDir, _allDefuns) {
+    const issues = [];
+    const pkgLspPath = path.join(pkgDir, 'pkg.lsp');
+    if (!fs.existsSync(pkgLspPath))
+        return issues;
+    const pkgContent = fs.readFileSync(pkgLspPath, 'utf-8');
+    const pkgAst = (0, parser_1.parseAst)(pkgContent);
+    const modulesNode = (0, parser_1.astFindAll)(pkgAst, (n) => (0, parser_1.astIsList)(n, 'setq'));
+    const registered = new Set();
+    for (const node of modulesNode) {
+        if (!node.children)
+            continue;
+        for (let i = 1; i < node.children.length - 1; i += 2) {
+            const sym = node.children[i];
+            if ((0, parser_1.astIsSymbol)(sym) && sym.name === '@::*modules*') {
+                const val = node.children[i + 1];
+                if (val.type === 'list' && val.children) {
+                    for (const item of val.children) {
+                        if ((0, parser_1.astIsSymbol)(item)) {
+                            registered.add(item.name);
+                        }
+                    }
+                }
+            }
+            if ((0, parser_1.astIsSymbol)(sym) && sym.name === '@::*modules*') {
+                break;
+            }
+        }
+    }
+    const fileContent = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(fileContent);
+    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)
+            continue;
+        const nameNode = node.children[1];
+        if (!(0, parser_1.astIsSymbol)(nameNode))
+            continue;
+        const name = nameNode.name;
+        if (name.startsWith('c:') || name.includes(':'))
+            continue;
+        if (!registered.has(name)) {
+            issues.push({
+                file,
+                line: nameNode.pos.line,
+                severity: 'warn',
+                rule: 'missing_export',
+                message: (0, locale_1.t)('missing_export', name),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=missing-export.js.map

package/dist/checks/module-reg.js

@@ -12,13 +12,18 @@ function checkModuleRegistration(content, file, relPath, config) {
     if (!config.dirs.includes(topDir))
         return [];
     const lines = content.split('\n');
-    const relevant = lines.filter(l => l.trim().length > 0);
+    const relevant = lines.filter((l) => l.trim().length > 0);
     const tail = relevant.slice(-20).join('\n');
     if (!tail.includes('*modules*')) {
-        return [{
-                file, line: 1, severity: config.severity, rule: 'module_registration',
+        return [
+            {
+                file,
+                line: 1,
+                severity: config.severity,
+                rule: 'module_registration',
                 message: (0, locale_1.t)('module_registration'),
-            }];
+            },
+        ];
     }
     return [];
 }

package/dist/checks/multiple-setq.d.ts

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

package/dist/checks/multiple-setq.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMultipleSetq = checkMultipleSetq;
+exports.checkMultipleSetqAst = checkMultipleSetqAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkMultipleSetq(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkMultipleSetqAst(ast, file);
+}
+function checkMultipleSetqAst(ast, file) {
+    const issues = [];
+    // Find all parent lists that contain at least one setq
+    const parents = new Set();
+    const setqNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'setq'));
+    for (const n of setqNodes) {
+        if (n.parent)
+            parents.add(n.parent);
+    }
+    for (const parent of parents) {
+        if (!parent.children)
+            continue;
+        let prevWasSetq = false;
+        let prevSetqNode = null;
+        for (const child of parent.children) {
+            const isSetq = (0, parser_1.astIsList)(child, 'setq');
+            if (isSetq && prevWasSetq && prevSetqNode) {
+                issues.push({
+                    file,
+                    line: prevSetqNode.pos.line,
+                    severity: 'warn',
+                    rule: 'multiple_setq',
+                    message: (0, locale_1.t)('multiple_setq'),
+                });
+                // Reset to avoid double-reporting the same pair
+                prevWasSetq = false;
+                prevSetqNode = null;
+            }
+            else if (isSetq) {
+                prevWasSetq = true;
+                prevSetqNode = child;
+            }
+            else {
+                prevWasSetq = false;
+                prevSetqNode = null;
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=multiple-setq.js.map

package/dist/checks/namespace-header.js

@@ -14,15 +14,25 @@ function checkNamespaceHeader(content, file, config) {
         if (stripped.startsWith('(in-package')) {
             if (stripped.includes(config.package))
                 return [];
-            return [{
-                    file, line: i + 1, severity: config.severity, rule: 'namespace_header',
+            return [
+                {
+                    file,
+                    line: i + 1,
+                    severity: config.severity,
+                    rule: 'namespace_header',
                     message: (0, locale_1.t)('namespace_header.wrong', config.package),
-                }];
+                },
+            ];
         }
     }
-    return [{
-            file, line: 1, severity: config.severity, rule: 'namespace_header',
+    return [
+        {
+            file,
+            line: 1,
+            severity: config.severity,
+            rule: 'namespace_header',
             message: (0, locale_1.t)('namespace_header.missing', config.package),
-        }];
+        },
+    ];
 }
 //# sourceMappingURL=namespace-header.js.map

package/dist/checks/open-close.d.ts

@@ -1,3 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkOpenWithoutClose(content: string, file: string): Issue[];
+export declare function checkOpenWithoutCloseAst(ast: AstNode, file: string): Issue[];
 //# sourceMappingURL=open-close.d.ts.map

package/dist/checks/open-close.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkOpenWithoutClose = checkOpenWithoutClose;
-const utils_1 = require("../utils");
+exports.checkOpenWithoutCloseAst = checkOpenWithoutCloseAst;
 const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
 function checkOpenWithoutClose(content, file) {
-    let openCount = 0, closeCount = 0;
-    for (const { stripped } of (0, utils_1.codeLines)(content)) {
-        if (/\(open\b/.test(stripped))
-            openCount++;
-        if (/\(close\b/.test(stripped))
-            closeCount++;
-    }
-    if (openCount > closeCount) {
-        return [{
-                file, line: 1, severity: 'warn', rule: 'open_without_close',
-                message: (0, locale_1.t)('open_without_close', openCount, closeCount),
-            }];
+    const ast = (0, parser_1.parseAst)(content);
+    return checkOpenWithoutCloseAst(ast, file);
+}
+function checkOpenWithoutCloseAst(ast, file) {
+    const openCalls = (0, parser_1.astFindListWithHead)(ast, 'open');
+    const closeCalls = (0, parser_1.astFindListWithHead)(ast, 'close');
+    if (openCalls.length > closeCalls.length) {
+        return [
+            {
+                file,
+                line: openCalls[0].pos.line,
+                severity: 'warn',
+                rule: 'open_without_close',
+                message: (0, locale_1.t)('open_without_close', openCalls.length, closeCalls.length),
+            },
+        ];
     }
     return [];
 }

package/dist/checks/parameter-naming.d.ts

@@ -1,3 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkParameterNaming(content: string, file: string): Issue[];
+export declare function checkParameterNamingAst(ast: AstNode, file: string): Issue[];
 //# sourceMappingURL=parameter-naming.d.ts.map

package/dist/checks/parameter-naming.js

@@ -1,25 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkParameterNaming = checkParameterNaming;
+exports.checkParameterNamingAst = checkParameterNamingAst;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkParameterNaming(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkParameterNamingAst(ast, file);
+}
+function checkParameterNamingAst(ast, 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+(\S+)\s+\(([^)]*)\)/);
-        if (!m)
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        const name = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '<unknown>';
+        // Third child should be the parameter list
+        const paramList = defun.children[2];
+        if (paramList.type !== 'list' || !paramList.children)
             continue;
-        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);
-        for (const p of params) {
-            if (/^[A-Z]/.test(p) && p !== 'T' && p !== 'nil') {
+        for (const p of paramList.children) {
+            if (p.type !== 'symbol' || !p.name)
+                continue;
+            if (p.name === 'T' || p.name === 'nil')
+                continue;
+            if (/^[A-Z]/.test(p.name)) {
                 issues.push({
-                    file, line: i + 1, severity: 'warn', rule: 'parameter_naming',
-                    message: (0, locale_1.t)('parameter_naming', p, m[1]),
+                    file,
+                    line: p.pos.line,
+                    severity: 'warn',
+                    rule: 'parameter_naming',
+                    message: (0, locale_1.t)('parameter_naming', p.name, name),
                 });
             }
         }

package/dist/checks/parens.js

@@ -32,10 +32,15 @@ function checkParens(content, file) {
     }
     if (openP !== closeP) {
         const diff = openP - closeP;
-        return [{
-                file, line: 1, severity: 'error', rule: 'parens',
+        return [
+            {
+                file,
+                line: 1,
+                severity: 'error',
+                rule: 'parens',
                 message: (0, locale_1.t)('parens.mismatch', openP, closeP, (diff > 0 ? '+' : '') + diff),
-            }];
+            },
+        ];
     }
     return [];
 }

package/dist/checks/quote-vs-function.d.ts

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

package/dist/checks/quote-vs-function.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkQuoteVsFunction = checkQuoteVsFunction;
+exports.checkQuoteVsFunctionAst = checkQuoteVsFunctionAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const HIGHER_ORDER_FUNCS = new Set([
+    'mapcar',
+    'apply',
+    'lambda',
+    'vl-sort',
+    'vl-sort-i',
+    'vl-remove-if',
+    'vl-remove-if-not',
+    'vl-member-if',
+    'vl-some',
+    'vl-every',
+]);
+function checkQuoteVsFunction(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkQuoteVsFunctionAst(ast, file);
+}
+function checkQuoteVsFunctionAst(ast, file) {
+    const issues = [];
+    const quotedLambdas = (0, parser_1.astFindAll)(ast, (n) => {
+        if (!(0, parser_1.astIsList)(n, 'quote'))
+            return false;
+        if (!n.children || n.children.length < 2)
+            return false;
+        return (0, parser_1.astIsList)(n.children[1], 'lambda');
+    });
+    for (const node of quotedLambdas) {
+        const parent = node.parent;
+        if (!parent || !parent.children)
+            continue;
+        const parentHead = parent.children[0];
+        const parentName = (parentHead.type === 'symbol' && parentHead.name) || '';
+        if (HIGHER_ORDER_FUNCS.has(parentName)) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'quote_vs_function',
+                message: (0, locale_1.t)('quote_vs_function', parentName),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=quote-vs-function.js.map

package/dist/checks/recursive-call.d.ts

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