@atlisp/lint 0.1.23 → 0.1.25

package/atlisp-lint.default.json

@@ -57,7 +57,8 @@
     "error_handling": "warn",
     "global_naming": "warn",
     "extra_parens": "warn",
-    "arg_count": "warn",
+    "arg_count": "error",
+    "builtin_arg_count": "error",
     "strcat_usage": "warn",
     "cond_simplify": "warn",
     "quote_style": "warn",

package/dist/atlisp-lint.default.json

@@ -0,0 +1,90 @@
+{
+  "locale": "zh",
+  "source": {
+    "globs": ["**/*.lsp"],
+    "exclude": ["**/node_modules/**", "**/vendor/**", "**/.git/**"]
+  },
+  "checks": {
+    "parens": "error",
+    "encoding": "warn",
+    "cl_syntax": "warn",
+    "quit_exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn",
+    "vlax_without_loading": "off",
+    "token_in_url": "warn",
+    "open_without_close": "warn",
+    "bare_function_names": "off",
+    "line_length": "warn",
+    "function_complexity": "warn",
+    "parameter_naming": "warn",
+    "unused_variable": "warn",
+    "missing_doc": "warn",
+    "error_handling": "warn",
+    "global_naming": "warn",
+    "extra_parens": "warn",
+    "arg_count": "warn",
+    "strcat_usage": "warn",
+    "cond_simplify": "warn",
+    "redundant_progn": "warn",
+    "quote_style": "warn",
+    "eq_usage": "warn",
+    "lambda_syntax": "warn",
+    "comment_style": "warn",
+    "empty_catch": "warn",
+    "nth_usage": "warn",
+    "append_single": "warn",
+    "setq_multiple": "warn",
+    "function_order": "off",
+    "magic_number": "off",
+    "mixed_indent": "warn",
+    "long_function_call": "warn",
+    "no_return": "warn",
+    "shadow_builtin": "warn",
+    "dynamic_doc": "warn",
+    "loop_optimization": "off",
+    "type_check": "off",
+    "redundant_if": "warn",
+    "trailing_whitespace": "warn",
+    "module_registration": "off",
+    "namespace_header": "off"
+  },
+  "line_length": {
+    "max": 100,
+    "tab_width": 2
+  },
+  "function_complexity": {
+    "max_lines": 60,
+    "max_nesting": 6
+  },
+  "cl_syntax": {
+    "keywords": ["&key"]
+  },
+  "dangerous_calls": {
+    "quit": "error",
+    "exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn"
+  },
+  "module_registration": {
+    "severity": "off",
+    "patterns": [],
+    "dirs": ["modules"]
+  },
+  "namespace_header": {
+    "severity": "off",
+    "package": "",
+    "deps": [],
+    "search_lines": 15
+  },
+  "bare_function_names": {
+    "allowlist": ["T", "nil"],
+    "namespace_pattern": "^[a-z]+:"
+  },
+  "sbcl": {
+    "walk_exclude": [".vscode", "vendor", ".git"],
+    "defmacro_allow_files": ["compat-cl"]
+  }
+}

package/dist/checks/arg-count.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkArgCount(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const 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)

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

