@atlisp/lint 0.2.16 → 0.2.18

package/README.md

@@ -120,7 +120,7 @@ npx @atlisp/lint --format-check
 | `lambda_syntax` | warn | 风格 | (function (lambda ...)) 建议缩写 |
 | `comment_style` | warn | 风格 | ; 后缺少空格 |
 | `empty_catch` | warn | 最佳实践 | vl-catch-all-apply 未检查结果 |
-| `nth_usage` | warn | 风格 | (nth 0 ...) 建议 car |
+| `nth_usage` | info | 风格 | (nth 0 ...) 建议 car |
 | `append_single` | warn | 风格 | (append (list ...)) 建议 cons |
 | `mixed_indent` | warn | 风格 | 缩进混用 tab 和空格 |
 | `long_function_call` | off | 风格 | 单行参数过多 |

package/atlisp-lint.default.json

@@ -67,7 +67,7 @@
     "lambda_syntax": "off",
     "comment_style": "warn",
     "empty_catch": "info",
-    "nth_usage": "warn",
+    "nth_usage": "info",
     "append_single": "warn",
     "setq_multiple": "warn",
     "format_indent": "off",

package/dist/checks/arg-count.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
-export declare function checkArgCount(content: string, file: string): Issue[];
+import { AstNode } from '@atlisp/parser';
+export declare function checkArgCount(content: string, file: string, ast?: AstNode): Issue[];
 //# sourceMappingURL=arg-count.d.ts.map

package/dist/checks/arg-count.js

