@atlisp/lint 0.2.16 → 0.2.17

package/dist/visitors/register.js

@@ -0,0 +1,625 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVisitorRules = registerVisitorRules;
+const parser_1 = require("@atlisp/parser");
+const locale_1 = require("../locale");
+const shared_1 = require("./shared");
+function registerVisitorRules(visitor, state, checks, addIssue, config, file) {
+    if (checks['redundant_progn'] !== 'off') {
+        visitor.on('progn', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 2) {
+                addIssue('redundant_progn', node.pos.line, (0, locale_1.t)('redundant_progn', 'progn'));
+            }
+        });
+    }
+    if (checks['redundant_setq'] !== 'off') {
+        visitor.on('setq', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            for (let i = 1; i < node.children.length - 1; i += 2) {
+                const varNode = node.children[i];
+                const valNode = node.children[i + 1];
+                if ((0, parser_1.astIsSymbol)(varNode) && (0, parser_1.astIsSymbol)(valNode) && varNode.name === valNode.name) {
+                    addIssue('redundant_setq', varNode.pos.line, (0, locale_1.t)('redundant_setq', varNode.name || ''));
+                }
+            }
+        });
+    }
+    if (checks['redundant_nil_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 4) {
+                const last = node.children[3];
+                if ((0, parser_1.astIsSymbol)(last, 'nil')) {
+                    addIssue('redundant_nil_else', node.pos.line, (0, locale_1.t)('redundant_nil_else'));
+                }
+            }
+        });
+    }
+    if (checks['single_arg_and_or'] !== 'off') {
+        const checkSingleArg = (node) => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 2) {
+                const name = (0, parser_1.astIsSymbol)(node.children[0]) ? node.children[0].name : '';
+                addIssue('single_arg_and_or', node.pos.line, (0, locale_1.t)('single_arg_and_or', name || 'and/or'));
+            }
+        };
+        visitor.on('and', checkSingleArg);
+        visitor.on('or', checkSingleArg);
+    }
+    if (checks['redundant_let'] !== 'off') {
+        visitor.on('let', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2) {
+                const bindings = node.children[1];
+                if ((0, parser_1.astIsList)(bindings) && bindings.children.length === 0) {
+                    addIssue('redundant_let', node.pos.line, (0, locale_1.t)('redundant_let'));
+                }
+            }
+        });
+    }
+    if (checks['self_compare'] !== 'off') {
+        const compareFns = new Set(['=', '/=', '<', '>', '<=', '>=', 'eq', 'equal']);
+        visitor.on('*', node => {
+            if ((0, parser_1.astIsList)(node) && node.children.length === 3) {
+                const op = node.children[0];
+                if ((0, parser_1.astIsSymbol)(op) && op.name && compareFns.has(op.name)) {
+                    const a = node.children[1];
+                    const b = node.children[2];
+                    if ((0, parser_1.astIsSymbol)(a) && (0, parser_1.astIsSymbol)(b) && a.name === b.name) {
+                        addIssue('self_compare', node.pos.line, (0, locale_1.t)('self_compare', `(${op.name} ${a.name} ${b.name})`));
+                    }
+                }
+            }
+        });
+    }
+    if (checks['double_not'] !== 'off') {
+        visitor.on('not', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2 && (0, parser_1.astIsList)(node.children[1], 'not')) {
+                addIssue('double_not', node.pos.line, (0, locale_1.t)('double_not'));
+            }
+        });
+    }
+    if (checks['setq_single_arg'] !== 'off') {
+        visitor.on('setq', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 2) {
+                const varName = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '';
+                addIssue('setq_single_arg', node.pos.line, (0, locale_1.t)('setq_single_arg', varName || ''));
+            }
+        });
+    }
+    if (checks['empty_branch'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 3) {
+                addIssue('empty_branch', node.pos.line, (0, locale_1.t)('empty_branch', 'if'));
+            }
+        });
+    }
+    if (checks['misplaced_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 4) {
+                const cond = node.children[1];
+                if ((0, parser_1.astIsList)(cond, 'not') && cond.children.length >= 2) {
+                    const innerName = (0, parser_1.astIsSymbol)(cond.children[1]) ? cond.children[1].name || '' : '';
+                    addIssue('misplaced_else', node.pos.line, (0, locale_1.t)('misplaced_else', innerName));
+                }
+            }
+        });
+    }
+    if (checks['while_constant'] !== 'off') {
+        visitor.on('while', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2) {
+                const cond = node.children[1];
+                if ((0, shared_1.isLiteral)(cond)) {
+                    const name = (0, parser_1.astIsSymbol)(cond) ? cond.name || '' : String(cond.value ?? '');
+                    addIssue('while_constant', node.pos.line, (0, locale_1.t)('while_constant', name));
+                }
+            }
+        });
+    }
+    if (checks['constant_condition'] !== 'off') {
+        const checkConstant = (node, formName) => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2) {
+                const cond = node.children[1];
+                if ((0, shared_1.isLiteral)(cond)) {
+                    const name = (0, parser_1.astIsSymbol)(cond) ? cond.name || '' : String(cond.value ?? '');
+                    addIssue('constant_condition', node.pos.line, (0, locale_1.t)('constant_condition', name, formName));
+                }
+            }
+        };
+        visitor.on('if', node => checkConstant(node, 'if'));
+        visitor.on('while', node => checkConstant(node, 'while'));
+        visitor.on('cond', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2) {
+                const clause = node.children[1];
+                if ((0, parser_1.astIsList)(clause) && clause.children.length >= 2) {
+                    const test = clause.children[1];
+                    if ((0, shared_1.isLiteral)(test)) {
+                        const name = (0, parser_1.astIsSymbol)(test) ? test.name || '' : String(test.value ?? '');
+                        addIssue('constant_condition', node.pos.line, (0, locale_1.t)('constant_condition', name, 'cond'));
+                    }
+                }
+            }
+        });
+    }
+    if (checks['quote_vs_function'] !== 'off') {
+        visitor.on('quote', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2 && (0, parser_1.astIsList)(node.children[1], 'lambda')) {
+                const parent = node.parent;
+                if (parent && (0, parser_1.astIsList)(parent) && parent.children.length > 0) {
+                    const pName = (0, parser_1.astIsSymbol)(parent.children[0]) ? parent.children[0].name || '' : '';
+                    if (shared_1.higherOrderFuncs.has(pName)) {
+                        addIssue('quote_vs_function', node.pos.line, (0, locale_1.t)('quote_vs_function', pName));
+                    }
+                }
+            }
+        });
+    }
+    if (checks['redundant_quotes'] !== 'off') {
+        visitor.on('quote', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2 && (0, parser_1.astIsList)(node.children[1], 'quote')) {
+                addIssue('redundant_quotes', node.pos.line, (0, locale_1.t)('redundant_quotes'));
+            }
+        });
+    }
+    if (checks['parameter_naming'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 3)
+                return;
+            const paramList = node.children[2];
+            const fnName = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name || '' : '';
+            for (const child of (0, parser_1.astChildren)(paramList)) {
+                if (!(0, parser_1.astIsSymbol)(child) || !child.name)
+                    continue;
+                if (/^[A-Z]/.test(child.name) && child.name !== 'T' && child.name !== 'nil') {
+                    addIssue('parameter_naming', child.pos.line, (0, locale_1.t)('parameter_naming', child.name, fnName));
+                }
+            }
+        });
+    }
+    if (checks['assoc_without_cdr'] !== 'off') {
+        visitor.on('assoc', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            const parent = node.parent;
+            if (!parent) {
+                addIssue('assoc_without_cdr', node.pos.line, (0, locale_1.t)('assoc_without_cdr'));
+                return;
+            }
+            if ((0, parser_1.astIsList)(parent) && parent.children.length > 0 && (0, parser_1.astIsSymbol)(parent.children[0])) {
+                if (parent.children[0].name === 'cdr' || parent.children[0].name === 'cadr') {
+                    return;
+                }
+            }
+            addIssue('assoc_without_cdr', node.pos.line, (0, locale_1.t)('assoc_without_cdr'));
+        });
+    }
+    if (checks['identical_branches'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 4) {
+                const thenBranch = node.children[2];
+                const elseBranch = node.children[3];
+                if ((0, shared_1.astEqual)(thenBranch, elseBranch)) {
+                    addIssue('identical_branches', node.pos.line, (0, locale_1.t)('identical_branches'));
+                }
+            }
+        });
+    }
+    if (checks['open_without_close'] !== 'off') {
+        visitor.on('open', () => {
+            state.openCount++;
+        });
+        visitor.on('close', () => {
+            state.closeCount++;
+        });
+    }
+    if (checks['cond_duplicate'] !== 'off') {
+        visitor.on('cond', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            const seen = new Set();
+            for (let i = 1; i < node.children.length; i++) {
+                const clause = node.children[i];
+                if (!(0, parser_1.astIsList)(clause) || clause.children.length < 1)
+                    continue;
+                const condTest = clause.children[0];
+                const key = (0, shared_1.getCondKey)(condTest);
+                if (seen.has(key)) {
+                    addIssue('cond_duplicate', clause.pos.line, (0, locale_1.t)('cond_duplicate'));
+                }
+                seen.add(key);
+            }
+        });
+    }
+    if (checks['quit_exit'] !== 'off') {
+        const dangerNames = new Set();
+        const dc = config.dangerous_calls;
+        if (dc.quit !== 'off')
+            dangerNames.add('quit');
+        if (dc.exit !== 'off')
+            dangerNames.add('exit');
+        if (dc.startapp !== 'off')
+            dangerNames.add('startapp');
+        if (dc.vl_registry_write !== 'off')
+            dangerNames.add('vl-registry-write');
+        if (dc.eval !== 'off')
+            dangerNames.add('eval');
+        if (dangerNames.size > 0) {
+            visitor.on('*', node => {
+                if ((0, parser_1.astIsList)(node) && node.children.length > 0 && (0, parser_1.astIsSymbol)(node.children[0]) && node.children[0].name && dangerNames.has(node.children[0].name)) {
+                    if (!(0, shared_1.isInQuote)(node)) {
+                        state.dangerousCalls.push({ name: node.children[0].name, node });
+                    }
+                }
+            });
+        }
+    }
+    if (checks['multiple_setq'] !== 'off') {
+        visitor.on('*', node => {
+            if ((0, parser_1.astIsList)(node)) {
+                let prevSetq = false;
+                for (const child of node.children) {
+                    if ((0, parser_1.astIsList)(child, 'setq')) {
+                        if (prevSetq) {
+                            addIssue('multiple_setq', child.pos.line, (0, locale_1.t)('multiple_setq'));
+                            prevSetq = false;
+                        }
+                        else {
+                            prevSetq = true;
+                        }
+                    }
+                    else {
+                        prevSetq = false;
+                    }
+                }
+            }
+        });
+    }
+    if (checks['recursive_call'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 4)
+                return;
+            const fnName = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '';
+            if (!fnName)
+                return;
+            const body = node.children.slice(3);
+            if ((0, shared_1.hasSelfCall)(body, fnName) && !(0, shared_1.hasConditionalForm)(body)) {
+                addIssue('recursive_call', node.pos.line, (0, locale_1.t)('recursive_call', fnName));
+            }
+        });
+    }
+    if (checks['variable_shadow'] !== 'off') {
+        visitor.on('let', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 2)
+                return;
+            const bindings = node.children[1];
+            if (!(0, parser_1.astIsList)(bindings))
+                return;
+            const letVars = new Set();
+            for (const b of bindings.children) {
+                if ((0, parser_1.astIsList)(b) && b.children.length > 0 && (0, parser_1.astIsSymbol)(b.children[0]) && b.children[0].name) {
+                    letVars.add(b.children[0].name);
+                }
+            }
+            const walkBodyForSetq = (forms) => {
+                for (const form of forms) {
+                    if ((0, parser_1.astIsList)(form) && form.children.length > 0 && (0, parser_1.astIsSymbol)(form.children[0])) {
+                        if (form.children[0].name === 'setq' && form.children.length > 1) {
+                            for (let i = 1; i < form.children.length; i += 2) {
+                                const child = form.children[i];
+                                if (!(0, parser_1.astIsSymbol)(child) || !child.name)
+                                    continue;
+                                if (letVars.has(child.name)) {
+                                    addIssue('variable_shadow', child.pos.line, (0, locale_1.t)('variable_shadow', child.name));
+                                }
+                            }
+                        }
+                        else if (form.children[0].name !== 'let') {
+                            walkBodyForSetq(form.children.slice(1));
+                        }
+                    }
+                }
+            };
+            walkBodyForSetq(node.children.slice(2));
+        });
+    }
+    if (checks['unused_let_binding'] !== 'off') {
+        visitor.on('let', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 2)
+                return;
+            const bindings = node.children[1];
+            if (!(0, parser_1.astIsList)(bindings))
+                return;
+            const letVars = [];
+            for (const b of bindings.children) {
+                if ((0, parser_1.astIsList)(b) && b.children.length > 0 && (0, parser_1.astIsSymbol)(b.children[0]) && b.children[0].name) {
+                    letVars.push({ name: b.children[0].name, line: b.children[0].pos.line });
+                }
+            }
+            if (letVars.length === 0)
+                return;
+            const bodyRefs = new Set();
+            for (const form of node.children.slice(2)) {
+                (0, shared_1.collectSymbolRefs)(form, bodyRefs);
+            }
+            for (const v of letVars) {
+                if (!bodyRefs.has(v.name)) {
+                    addIssue('unused_let_binding', v.line, (0, locale_1.t)('unused_let_binding', v.name));
+                }
+            }
+        });
+    }
+    if (checks['unused_parameter'] !== 'off' || checks['unused_local_fun'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length < 4)
+                return;
+            const fnName = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '';
+            if (!fnName || fnName.startsWith('C:') || fnName.startsWith('c:'))
+                return;
+            const body = node.children.slice(3);
+            if (checks['unused_parameter'] !== 'off') {
+                const params = (0, shared_1.defunParams)(node);
+                if (params.length > 0) {
+                    const bodyRefs = new Set();
+                    for (const form of body) {
+                        (0, shared_1.collectSymbolRefs)(form, bodyRefs);
+                    }
+                    for (const p of params) {
+                        if (!bodyRefs.has(p) && p !== fnName) {
+                            addIssue('unused_parameter', node.pos.line, (0, locale_1.t)('unused_parameter', p, fnName));
+                        }
+                    }
+                }
+            }
+            if (checks['unused_local_fun'] !== 'off') {
+                const locals = (0, shared_1.defunLocals)(node);
+                if (locals.length > 0) {
+                    const bodyRefs = new Set();
+                    for (const form of body) {
+                        (0, shared_1.collectSymbolRefs)(form, bodyRefs);
+                    }
+                    for (const l of locals) {
+                        if (!bodyRefs.has(l)) {
+                            addIssue('unused_local_fun', node.pos.line, (0, locale_1.t)('unused_local_fun', l));
+                        }
+                    }
+                }
+            }
+        });
+    }
+    if (checks['unused_variable'] !== 'off') {
+        visitor.on('setq', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            for (let i = 1; i < node.children.length; i += 2) {
+                const varNode = node.children[i];
+                if ((0, parser_1.astIsSymbol)(varNode) &&
+                    varNode.name &&
+                    !varNode.name.startsWith('*') &&
+                    !varNode.name.includes(':*') &&
+                    varNode.name !== 'T' &&
+                    varNode.name !== 'nil' &&
+                    !varNode.name.startsWith('/')) {
+                    state.setqDefs.set(varNode.name, { line: varNode.pos.line, file });
+                }
+            }
+        });
+    }
+    if (checks['unused_variable'] !== 'off') {
+        visitor.on('*', node => {
+            if ((0, parser_1.astIsSymbol)(node) && node.name) {
+                state.symbolRefs.set(node.name, (state.symbolRefs.get(node.name) || 0) + 1);
+            }
+        });
+    }
+    if (checks['function_complexity'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 3) {
+                const fnName = ((0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '<anonymous>') || '<anonymous>';
+                state.defunScopes.push({
+                    name: fnName,
+                    params: [],
+                    body: node.children.slice(3),
+                    line: node.pos.line,
+                    file,
+                });
+            }
+        });
+    }
+    if (checks['if_without_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 3) {
+                const parent = node.parent;
+                if (parent && (0, parser_1.astIsList)(parent) && parent.children.length > 0 && (0, parser_1.astIsSymbol)(parent.children[0])) {
+                    const parentName = parent.children[0].name;
+                    if (parentName === 'cond' || parentName === 'if')
+                        return;
+                }
+                addIssue('if_without_else', node.pos.line, (0, locale_1.t)('if_without_else'));
+            }
+        });
+    }
+    if (checks['strcat_or_arg'] !== 'off') {
+        visitor.on('*', node => {
+            if ((0, parser_1.astIsList)(node, 'strcat') && node.children.length > 1) {
+                if ((0, shared_1.isInQuote)(node))
+                    return;
+                for (let i = 1; i < node.children.length; i++) {
+                    const arg = node.children[i];
+                    if ((0, parser_1.astIsList)(arg, 'or')) {
+                        addIssue('strcat_or_arg', arg.pos.line, (0, locale_1.t)('strcat_or_arg'));
+                    }
+                }
+            }
+        });
+    }
+    if (checks['redundant_list'] !== 'off') {
+        visitor.on('list', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 1) {
+                addIssue('redundant_list', node.pos.line, (0, locale_1.t)('redundant_list'));
+            }
+        });
+    }
+    if (checks['command_s'] !== 'off') {
+        visitor.on('command', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length >= 2) {
+                const subCmd = node.children[1];
+                if ((0, parser_1.astIsString)(subCmd) && subCmd.value === 'shell')
+                    return;
+                addIssue('command_s', node.pos.line, (0, locale_1.t)('command_s'));
+            }
+        });
+    }
+    if (checks['zerop_usage'] !== 'off') {
+        const checkZero = (node) => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 3) {
+                const a = node.children[1];
+                const b = node.children[2];
+                const extract = (n) => (0, parser_1.astIsSymbol)(n) ? n.name || '' : (0, parser_1.astIsNumber)(n) ? String(n.value ?? '') : '';
+                if ((0, parser_1.astIsNumber)(a) && a.value === 0 && (0, parser_1.astIsSymbol)(b)) {
+                    addIssue('zerop_usage', node.pos.line, (0, locale_1.t)('zerop_usage', extract(b)));
+                }
+                else if ((0, parser_1.astIsNumber)(b) && b.value === 0 && (0, parser_1.astIsSymbol)(a)) {
+                    addIssue('zerop_usage', node.pos.line, (0, locale_1.t)('zerop_usage', extract(a)));
+                }
+            }
+        };
+        visitor.on('=', checkZero);
+        visitor.on('equal', checkZero);
+    }
+    if (checks['progn_in_body'] !== 'off') {
+        const checkPrognInBody = (node, formName, bodyStartIdx) => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length > bodyStartIdx) {
+                const firstBody = node.children[bodyStartIdx];
+                if ((0, parser_1.astIsList)(firstBody, 'progn')) {
+                    addIssue('progn_in_body', firstBody.pos.line, (0, locale_1.t)('progn_in_body', formName));
+                }
+            }
+        };
+        visitor.on('while', node => checkPrognInBody(node, 'while', 2));
+        visitor.on('repeat', node => checkPrognInBody(node, 'repeat', 2));
+        visitor.on('foreach', node => checkPrognInBody(node, 'foreach', 3));
+    }
+    if (checks['if_progn_both'] !== 'off') {
+        visitor.on('if', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 4) {
+                const thenBranch = node.children[2];
+                const elseBranch = node.children[3];
+                if ((0, parser_1.astIsList)(thenBranch, 'progn') && (0, parser_1.astIsList)(elseBranch, 'progn')) {
+                    addIssue('if_progn_both', node.pos.line, (0, locale_1.t)('if_progn_both'));
+                }
+            }
+        });
+    }
+    if (checks['redundant_cond'] !== 'off') {
+        visitor.on('cond', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            if (node.children.length === 2) {
+                const clause = node.children[1];
+                if ((0, parser_1.astIsList)(clause) && clause.children.length === 2) {
+                    const test = clause.children[0];
+                    if ((0, parser_1.astIsSymbol)(test, 't'))
+                        return;
+                    addIssue('redundant_cond', node.pos.line, (0, locale_1.t)('redundant_cond'));
+                }
+            }
+        });
+    }
+    if (checks['empty_branch_cond'] !== 'off') {
+        visitor.on('cond', node => {
+            if (!(0, parser_1.astIsList)(node))
+                return;
+            for (let i = 1; i < node.children.length; i++) {
+                const clause = node.children[i];
+                if ((0, parser_1.astIsList)(clause) && clause.children.length < 2) {
+                    addIssue('empty_branch_cond', clause.pos.line, (0, locale_1.t)('empty_branch_cond'));
+                }
+            }
+        });
+    }
+    if (checks['selection_set_leak'] !== 'off') {
+        visitor.on('ssget', () => {
+            state.ssgetCount++;
+        });
+        visitor.on('ssset', () => {
+            state.sssetCount++;
+        });
+    }
+    if (checks['promise_handler'] !== 'off') {
+        visitor.on('*', node => {
+            if ((0, parser_1.astIsList)(node) &&
+                node.children.length > 0 &&
+                (0, parser_1.astIsSymbol)(node.children[0]) &&
+                node.children[0].name &&
+                (node.children[0].name.startsWith('vlax-invoke') || node.children[0].name.startsWith('vlax-invoke-method'))) {
+                if ((0, shared_1.isInQuote)(node))
+                    return;
+                const parent = node.parent;
+                if (parent && (0, parser_1.astIsList)(parent) && parent.children.length > 0 && (0, parser_1.astIsSymbol)(parent.children[0], 'vl-catch-all-apply')) {
+                    return;
+                }
+                let hasCallback = false;
+                for (const child of node.children.slice(1)) {
+                    if ((0, parser_1.astIsList)(child) && child.children.length > 0 && (0, parser_1.astIsSymbol)(child.children[0]) && (child.children[0].name === 'lambda' || child.children[0].name === 'function')) {
+                        hasCallback = true;
+                        break;
+                    }
+                }
+                if (!hasCallback) {
+                    addIssue('promise_handler', node.pos.line, (0, locale_1.t)('promise_handler'));
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=register.js.map

package/dist/visitors/shared.d.ts

@@ -0,0 +1,40 @@
+import { AstNode } from '@atlisp/parser';
+export interface CollectState {
+    openCount: number;
+    closeCount: number;
+    setqDefs: Map<string, {
+        line: number;
+        file: string;
+    }>;
+    symbolRefs: Map<string, number>;
+    condKeys: Map<number, Set<string>>;
+    defunScopes: Array<{
+        name: string;
+        params: string[];
+        body: AstNode[];
+        line: number;
+        file: string;
+    }>;
+    letScopes: Array<{
+        bindings: string[];
+        body: AstNode[];
+        line: number;
+    }>;
+    dangerousCalls: Array<{
+        name: string;
+        node: AstNode;
+    }>;
+    ssgetCount: number;
+    sssetCount: number;
+}
+export declare function isInQuote(node: AstNode, checkFunction?: boolean): boolean;
+export declare function isLiteral(node: AstNode): boolean;
+export declare function astEqual(a: AstNode, b: AstNode): boolean;
+export declare function getCondKey(node: AstNode): string;
+export declare function hasConditionalForm(body: AstNode[]): boolean;
+export declare function hasSelfCall(body: AstNode[], fnName: string): boolean;
+export declare function defunParams(defunNode: AstNode): string[];
+export declare function defunLocals(defunNode: AstNode): string[];
+export declare function collectSymbolRefs(node: AstNode, result: Set<string>): void;
+export declare const higherOrderFuncs: Set<string>;
+//# sourceMappingURL=shared.d.ts.map