@@ -5,7 +5,7 @@ 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);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkAssocWithoutCdrAst(ast, file);
 }
 function checkAssocWithoutCdrAst(ast, file) {

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

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

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

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBuiltinArgCount = checkBuiltinArgCount;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const BUILTIN_ARITY = {
+    // === Special forms & control flow ===
+    if: { min: 2, max: 3 },
+    progn: { min: 0, max: -1 },
+    cond: { min: 0, max: -1 },
+    while: { min: 1, max: -1 },
+    repeat: { min: 1, max: -1 },
+    foreach: { min: 2, max: -1 },
+    'vlax-for': { min: 2, max: -1 },
+    setq: { min: 2, max: -1 },
+    set: { min: 2, max: 2 },
+    lambda: { min: 1, max: -1 },
+    defun: { min: 3, max: -1 },
+    'defun-q': { min: 3, max: -1 },
+    and: { min: 0, max: -1 },
+    or: { min: 0, max: -1 },
+    not: { min: 1, max: 1 },
+    null: { min: 1, max: 1 },
+    quote: { min: 1, max: 1 },
+    function: { min: 1, max: 1 },
+    eval: { min: 1, max: 1 },
+    apply: { min: 2, max: -1 },
+    mapcar: { min: 2, max: -1 },
+    // === Predicates ===
+    atom: { min: 1, max: 1 },
+    boundp: { min: 1, max: 1 },
+    type: { min: 1, max: 1 },
+    numberp: { min: 1, max: 1 },
+    zerop: { min: 1, max: 1 },
+    minusp: { min: 1, max: 1 },
+    plusp: { min: 1, max: 1 },
+    eq: { min: 2, max: 2 },
+    equal: { min: 2, max: 2 },
+    '=': { min: 2, max: -1 },
+    '/=': { min: 2, max: -1 },
+    '<': { min: 2, max: -1 },
+    '<=': { min: 2, max: -1 },
+    '>': { min: 2, max: -1 },
+    '>=': { min: 2, max: -1 },
+    wcmatch: { min: 2, max: 2 },
+    member: { min: 2, max: 2 },
+    assoc: { min: 2, max: 3 },
+    // === List/cons operations ===
+    car: { min: 1, max: 1 },
+    cdr: { min: 1, max: 1 },
+    caar: { min: 1, max: 1 },
+    cadr: { min: 1, max: 1 },
+    cdar: { min: 1, max: 1 },
+    cddr: { min: 1, max: 1 },
+    caaar: { min: 1, max: 1 },
+    caadr: { min: 1, max: 1 },
+    cadar: { min: 1, max: 1 },
+    caddr: { min: 1, max: 1 },
+    cdaar: { min: 1, max: 1 },
+    cdadr: { min: 1, max: 1 },
+    cddar: { min: 1, max: 1 },
+    cdddr: { min: 1, max: 1 },
+    cons: { min: 2, max: 2 },
+    list: { min: 0, max: -1 },
+    append: { min: 0, max: -1 },
+    reverse: { min: 1, max: 1 },
+    length: { min: 1, max: 1 },
+    subst: { min: 3, max: 3 },
+    'vl-remove': { min: 2, max: 2 },
+    // === Arithmetic ===
+    '+': { min: 0, max: -1 },
+    '-': { min: 1, max: -1 },
+    '*': { min: 0, max: -1 },
+    '/': { min: 1, max: -1 },
+    '1+': { min: 1, max: 1 },
+    '1-': { min: 1, max: 1 },
+    abs: { min: 1, max: 1 },
+    fix: { min: 1, max: 1 },
+    float: { min: 1, max: 1 },
+    max: { min: 1, max: -1 },
+    min: { min: 1, max: -1 },
+    gcd: { min: 2, max: 2 },
+    rem: { min: 2, max: 2 },
+    logand: { min: 0, max: -1 },
+    logior: { min: 0, max: -1 },
+    logxor: { min: 0, max: -1 },
+    lsh: { min: 2, max: 2 },
+    boole: { min: 3, max: 3 },
+    exp: { min: 1, max: 1 },
+    expt: { min: 2, max: 2 },
+    log: { min: 1, max: 2 },
+    sqrt: { min: 1, max: 1 },
+    sin: { min: 1, max: 1 },
+    cos: { min: 1, max: 1 },
+    tan: { min: 1, max: 1 },
+    atan: { min: 1, max: 2 },
+    atof: { min: 1, max: 1 },
+    atoi: { min: 1, max: 1 },
+    itoa: { min: 1, max: 1 },
+    rtos: { min: 1, max: 3 },
+    distof: { min: 2, max: 2 },
+    cvunit: { min: 2, max: 2 },
+    // === String ===
+    strcat: { min: 0, max: -1 },
+    strlen: { min: 1, max: 1 },
+    substr: { min: 2, max: 3 },
+    strcase: { min: 1, max: 2 },
+    'vl-string->list': { min: 1, max: 1 },
+    'vl-string-search': { min: 2, max: 3 },
+    'vl-string-subst': { min: 3, max: 4 },
+    // === File I/O ===
+    open: { min: 2, max: 3 },
+    close: { min: 1, max: 1 },
+    'read-line': { min: 0, max: 1 },
+    'read-char': { min: 0, max: 1 },
+    'write-line': { min: 1, max: 2 },
+    'write-char': { min: 1, max: 2 },
+    'read': { min: 0, max: 1 },
+    princ: { min: 0, max: 2 },
+    prin1: { min: 0, max: 2 },
+    print: { min: 0, max: 2 },
+    terpri: { min: 0, max: 0 },
+    prompt: { min: 1, max: 1 },
+    getstring: { min: 0, max: 2 },
+    getint: { min: 0, max: 2 },
+    getreal: { min: 0, max: 2 },
+    getpoint: { min: 0, max: 3 },
+    getcorner: { min: 1, max: 3 },
+    getdist: { min: 0, max: 3 },
+    getangle: { min: 0, max: 3 },
+    getorient: { min: 0, max: 3 },
+    getkword: { min: 0, max: 2 },
+    initget: { min: 1, max: 2 },
+    'load': { min: 1, max: 2 },
+    autoload: { min: 2, max: 2 },
+    // === System ===
+    getvar: { min: 1, max: 1 },
+    setvar: { min: 2, max: 2 },
+    command: { min: 0, max: -1 },
+    'vl-cmdf': { min: 0, max: -1 },
+    gc: { min: 0, max: 0 },
+    ver: { min: 0, max: 0 },
+    exit: { min: 0, max: 0 },
+    quit: { min: 0, max: 0 },
+    findfile: { min: 1, max: 1 },
+    getfiled: { min: 3, max: 4 },
+    // === Entity/selection ===
+    entget: { min: 1, max: 2 },
+    entmod: { min: 1, max: 1 },
+    entmake: { min: 0, max: 1 },
+    entmakex: { min: 0, max: 1 },
+    entdel: { min: 1, max: 1 },
+    entsel: { min: 0, max: 2 },
+    nentsel: { min: 0, max: 2 },
+    entlast: { min: 0, max: 0 },
+    entnext: { min: 0, max: 1 },
+    handent: { min: 1, max: 1 },
+    entupd: { min: 1, max: 1 },
+    'ssget': { min: 0, max: -1 },
+    ssadd: { min: 0, max: 2 },
+    ssdel: { min: 2, max: 2 },
+    sslength: { min: 1, max: 1 },
+    ssname: { min: 2, max: 2 },
+    ssnamex: { min: 1, max: 2 },
+    sssetfirst: { min: 1, max: 2 },
+    // === Geometry ===
+    polar: { min: 3, max: 3 },
+    angle: { min: 2, max: 2 },
+    distance: { min: 2, max: 2 },
+    inters: { min: 4, max: 5 },
+    textbox: { min: 1, max: 1 },
+    trans: { min: 3, max: 4 },
+    // === Table/dictionary ===
+    tblobjname: { min: 2, max: 2 },
+    tblnext: { min: 2, max: 2 },
+    tblsearch: { min: 2, max: 3 },
+    acad_colordlg: { min: 1, max: 3 },
+    // === ActiveX ===
+    'vlax-invoke-method': { min: 2, max: -1 },
+    'vlax-get-property': { min: 2, max: 2 },
+    'vlax-put-property': { min: 3, max: 3 },
+    'vlax-get-or-create-object': { min: 1, max: 2 },
+    'vlax-create-object': { min: 1, max: 1 },
+    'vlax-get-object': { min: 1, max: 1 },
+    'vlax-release-object': { min: 1, max: 1 },
+    'vlax-safearray->list': { min: 1, max: 1 },
+    'vlax-safearray-fill': { min: 2, max: 2 },
+    'vlax-safearray-put-element': { min: 2, max: -1 },
+    'vlax-safearray-get-dim': { min: 1, max: 1 },
+    'vlax-safearray-get-element': { min: 2, max: -1 },
+    'vlax-make-safearray': { min: 2, max: 3 },
+    'vlax-ename->vla-object': { min: 1, max: 1 },
+    'vlax-vla-object->ename': { min: 1, max: 1 },
+    'vlax-tmatrix': { min: 1, max: 1 },
+    'vlax-curve-getarea': { min: 1, max: 1 },
+    'vlax-curve-getdistatparam': { min: 2, max: 2 },
+    'vlax-curve-getdistatpoint': { min: 2, max: 2 },
+    'vlax-curve-getendparam': { min: 1, max: 1 },
+    'vlax-curve-getendpoint': { min: 1, max: 1 },
+    'vlax-curve-getparamatdist': { min: 2, max: 2 },
+    'vlax-curve-getparamatpoint': { min: 2, max: 2 },
+    'vlax-curve-getpointatdist': { min: 2, max: 2 },
+    'vlax-curve-getpointatparam': { min: 2, max: 2 },
+    'vlax-curve-getstartparam': { min: 1, max: 1 },
+    'vlax-curve-getstartpoint': { min: 1, max: 1 },
+    'vlax-curve-isclosed': { min: 1, max: 1 },
+    'vlax-curve-getclosestpointto': { min: 2, max: 3 },
+    'vl-catch-all-apply': { min: 1, max: -1 },
+    'vl-catch-all-error-message': { min: 1, max: 1 },
+    'vlax-read-enabled-p': { min: 1, max: 1 },
+    'vlax-write-enabled-p': { min: 1, max: 1 },
+    'vlax-erased-p': { min: 1, max: 1 },
+    'vlax-object-released-p': { min: 1, max: 1 },
+    'vlax-ldata-get': { min: 2, max: 3 },
+    'vlax-ldata-put': { min: 3, max: 3 },
+    'vlax-ldata-delete': { min: 2, max: 3 },
+    'vlax-ldata-list': { min: 1, max: 2 },
+    'vlax-dump-object': { min: 1, max: 2 },
+    'vl-propagate': { min: 1, max: 1 },
+    'vl-exit-with-error': { min: 1, max: 1 },
+    'vl-exit-with-value': { min: 1, max: 1 },
+    'vl-position': { min: 2, max: 2 },
+    // === Symbol/function management ===
+    'atoms-family': { min: 1, max: 2 },
+    'vl-acad-defun': { min: 1, max: 1 },
+    'vl-acad-undefun': { min: 1, max: 1 },
+    'vl-symbol-name': { min: 1, max: 1 },
+    'vl-symbol-value': { min: 1, max: 1 },
+    'vl-bb-ref': { min: 1, max: 1 },
+    'vl-bb-set': { min: 2, max: 2 },
+    // === DOSLib / common plugins ===
+    dos_gettext: { min: 0, max: -1 },
+    // === Misc ===
+    trace: { min: 1, max: 1 },
+    untrace: { min: 1, max: 1 },
+};
+function checkBuiltinArgCount(content, file) {
+    const issues = [];
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    for (const node of (0, parser_1.astChildren)(ast)) {
+        checkNode(node, content, file, issues);
+    }
+    return issues;
+}
+function checkNode(node, content, file, issues) {
+    if (node.type !== 'list' || !node.children || node.children.length < 1)
+        return;
+    const head = node.children[0];
+    if (head.type !== 'symbol' || !head.name) {
+        for (const child of node.children) {
+            checkNode(child, content, file, issues);
+        }
+        return;
+    }
+    const funcName = head.name.toLowerCase();
+    const arity = BUILTIN_ARITY[funcName];
+    if (arity) {
+        const argCount = node.children.length - 1;
+        if (argCount < arity.min) {
+            issues.push({
+                file,
+                line: head.pos.line,
+                severity: 'warn',
+                rule: 'builtin_arg_count',
+                message: (0, locale_1.t)('builtin_arg_count.too_few', funcName, argCount, arity.min),
+            });
+        }
+        else if (arity.max !== -1 && argCount > arity.max) {
+            issues.push({
+                file,
+                line: head.pos.line,
+                severity: 'warn',
+                rule: 'builtin_arg_count',
+                message: (0, locale_1.t)('builtin_arg_count.too_many', funcName, argCount, arity.max),
+            });
+        }
+    }
+    for (const child of node.children) {
+        checkNode(child, content, file, issues);
+    }
+}
+//# sourceMappingURL=builtin-arg-count.js.map

package/dist/checks/cond-duplicate.js

@@ -18,7 +18,7 @@ function condKey(node) {
     return '';
 }
 function checkCondDuplicate(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkCondDuplicateAst(ast, file);
 }
 function checkCondDuplicateAst(ast, file) {

package/dist/checks/constant-condition.js

@@ -7,7 +7,7 @@ const parser_1 = require("@atlisp/parser");
 const CONDITION_FORMS = new Set(['if', 'while']);
 const CONSTANTS = new Set(['T', 'nil']);
 function checkConstantCondition(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkConstantConditionAst(ast, file);
 }
 function checkConstantConditionAst(ast, file) {
@@ -41,8 +41,8 @@ function checkConstantConditionAst(ast, file) {
                 continue;
             const condTest = clause.children[0];
             if (condTest.type === 'symbol' && condTest.name && CONSTANTS.has(condTest.name)) {
-                // Skip last clause with T — that's the standard else/default pattern
-                if (condTest.name === 'T' && i === condNode.children.length - 1)
+                // 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;
                 issues.push({
                     file,

package/dist/checks/dangerous-calls.js

@@ -36,7 +36,7 @@ function isFunctionCall(list, name) {
     return list.children[0].type === 'symbol' && list.children[0].name === name;
 }
 function checkDangerousCalls(content, file, config) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkDangerousCallsAst(ast, file, config);
 }
 function checkDangerousCallsAst(ast, file, config) {

package/dist/checks/dangling-defun.js

@@ -40,7 +40,7 @@ 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);
+    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) {

package/dist/checks/double-not.js

@@ -5,7 +5,7 @@ exports.checkDoubleNotAst = checkDoubleNotAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkDoubleNot(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkDoubleNotAst(ast, file);
 }
 function checkDoubleNotAst(ast, file) {

package/dist/checks/empty-branch.js

@@ -7,7 +7,7 @@ const parser_1 = require("@atlisp/parser");
 // AutoLISP only has `if` for conditional branching; `while` with no body is valid (no-op loop)
 const BRANCH_FORMS = new Set(['if']);
 function checkEmptyBranch(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkEmptyBranchAst(ast, file);
 }
 function checkEmptyBranchAst(ast, file) {

package/dist/checks/empty-catch.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkEmptyCatch(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const 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))

package/dist/checks/function-complexity.js

@@ -5,7 +5,7 @@ exports.checkFunctionComplexityAst = checkFunctionComplexityAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkFunctionComplexity(content, file, maxLines, maxNesting) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkFunctionComplexityAst(ast, file, maxLines, maxNesting);
 }
 function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {

package/dist/checks/global-naming.js

@@ -25,7 +25,7 @@ function isInsideLocalScope(node) {
 }
 function checkGlobalNaming(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    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)

package/dist/checks/identical-branches.js

@@ -27,7 +27,7 @@ function astEqual(a, b) {
     return false;
 }
 function checkIdenticalBranches(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkIdenticalBranchesAst(ast, file);
 }
 function checkIdenticalBranchesAst(ast, file) {

package/dist/checks/misplaced-else.js

@@ -5,7 +5,7 @@ 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);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkMisplacedElseAst(ast, file);
 }
 function checkMisplacedElseAst(ast, file) {

package/dist/checks/multiple-setq.js

@@ -5,7 +5,7 @@ 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);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkMultipleSetqAst(ast, file);
 }
 function checkMultipleSetqAst(ast, file) {

package/dist/checks/no-return.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkNoReturn(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const 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)

package/dist/checks/open-close.js

@@ -5,7 +5,7 @@ exports.checkOpenWithoutCloseAst = checkOpenWithoutCloseAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkOpenWithoutClose(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkOpenWithoutCloseAst(ast, file);
 }
 function checkOpenWithoutCloseAst(ast, file) {

package/dist/checks/parameter-naming.js

@@ -5,7 +5,7 @@ exports.checkParameterNamingAst = checkParameterNamingAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkParameterNaming(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkParameterNamingAst(ast, file);
 }
 function checkParameterNamingAst(ast, file) {

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

@@ -17,7 +17,7 @@ const HIGHER_ORDER_FUNCS = new Set([
     'vl-every',
 ]);
 function checkQuoteVsFunction(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkQuoteVsFunctionAst(ast, file);
 }
 function checkQuoteVsFunctionAst(ast, file) {

package/dist/checks/recursive-call.js

@@ -5,7 +5,7 @@ exports.checkRecursiveCallAst = checkRecursiveCallAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRecursiveCall(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRecursiveCallAst(ast, file);
 }
 /** Forms that provide conditional branching (exit condition for recursion) */

package/dist/checks/redundant-let.js

@@ -5,7 +5,7 @@ exports.checkRedundantLetAst = checkRedundantLetAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantLet(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantLetAst(ast, file);
 }
 function checkRedundantLetAst(ast, file) {

package/dist/checks/redundant-nil-else.js

@@ -5,7 +5,7 @@ exports.checkRedundantNilElseAst = checkRedundantNilElseAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantNilElse(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantNilElseAst(ast, file);
 }
 function checkRedundantNilElseAst(ast, file) {

package/dist/checks/redundant-progn.js

@@ -5,7 +5,7 @@ exports.checkRedundantPrognAst = checkRedundantPrognAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantProgn(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantPrognAst(ast, file);
 }
 function checkRedundantPrognAst(ast, file) {

package/dist/checks/redundant-quotes.js

@@ -5,7 +5,7 @@ exports.checkRedundantQuotesAst = checkRedundantQuotesAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantQuotes(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantQuotesAst(ast, file);
 }
 function checkRedundantQuotesAst(ast, file) {

package/dist/checks/redundant-setq.js

@@ -5,7 +5,7 @@ exports.checkRedundantSetqAst = checkRedundantSetqAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantSetq(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantSetqAst(ast, file);
 }
 function checkRedundantSetqAst(ast, file) {

package/dist/checks/self-compare.js

@@ -6,7 +6,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const COMPARE_FUNCTIONS = new Set(['=', '/=', '<', '>', '<=', '>=', 'eq', 'equal']);
 function checkSelfCompare(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkSelfCompareAst(ast, file);
 }
 function checkSelfCompareAst(ast, file) {

package/dist/checks/setq-single-arg.js

@@ -5,7 +5,7 @@ exports.checkSetqSingleArgAst = checkSetqSingleArgAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkSetqSingleArg(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkSetqSingleArgAst(ast, file);
 }
 function checkSetqSingleArgAst(ast, file) {