@@ -3,52 +3,70 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkArgCount = checkArgCount;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
-function isInQuoteOrFunction(node) {
-    let cur = node.parent;
-    while (cur) {
-        if (cur.children?.[0]?.type === 'symbol' &&
-            (cur.children[0].name === 'quote' || cur.children[0].name === 'function')) {
-            return true;
+const shared_1 = require("../visitors/shared");
+function buildCallIndex(ast) {
+    const index = new Map();
+    function walk(node) {
+        if ((0, parser_1.astIsList)(node) && node.children.length > 0 && (0, parser_1.astIsSymbol)(node.children[0])) {
+            const name = node.children[0].name;
+            if (name && name !== 'defun' && name !== 'defun-q') {
+                let list = index.get(name);
+                if (!list) {
+                    list = [];
+                    index.set(name, list);
+                }
+                list.push(node);
+            }
+        }
+        if ((0, parser_1.astIsList)(node)) {
+            for (const c of node.children)
+                walk(c);
         }
-        cur = cur.parent;
     }
-    return false;
+    walk(ast);
+    return index;
 }
-function checkArgCount(content, file) {
+function checkArgCount(content, file, ast) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    if (!ast)
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    const callIndex = buildCallIndex(ast);
     for (const defun of defuns) {
-        if (!defun.children || defun.children.length < 3)
+        if (!(0, parser_1.astIsList)(defun))
+            continue;
+        if (defun.children.length < 3)
             continue;
         const nameNode = defun.children[1];
-        if (nameNode.type !== 'symbol' || !nameNode.name)
+        if (!(0, parser_1.astIsSymbol)(nameNode) || !nameNode.name)
             continue;
         const funcName = nameNode.name;
         // Skip C: commands and local functions
         if (funcName.startsWith('c:') || funcName.startsWith('C:') || funcName.includes('/'))
             continue;
         const paramList = defun.children[2];
-        if (paramList.type !== 'list' || !paramList.children)
+        if (!(0, parser_1.astIsList)(paramList))
             continue;
         // Count params before /
         let paramCount = 0;
         for (const p of paramList.children) {
-            if (p.type === 'symbol' && p.name === '/')
+            if ((0, parser_1.astIsSymbol)(p) && p.name === '/')
                 break;
-            if (p.type === 'symbol' && p.name && p.name !== 'T' && p.name !== 'nil') {
+            if ((0, parser_1.astIsSymbol)(p) && p.name && p.name !== 'T' && p.name !== 'nil') {
                 paramCount++;
             }
         }
         if (paramCount === 0)
             continue;
-        // Find all calls to this function
-        const calls = (0, parser_1.astFindListWithHead)(ast, funcName);
+        // Find all calls to this function via pre-built index
+        const calls = callIndex.get(funcName);
+        if (!calls)
+            continue;
         for (const call of calls) {
-            if (!call.children || call.children.length === 0)
+            if (!(0, parser_1.astIsList)(call) || call.children.length === 0)
                 continue;
             // Skip calls inside quoted or function forms
-            if (isInQuoteOrFunction(call))
+            if ((0, shared_1.isInQuote)(call))
                 continue;
             const argCount = call.children.length - 1;
             if (argCount !== paramCount) {

package/dist/checks/builtin-arg-count.d.ts

@@ -1,4 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare const BUILTIN_FUNCTIONS: Set<string>;
-export declare function checkBuiltinArgCount(content: string, file: string): Issue[];
+export declare function checkBuiltinArgCount(content: string, file: string, ast?: AstNode): Issue[];
 //# sourceMappingURL=builtin-arg-count.d.ts.map

package/dist/checks/builtin-arg-count.js

@@ -239,9 +239,10 @@ const BUILTIN_ARITY = {
 for (const key of Object.keys(BUILTIN_ARITY)) {
     exports.BUILTIN_FUNCTIONS.add(key);
 }
-function checkBuiltinArgCount(content, file) {
+function checkBuiltinArgCount(content, file, ast) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    if (!ast)
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     for (const node of (0, parser_1.astChildren)(ast)) {
         checkNode(node, content, file, issues);
     }

package/dist/checks/cond-duplicate.js

@@ -5,15 +5,14 @@ exports.checkCondDuplicateAst = checkCondDuplicateAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function condKey(node) {
-    if (node.type === 'symbol' || node.type === 'keyword')
+    if ((0, parser_1.astIsSymbol)(node) || node.type === 'keyword')
         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(',')})`;
+    if ((0, parser_1.astIsList)(node)) {
+        return `list(${node.children.map(condKey).join(',')})`;
     }
     return '';
 }
@@ -25,12 +24,12 @@ 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)
+        if (!(0, parser_1.astIsList)(node))
             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)
+            if (!(0, parser_1.astIsList)(clause) || clause.children.length < 1)
                 continue;
             const condition = clause.children[0];
             const key = condKey(condition);

package/dist/checks/constant-condition.js

@@ -16,10 +16,10 @@ function checkConstantConditionAst(ast, file) {
     for (const form of CONDITION_FORMS) {
         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)
+            if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
                 continue;
             const cond = node.children[1];
-            if (cond.type === 'symbol' && cond.name && CONSTANTS.has(cond.name)) {
+            if ((0, parser_1.astIsSymbol)(cond) && cond.name && CONSTANTS.has(cond.name)) {
                 issues.push({
                     file,
                     line: cond.pos.line,
@@ -33,14 +33,14 @@ function checkConstantConditionAst(ast, file) {
     // Check (cond (T ...))
     const condNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'cond'));
     for (const condNode of condNodes) {
-        if (!condNode.children)
+        if (!(0, parser_1.astIsList)(condNode))
             continue;
         for (let i = 1; i < condNode.children.length; i++) {
             const clause = condNode.children[i];
-            if (clause.type !== 'list' || !clause.children || clause.children.length === 0)
+            if (!(0, parser_1.astIsList)(clause) || clause.children.length === 0)
                 continue;
             const condTest = clause.children[0];
-            if (condTest.type === 'symbol' && condTest.name && CONSTANTS.has(condTest.name)) {
+            if ((0, parser_1.astIsSymbol)(condTest) && condTest.name && CONSTANTS.has(condTest.name)) {
                 // Skip last clause with T (only when there are multiple clauses — else/default pattern)
                 if (condTest.name === 'T' && i === condNode.children.length - 1 && i > 1)
                     continue;
@@ -57,10 +57,10 @@ 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'));
     for (const node of orNodes) {
-        if (!node.children || node.children.length < 2)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
             continue;
         const first = node.children[1];
-        if (first.type === 'symbol' && first.name === 'T') {
+        if ((0, parser_1.astIsSymbol)(first) && first.name === 'T') {
             issues.push({
                 file,
                 line: first.pos.line,
@@ -73,10 +73,10 @@ 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'));
     for (const node of andNodes) {
-        if (!node.children || node.children.length < 2)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
             continue;
         const first = node.children[1];
-        if (first.type === 'symbol' && first.name === 'nil') {
+        if ((0, parser_1.astIsSymbol)(first) && first.name === 'nil') {
             issues.push({
                 file,
                 line: first.pos.line,

package/dist/checks/dangerous-calls.js

@@ -52,7 +52,7 @@ function checkDangerousCallsAst(ast, file, config) {
             for (const call of commandCalls) {
                 if (isInQuote(call))
                     continue;
-                if (!call.children || call.children.length < 2)
+                if (!(0, parser_1.astIsList)(call) || call.children.length < 2)
                     continue;
                 const firstArg = call.children[1];
                 if (firstArg.type === 'string' && firstArg.value === 'shell') {

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

@@ -1,11 +1,4 @@
 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[];
 export declare function checkDanglingDefunFromDefs(localDefuns: {
     name: string;
     line: number;

package/dist/checks/dangling-defun.js

@@ -1,70 +1,7 @@
 "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.checkDanglingDefun = checkDanglingDefun;
 exports.checkDanglingDefunFromDefs = checkDanglingDefunFromDefs;
 const locale_1 = require("../locale");
-const parser_1 = require("@atlisp/parser");
-const fs = __importStar(require("fs"));
-function checkDanglingDefun(file, allDefuns, allReferences) {
-    const issues = [];
-    const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
-    const localDefuns = [];
-    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({ name: node.children[1].name, line: node.pos.line });
-        }
-    }
-    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: defun.line,
-                severity: 'warn',
-                rule: 'dangling_defun',
-                message: (0, locale_1.t)('dangling_defun', defun.name),
-            });
-        }
-    }
-    return issues;
-}
 function checkDanglingDefunFromDefs(localDefuns, allReferences, file) {
     const issues = [];
     for (const defun of localDefuns) {

package/dist/checks/double-not.js

@@ -12,7 +12,7 @@ function checkDoubleNotAst(ast, file) {
     const issues = [];
     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)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
             continue;
         const arg = node.children[1];
         if (!(0, parser_1.astIsList)(arg, 'not'))

package/dist/checks/empty-branch.js

@@ -15,7 +15,7 @@ function checkEmptyBranchAst(ast, file) {
     for (const form of BRANCH_FORMS) {
         const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, form));
         for (const node of nodes) {
-            if (!node.children)
+            if (!(0, parser_1.astIsList)(node))
                 continue;
             // (if cond) — no then or else, only 2 items (form + cond)
             if (node.children.length < 3) {

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

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

package/dist/checks/empty-catch.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkEmptyCatch = checkEmptyCatch;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
-function checkEmptyCatch(content, file) {
+function checkEmptyCatch(content, file, ast) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    if (!ast)
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     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))
@@ -49,25 +50,25 @@ function isSetqStored(node) {
     const parent = node.parent;
     if (!parent || !(0, parser_1.astIsList)(parent, 'setq'))
         return false;
-    if (!parent.children || parent.children.length < 3)
+    if (parent.children.length < 3)
         return false;
     const idx = parent.children.indexOf(node);
     return idx >= 2 && idx % 2 === 0;
 }
 function getSetqVarName(node) {
     const parent = node.parent;
-    if (!parent || !parent.children)
+    if (!parent || !(0, parser_1.astIsList)(parent))
         return null;
     const idx = parent.children.indexOf(node);
     const varNode = parent.children[idx - 1];
-    if (varNode && varNode.type === 'symbol' && varNode.name) {
+    if (varNode && (0, parser_1.astIsSymbol)(varNode) && varNode.name) {
         return varNode.name;
     }
     return null;
 }
 function hasErrorCheckInSiblings(node, varName) {
     const parent = node.parent;
-    if (!parent || !parent.children)
+    if (!parent || !(0, parser_1.astIsList)(parent))
         return false;
     const idx = parent.children.indexOf(node);
     for (let i = idx + 1; i < parent.children.length; i++) {
@@ -76,7 +77,7 @@ function hasErrorCheckInSiblings(node, varName) {
     }
     if ((0, parser_1.astIsList)(parent, 'setq')) {
         const grandparent = parent.parent;
-        if (grandparent && grandparent.children) {
+        if (grandparent && (0, parser_1.astIsList)(grandparent)) {
             const parentIdx = grandparent.children.indexOf(parent);
             for (let i = parentIdx + 1; i < grandparent.children.length; i++) {
                 if (containsErrorCheck(grandparent.children[i], varName))

package/dist/checks/function-complexity.js

@@ -4,6 +4,7 @@ exports.checkFunctionComplexity = checkFunctionComplexity;
 exports.checkFunctionComplexityAst = checkFunctionComplexityAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
+const shared_1 = require("../visitors/shared");
 function checkFunctionComplexity(content, file, maxLines, maxNesting) {
     const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkFunctionComplexityAst(ast, file, maxLines, maxNesting);
@@ -13,12 +14,12 @@ function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {
     // Check defun forms
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
     for (const defun of defuns) {
-        if (!defun.children || !defun.end)
+        if (!(0, parser_1.astIsList)(defun) || !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 name = (0, parser_1.astIsSymbol)(nameNode) && 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) {
@@ -43,10 +44,10 @@ 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'));
     for (const lam of lambdas) {
-        if (!lam.children || !lam.end)
+        if (!(0, parser_1.astIsList)(lam) || !lam.end)
             continue;
         // Skip quoted lambdas: (quote (lambda ...)) — data, not code
-        if (isInsideQuote(lam))
+        if ((0, shared_1.isInQuote)(lam, false))
             continue;
         const bodyLines = (lam.end ? lam.end.line : lam.pos.line) - lam.pos.line + 1;
         const depth = computeNestingDepth(lam, 1);
@@ -71,20 +72,6 @@ function checkFunctionComplexityAst(ast, file, maxLines, 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;

package/dist/checks/global-naming.js

@@ -28,7 +28,7 @@ function checkGlobalNaming(content, file) {
     const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
     for (const form of setqForms) {
-        if (!form.children || form.children.length < 2)
+        if (!(0, parser_1.astIsList)(form) || form.children.length < 2)
             continue;
         // Skip setq inside defun/lambda/let — those are local
         if (isInsideLocalScope(form))

package/dist/checks/identical-branches.js

@@ -14,8 +14,8 @@ function astEqual(a, b) {
     if (a.type === 'string')
         return a.value === b.value;
     if (a.type === 'list') {
-        const aChildren = a.children || [];
-        const bChildren = b.children || [];
+        const aChildren = a.children;
+        const bChildren = b.children;
         if (aChildren.length !== bChildren.length)
             return false;
         for (let i = 0; i < aChildren.length; i++) {
@@ -35,7 +35,7 @@ function checkIdenticalBranchesAst(ast, file) {
     // Check if statements: (if cond then-branch else-branch)
     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)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 4)
             continue;
         const thenBranch = node.children[2];
         const elseBranch = node.children[3];

package/dist/checks/if-without-else.js

@@ -7,7 +7,7 @@ function checkIfWithoutElse(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 < 3)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 3)
             continue;
         if (node.children.length === 3) {
             const parent = node.parent;

package/dist/checks/misplaced-else.js

@@ -12,12 +12,12 @@ 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)
+        if (!(0, parser_1.astIsList)(node) || 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;
+        const innerName = cond.children[1] && (0, parser_1.astIsSymbol)(cond.children[1]) ? cond.children[1].name : '';
         issues.push({
             file,
             line: node.pos.line,

package/dist/checks/missing-export.js

@@ -48,13 +48,13 @@ function checkMissingExport(file, pkgDir, _allDefuns) {
     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)
+        if (!(0, parser_1.astIsList)(node))
             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) {
+                if ((0, parser_1.astIsList)(val)) {
                     for (const item of val.children) {
                         if ((0, parser_1.astIsSymbol)(item)) {
                             registered.add(item.name);
@@ -71,7 +71,7 @@ function checkMissingExport(file, pkgDir, _allDefuns) {
     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)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
             continue;
         const nameNode = node.children[1];
         if (!(0, parser_1.astIsSymbol)(nameNode))

package/dist/checks/missing-princ.js

@@ -14,7 +14,7 @@ function checkMissingPrinc(content, file) {
     }
     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 < 3)
+        if (!(0, parser_1.astIsList)(node) || node.children.length < 3)
             continue;
         const nameNode = node.children[1];
         if (!(0, parser_1.astIsSymbol)(nameNode))

package/dist/checks/multiple-setq.js

@@ -18,7 +18,7 @@ function checkMultipleSetqAst(ast, file) {
             parents.add(n.parent);
     }
     for (const parent of parents) {
-        if (!parent.children)
+        if (!(0, parser_1.astIsList)(parent))
             continue;
         let prevWasSetq = false;
         let prevSetqNode = null;

package/dist/checks/no-return.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
-export declare function checkNoReturn(content: string, file: string): Issue[];
+import { AstNode } from '@atlisp/parser';
+export declare function checkNoReturn(content: string, file: string, ast?: AstNode): Issue[];
 //# sourceMappingURL=no-return.d.ts.map

package/dist/checks/no-return.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkNoReturn = checkNoReturn;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
-function checkNoReturn(content, file) {
+function checkNoReturn(content, file, ast) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    if (!ast)
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
     for (const defun of defuns) {
-        if (!defun.children || defun.children.length < 3)
+        if (!(0, parser_1.astIsList)(defun) || defun.children.length < 3)
             continue;
         const nameNode = defun.children[1];
         if (nameNode.type !== 'symbol' || !nameNode.name)

package/dist/checks/nth-usage.js

@@ -18,7 +18,7 @@ function checkNthUsage(content, file) {
         const stripped = (0, utils_1.stripLine)(lines[i]);
         const m = stripped.match(NTH_RE);
         if (m && REPLACEMENTS[m[1]]) {
-            issues.push({ file, line: i + 1, severity: 'warn', rule: 'nth_usage', message: (0, locale_1.t)('nth_usage') });
+            issues.push({ file, line: i + 1, severity: 'info', rule: 'nth_usage', message: (0, locale_1.t)('nth_usage') });
         }
     }
     return issues;

package/dist/checks/parameter-naming.js

@@ -12,13 +12,13 @@ function checkParameterNamingAst(ast, file) {
     const issues = [];
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
     for (const defun of defuns) {
-        if (!defun.children || defun.children.length < 3)
+        if (!(0, parser_1.astIsList)(defun) || 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)
+        if (!(0, parser_1.astIsList)(paramList))
             continue;
         for (const p of paramList.children) {
             if (p.type !== 'symbol' || !p.name)

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

@@ -31,7 +31,7 @@ function checkQuoteVsFunctionAst(ast, file) {
     });
     for (const node of quotedLambdas) {
         const parent = node.parent;
-        if (!parent || !parent.children)
+        if (!parent || !(0, parser_1.astIsList)(parent))
             continue;
         const parentHead = parent.children[0];
         const parentName = (parentHead.type === 'symbol' && parentHead.name) || '';

package/dist/checks/recursive-call.js

@@ -14,7 +14,7 @@ function checkRecursiveCallAst(ast, file) {
     const issues = [];
     const defuns = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun'));
     for (const defun of defuns) {
-        if (!defun.children || defun.children.length < 3)
+        if (!(0, parser_1.astIsList)(defun) || defun.children.length < 3)
             continue;
         const nameNode = defun.children[1];
         const funcName = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '';