@atlisp/lint 0.1.5 → 0.1.6

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

package/dist/checks/error-handling.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkErrorHandling = checkErrorHandling;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkErrorHandling(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    let inDefun = false;
+    let defunName = '';
+    let defunStart = 0;
+    let defunText = '';
+    let hasErrorHandler = false;
+    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;
+                defunText = '';
+                hasErrorHandler = false;
+            }
+        }
+        if (inDefun) {
+            defunText += stripped + '\n';
+            if (stripped.includes('*error*'))
+                hasErrorHandler = true;
+            // Check for depth returning to 0 (end of defun)
+            let depth = 0;
+            for (const ch of stripped) {
+                if (ch === '(')
+                    depth++;
+                else if (ch === ')')
+                    depth--;
+            }
+            if (depth === 0 && defunText.trim().length > 0 && defunName) {
+                // End of defun - check if it uses command but no *error*
+                if (/\(command\b/.test(defunText) && !hasErrorHandler && !defunName.startsWith('c:')) {
+                    issues.push({
+                        file,
+                        line: defunStart,
+                        severity: 'warn',
+                        rule: 'error_handling',
+                        message: (0, locale_1.t)('error_handling', defunName),
+                    });
+                }
+                inDefun = false;
+                defunName = '';
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=error-handling.js.map

package/dist/checks/extra-parens.d.ts

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

package/dist/checks/extra-parens.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExtraParens = checkExtraParens;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkExtraParens(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    let runningDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const closeOnly = stripped.trim();
+        // Empty line resets nothing; just continue tracking depth
+        if (!closeOnly)
+            continue;
+        // Count parens on this line
+        let lineOpen = 0, lineClose = 0;
+        for (const ch of stripped) {
+            if (ch === '(')
+                lineOpen++;
+            else if (ch === ')')
+                lineClose++;
+        }
+        // Check if this line is pure closing parens
+        if (/^\)+$/.test(closeOnly)) {
+            // Only flag if these closing parens exceed the running depth
+            // (i.e., they are unmatched / extra)
+            if (lineClose > runningDepth + lineOpen) {
+                const extra = lineClose - runningDepth - lineOpen;
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'extra_parens',
+                    message: (0, locale_1.t)('extra_parens', extra),
+                });
+            }
+        }
+        runningDepth += lineOpen - lineClose;
+        if (runningDepth < 0)
+            runningDepth = 0;
+    }
+    return issues;
+}
+//# sourceMappingURL=extra-parens.js.map

package/dist/checks/function-complexity.js

@@ -41,7 +41,7 @@ function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {
         }
     }
     // Check lambda forms: (lambda (args) body...)
-    const lambdas = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'lambda'));
+    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;

package/dist/checks/function-order.d.ts

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

package/dist/checks/function-order.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFunctionOrder = checkFunctionOrder;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkFunctionOrder(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const defined = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const defunM = stripped.match(/\(defun\s+(\S+)/);
+        if (defunM) {
+            const name = defunM[1];
+            if (name.includes('/') || name.startsWith('c:'))
+                continue;
+            defined.add(name);
+            continue;
+        }
+        const callM = stripped.match(/\((\S+)\s+/);
+        if (callM) {
+            const name = callM[1];
+            if (name.startsWith('(') || name === 'defun' || name.startsWith('@') || /^[a-z]+:/.test(name))
+                continue;
+            if (!defined.has(name) && name.length > 1 && /^[a-z]/.test(name)) {
+                defined.add(name);
+                issues.push({ file, line: i + 1, severity: 'warn', rule: 'function_order', message: (0, locale_1.t)('function_order', name) });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=function-order.js.map

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

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