@atlisp/lint 0.1.16 → 0.1.19

package/dist/visitor-runner.js

@@ -0,0 +1,709 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecksWithVisitor = runChecksWithVisitor;
+const locale_1 = require("./locale");
+const disable_1 = require("./disable");
+const parser_1 = require("@atlisp/parser");
+function emit(issues, rule, line, severity, message, file) {
+    if (severity === 'off')
+        return;
+    issues.push({ file, line, severity: severity, rule, message });
+}
+function runChecksWithVisitor(ast, file, config, disableMap) {
+    const issues = [];
+    const checks = config.checks;
+    const visitor = new parser_1.AstVisitor();
+    const state = {
+        openCount: 0,
+        closeCount: 0,
+        setqDefs: new Map(),
+        symbolRefs: new Set(),
+        condKeys: new Map(),
+        defunScopes: [],
+        letScopes: [],
+        dangerousCalls: [],
+    };
+    function addIssue(rule, line, message) {
+        const severity = checks[rule];
+        if (!severity || severity === 'off')
+            return;
+        if (!(0, disable_1.isDisabled)(rule, line, disableMap)) {
+            issues.push({ file, line, severity: severity, rule, message });
+        }
+    }
+    function isInQuote(node) {
+        let p = node.parent;
+        while (p) {
+            if (p.type === 'list' && p.children && p.children.length > 0 && p.children[0].type === 'symbol' && (p.children[0].name === 'quote' || p.children[0].name === 'function')) {
+                return true;
+            }
+            p = p.parent;
+        }
+        return false;
+    }
+    function isLiteral(node) {
+        if (node.type === 'symbol' && (node.name === 'T' || node.name === 't' || node.name === 'nil'))
+            return true;
+        if (node.type === 'number')
+            return true;
+        return false;
+    }
+    function astEqual(a, b) {
+        if (a.type !== b.type)
+            return false;
+        if (a.type === 'symbol')
+            return a.name === b.name;
+        if (a.type === 'string')
+            return a.value === b.value;
+        if (a.type === 'number')
+            return a.value === b.value;
+        if (a.type === 'list') {
+            const ac = a.children || [];
+            const bc = b.children || [];
+            if (ac.length !== bc.length)
+                return false;
+            for (let i = 0; i < ac.length; i++) {
+                if (!astEqual(ac[i], bc[i]))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    function getCondKey(node) {
+        if (node.type === 'symbol')
+            return node.name || '';
+        if (node.type === 'string' || node.type === 'number')
+            return String(node.value);
+        if (node.type === 'list' && node.children) {
+            return '(' + node.children.map(c => getCondKey(c)).join(' ') + ')';
+        }
+        return '';
+    }
+    function hasSelfCall(body, fnName) {
+        for (const form of body) {
+            if (form.type === 'list' && form.children && form.children.length > 0 && form.children[0].type === 'symbol' && form.children[0].name === fnName) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function hasConditionalForm(body) {
+        for (const form of body) {
+            if (form.type === 'list' && form.children && form.children.length > 0 && form.children[0].type === 'symbol') {
+                const name = form.children[0].name;
+                if (name === 'if' || name === 'cond' || name === 'when' || name === 'unless') {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function defunParams(defunNode) {
+        if (!defunNode.children || defunNode.children.length < 3)
+            return [];
+        const paramList = defunNode.children[2];
+        if (!paramList.children)
+            return [];
+        const params = [];
+        for (const child of paramList.children) {
+            if (child.type === 'symbol' && child.name && child.name !== '/') {
+                params.push(child.name);
+            }
+        }
+        return params;
+    }
+    function defunLocals(defunNode) {
+        if (!defunNode.children || defunNode.children.length < 3)
+            return [];
+        const paramList = defunNode.children[2];
+        if (!paramList.children)
+            return [];
+        const locals = [];
+        let afterSlash = false;
+        for (const child of paramList.children) {
+            if (child.type === 'symbol' && child.name === '/') {
+                afterSlash = true;
+                continue;
+            }
+            if (afterSlash && child.type === 'symbol' && child.name) {
+                locals.push(child.name);
+            }
+        }
+        return locals;
+    }
+    function collectSymbolRefs(node, result) {
+        if (node.type === 'symbol' && node.name) {
+            result.add(node.name);
+        }
+        if (node.children) {
+            for (const c of node.children) {
+                collectSymbolRefs(c, result);
+            }
+        }
+    }
+    const higherOrderFuncs = new Set([
+        'mapcar', 'apply', 'lambda', 'vl-sort', 'vl-sort-i',
+        'vl-remove-if', 'vl-remove-if-not', 'vl-member-if', 'vl-some', 'vl-every',
+    ]);
+    // redundant_progn
+    if (checks['redundant_progn'] !== 'off') {
+        visitor.on('progn', node => {
+            if (node.children && node.children.length === 2) {
+                addIssue('redundant_progn', node.pos.line, (0, locale_1.t)('redundant_progn', 'progn'));
+            }
+        });
+    }
+    // redundant_setq
+    if (checks['redundant_setq'] !== 'off') {
+        visitor.on('setq', node => {
+            if (!node.children)
+                return;
+            for (let i = 1; i < node.children.length - 1; i += 2) {
+                const varNode = node.children[i];
+                const valNode = node.children[i + 1];
+                if (varNode.type === 'symbol' && valNode.type === 'symbol' && varNode.name === valNode.name) {
+                    addIssue('redundant_setq', varNode.pos.line, (0, locale_1.t)('redundant_setq', varNode.name || ''));
+                }
+            }
+        });
+    }
+    // redundant_nil_else
+    if (checks['redundant_nil_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length === 4) {
+                const last = node.children[3];
+                if (last.type === 'symbol' && last.name === 'nil') {
+                    addIssue('redundant_nil_else', node.pos.line, (0, locale_1.t)('redundant_nil_else'));
+                }
+            }
+        });
+    }
+    // single_arg_and_or
+    if (checks['single_arg_and_or'] !== 'off') {
+        const checkSingleArg = (node) => {
+            if (node.children && node.children.length === 2) {
+                const name = node.children[0].type === 'symbol' ? 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);
+    }
+    // redundant_let
+    if (checks['redundant_let'] !== 'off') {
+        visitor.on('let', node => {
+            if (node.children && node.children.length >= 2) {
+                const bindings = node.children[1];
+                if (bindings.type === 'list' && (!bindings.children || bindings.children.length === 0)) {
+                    addIssue('redundant_let', node.pos.line, (0, locale_1.t)('redundant_let'));
+                }
+            }
+        });
+    }
+    // self_compare
+    if (checks['self_compare'] !== 'off') {
+        const compareFns = new Set(['=', '/=', '<', '>', '<=', '>=', 'eq', 'equal']);
+        visitor.on('*', node => {
+            if (node.type === 'list' && node.children && node.children.length === 3) {
+                const op = node.children[0];
+                if (op.type === 'symbol' && op.name && compareFns.has(op.name)) {
+                    const a = node.children[1];
+                    const b = node.children[2];
+                    if (a.type === 'symbol' && b.type === 'symbol' && a.name === b.name) {
+                        addIssue('self_compare', node.pos.line, (0, locale_1.t)('self_compare', `(${op.name} ${a.name} ${b.name})`));
+                    }
+                }
+            }
+        });
+    }
+    // double_not
+    if (checks['double_not'] !== 'off') {
+        visitor.on('not', node => {
+            if (node.children && node.children.length >= 2 && node.children[1].type === 'list' &&
+                node.children[1].children && node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' && node.children[1].children[0].name === 'not') {
+                addIssue('double_not', node.pos.line, (0, locale_1.t)('double_not'));
+            }
+        });
+    }
+    // setq_single_arg
+    if (checks['setq_single_arg'] !== 'off') {
+        visitor.on('setq', node => {
+            if (node.children && node.children.length === 2) {
+                const varName = node.children[1].type === 'symbol' ? node.children[1].name : '';
+                addIssue('setq_single_arg', node.pos.line, (0, locale_1.t)('setq_single_arg', varName || ''));
+            }
+        });
+    }
+    // empty_branch
+    if (checks['empty_branch'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length < 3) {
+                addIssue('empty_branch', node.pos.line, (0, locale_1.t)('empty_branch', 'if'));
+            }
+        });
+    }
+    // misplaced_else
+    if (checks['misplaced_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length === 4) {
+                const cond = node.children[1];
+                if (cond.type === 'list' && cond.children && cond.children.length >= 2 &&
+                    cond.children[0].type === 'symbol' && cond.children[0].name === 'not') {
+                    const innerName = cond.children[1].type === 'symbol' ? (cond.children[1].name || '') : '';
+                    addIssue('misplaced_else', node.pos.line, (0, locale_1.t)('misplaced_else', innerName));
+                }
+            }
+        });
+    }
+    // while_constant
+    if (checks['while_constant'] !== 'off') {
+        visitor.on('while', node => {
+            if (node.children && node.children.length >= 2) {
+                const cond = node.children[1];
+                if (isLiteral(cond)) {
+                    const name = cond.type === 'symbol' ? (cond.name || '') : String(cond.value ?? '');
+                    addIssue('while_constant', node.pos.line, (0, locale_1.t)('while_constant', name));
+                }
+            }
+        });
+    }
+    // constant_condition
+    if (checks['constant_condition'] !== 'off') {
+        const checkConstant = (node, formName) => {
+            if (node.children && node.children.length >= 2) {
+                const cond = node.children[1];
+                if (isLiteral(cond)) {
+                    const name = cond.type === 'symbol' ? (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 (node.children && node.children.length >= 2) {
+                const clause = node.children[1];
+                if (clause.type === 'list' && clause.children && clause.children.length >= 2) {
+                    const test = clause.children[1];
+                    if (isLiteral(test)) {
+                        const name = test.type === 'symbol' ? (test.name || '') : String(test.value ?? '');
+                        addIssue('constant_condition', node.pos.line, (0, locale_1.t)('constant_condition', name, 'cond'));
+                    }
+                }
+            }
+        });
+    }
+    // quote_vs_function
+    if (checks['quote_vs_function'] !== 'off') {
+        visitor.on('quote', node => {
+            if (node.children && node.children.length >= 2 && node.children[1].type === 'list' &&
+                node.children[1].children && node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' && node.children[1].children[0].name === 'lambda') {
+                const parent = node.parent;
+                if (parent && parent.children && parent.children.length > 0) {
+                    const pName = (parent.children[0].type === 'symbol' && parent.children[0].name) || '';
+                    if (higherOrderFuncs.has(pName)) {
+                        addIssue('quote_vs_function', node.pos.line, (0, locale_1.t)('quote_vs_function', pName));
+                    }
+                }
+            }
+        });
+    }
+    // redundant_quotes
+    if (checks['redundant_quotes'] !== 'off') {
+        visitor.on('quote', node => {
+            if (node.children && node.children.length >= 2 && node.children[1].type === 'list' &&
+                node.children[1].children && node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' && node.children[1].children[0].name === 'quote') {
+                addIssue('redundant_quotes', node.pos.line, (0, locale_1.t)('redundant_quotes'));
+            }
+        });
+    }
+    // parameter_naming
+    if (checks['parameter_naming'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!node.children || node.children.length < 3)
+                return;
+            const paramList = node.children[2];
+            if (!paramList.children)
+                return;
+            const fnName = node.children[1].type === 'symbol' && node.children[1].name ? node.children[1].name : '';
+            for (const child of paramList.children) {
+                if (child.type !== 'symbol' || !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));
+                }
+            }
+        });
+    }
+    // assoc_without_cdr
+    if (checks['assoc_without_cdr'] !== 'off') {
+        visitor.on('assoc', node => {
+            const parent = node.parent;
+            if (!parent) {
+                addIssue('assoc_without_cdr', node.pos.line, (0, locale_1.t)('assoc_without_cdr'));
+                return;
+            }
+            if (parent.type === 'list' && parent.children && parent.children.length > 0 &&
+                parent.children[0].type === 'symbol' && (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'));
+        });
+    }
+    // identical_branches
+    if (checks['identical_branches'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length === 4) {
+                const thenBranch = node.children[2];
+                const elseBranch = node.children[3];
+                if (astEqual(thenBranch, elseBranch)) {
+                    addIssue('identical_branches', node.pos.line, (0, locale_1.t)('identical_branches'));
+                }
+            }
+        });
+    }
+    // open_without_close (data collection)
+    if (checks['open_without_close'] !== 'off') {
+        visitor.on('open', () => { state.openCount++; });
+        visitor.on('close', () => { state.closeCount++; });
+    }
+    // cond_duplicate (data collection)
+    if (checks['cond_duplicate'] !== 'off') {
+        visitor.on('cond', node => {
+            if (!node.children)
+                return;
+            const seen = new Set();
+            for (let i = 1; i < node.children.length; i++) {
+                const clause = node.children[i];
+                if (clause.type !== 'list' || !clause.children || clause.children.length < 2)
+                    continue;
+                const condTest = clause.children[1];
+                const key = getCondKey(condTest);
+                if (seen.has(key)) {
+                    addIssue('cond_duplicate', clause.pos.line, (0, locale_1.t)('cond_duplicate'));
+                }
+                seen.add(key);
+            }
+        });
+    }
+    // dangerous_calls (data collection) - skip if in quote
+    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 (dangerNames.size > 0) {
+            visitor.on('*', node => {
+                if (node.type === 'list' && node.children && node.children.length > 0 &&
+                    node.children[0].type === 'symbol' && node.children[0].name && dangerNames.has(node.children[0].name)) {
+                    if (!isInQuote(node)) {
+                        state.dangerousCalls.push({ name: node.children[0].name, node });
+                    }
+                }
+            });
+        }
+    }
+    // multiple_setq (data collection via wildcard)
+    if (checks['multiple_setq'] !== 'off') {
+        visitor.on('*', node => {
+            if (node.type === 'list' && node.children) {
+                let prevSetq = false;
+                for (const child of node.children) {
+                    if (child.type === 'list' && child.children && child.children.length > 0 &&
+                        child.children[0].type === 'symbol' && child.children[0].name === 'setq') {
+                        if (prevSetq) {
+                            addIssue('multiple_setq', child.pos.line, (0, locale_1.t)('multiple_setq'));
+                            prevSetq = false;
+                        }
+                        else {
+                            prevSetq = true;
+                        }
+                    }
+                    else {
+                        prevSetq = false;
+                    }
+                }
+            }
+        });
+    }
+    // recursive_call (data collection)
+    if (checks['recursive_call'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!node.children || node.children.length < 4)
+                return;
+            const fnName = node.children[1].type === 'symbol' ? node.children[1].name : '';
+            if (!fnName)
+                return;
+            const body = node.children.slice(3);
+            if (hasSelfCall(body, fnName) && !hasConditionalForm(body)) {
+                addIssue('recursive_call', node.pos.line, (0, locale_1.t)('recursive_call', fnName));
+            }
+        });
+    }
+    // variable_shadow (data collection)
+    if (checks['variable_shadow'] !== 'off') {
+        visitor.on('let', node => {
+            if (!node.children || node.children.length < 2)
+                return;
+            const bindings = node.children[1];
+            if (bindings.type !== 'list' || !bindings.children)
+                return;
+            const letVars = new Set();
+            for (const b of bindings.children) {
+                if (b.type === 'list' && b.children && b.children.length > 0 && b.children[0].type === 'symbol' && b.children[0].name) {
+                    letVars.add(b.children[0].name);
+                }
+            }
+            // Walk body for setq of let-bound vars (shallow, don't descend into nested lets)
+            const walkBodyForSetq = (forms) => {
+                for (const form of forms) {
+                    if (form.type === 'list' && form.children && form.children.length > 0 &&
+                        form.children[0].type === 'symbol') {
+                        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 (child.type !== 'symbol' || !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') {
+                            // Don't descend into nested lets
+                            if (form.children) {
+                                walkBodyForSetq(form.children.slice(1));
+                            }
+                        }
+                    }
+                }
+            };
+            walkBodyForSetq(node.children.slice(2));
+        });
+    }
+    // unused_let_binding (data collection)
+    if (checks['unused_let_binding'] !== 'off') {
+        visitor.on('let', node => {
+            if (!node.children || node.children.length < 2)
+                return;
+            const bindings = node.children[1];
+            if (bindings.type !== 'list' || !bindings.children)
+                return;
+            const letVars = [];
+            for (const b of bindings.children) {
+                if (b.type === 'list' && b.children && b.children.length > 0 && b.children[0].type === 'symbol' && 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)) {
+                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));
+                }
+            }
+        });
+    }
+    // defun-based unused checks (unused_parameter, unused_local_fun) - data collection
+    if (checks['unused_parameter'] !== 'off' || checks['unused_local_fun'] !== 'off') {
+        visitor.on('defun', node => {
+            if (!node.children || node.children.length < 4)
+                return;
+            const fnName = node.children[1].type === 'symbol' ? 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 = defunParams(node);
+                if (params.length > 0) {
+                    const bodyRefs = new Set();
+                    for (const form of body) {
+                        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 = defunLocals(node);
+                if (locals.length > 0) {
+                    const bodyRefs = new Set();
+                    for (const form of body) {
+                        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));
+                        }
+                    }
+                }
+            }
+        });
+    }
+    // unused_variable (data collection)
+    if (checks['unused_variable'] !== 'off') {
+        visitor.on('setq', node => {
+            if (!node.children)
+                return;
+            for (let i = 1; i < node.children.length; i += 2) {
+                const varNode = node.children[i];
+                if (varNode.type === 'symbol' && 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 });
+                }
+            }
+        });
+    }
+    // Collect all symbol references for unused_variable
+    if (checks['unused_variable'] !== 'off') {
+        visitor.on('*', node => {
+            if (node.type === 'symbol' && node.name) {
+                state.symbolRefs.add(node.name);
+            }
+        });
+    }
+    // function_complexity (data collection)
+    if (checks['function_complexity'] !== 'off') {
+        visitor.on('defun', node => {
+            if (node.children && node.children.length >= 3) {
+                const fnName = (node.children[1].type === 'symbol' ? node.children[1].name : '<anonymous>') || '<anonymous>';
+                state.defunScopes.push({
+                    name: fnName,
+                    params: [],
+                    body: node.children.slice(3),
+                    line: node.pos.line,
+                    file,
+                });
+            }
+        });
+    }
+    // if_without_else
+    if (checks['if_without_else'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length === 3) {
+                const parent = node.parent;
+                if (parent && parent.type === 'list' && parent.children && parent.children.length > 0 &&
+                    parent.children[0].type === 'symbol') {
+                    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'));
+            }
+        });
+    }
+    // redundant_list
+    if (checks['redundant_list'] !== 'off') {
+        visitor.on('list', node => {
+            if (node.children && node.children.length === 1) {
+                addIssue('redundant_list', node.pos.line, (0, locale_1.t)('redundant_list'));
+            }
+        });
+    }
+    // promise_handler
+    if (checks['promise_handler'] !== 'off') {
+        visitor.on('*', node => {
+            if (node.type === 'list' && node.children && node.children.length > 0 &&
+                node.children[0].type === 'symbol' && node.children[0].name &&
+                (node.children[0].name.startsWith('vlax-invoke') || node.children[0].name.startsWith('vlax-invoke-method'))) {
+                if (isInQuote(node))
+                    return;
+                const parent = node.parent;
+                if (parent && parent.type === 'list' && parent.children && parent.children.length > 0 &&
+                    parent.children[0].type === 'symbol' && parent.children[0].name === 'vl-catch-all-apply') {
+                    return;
+                }
+                let hasCallback = false;
+                for (const child of (node.children || []).slice(1)) {
+                    if (child.type === 'list' && child.children && child.children.length > 0 &&
+                        child.children[0].type === 'symbol' &&
+                        (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'));
+                }
+            }
+        });
+    }
+    visitor.run(ast);
+    // ===== POST-PROCESSING =====
+    // open_without_close
+    if (checks['open_without_close'] !== 'off') {
+        if (state.openCount > state.closeCount) {
+            addIssue('open_without_close', 1, (0, locale_1.t)('open_without_close', String(state.openCount), String(state.closeCount)));
+        }
+    }
+    // dangerous_calls
+    if (checks['quit_exit'] !== 'off') {
+        const dc = config.dangerous_calls;
+        for (const call of state.dangerousCalls) {
+            const sev = config.dangerous_calls[call.name === 'vl-registry-write' ? 'vl_registry_write' : call.name] || 'off';
+            if (sev === 'off')
+                continue;
+            const msgKey = call.name === 'quit' ? 'dangerous.quit' :
+                call.name === 'exit' ? 'dangerous.exit' :
+                    call.name === 'startapp' ? 'dangerous.startapp' :
+                        call.name === 'vl-registry-write' ? 'dangerous.vl_registry_write' : '';
+            if (msgKey) {
+                addIssue(call.name === 'vl-registry-write' ? 'vl_registry_write' : call.name, call.node.pos.line, (0, locale_1.t)(msgKey));
+            }
+        }
+    }
+    // unused_variable
+    if (checks['unused_variable'] !== 'off') {
+        for (const [name, def] of state.setqDefs) {
+            if (state.setqDefs.size > 1) {
+                let refCount = 0;
+                for (const ref of state.symbolRefs) {
+                    if (ref === name)
+                        refCount++;
+                }
+                if (refCount <= 1) {
+                    addIssue('unused_variable', def.line, (0, locale_1.t)('unused_variable', name));
+                }
+            }
+        }
+    }
+    // function_complexity
+    if (checks['function_complexity'] !== 'off') {
+        const maxLines = config.function_complexity.max_lines;
+        const maxNesting = config.function_complexity.max_nesting;
+        for (const scope of state.defunScopes) {
+            let maxLine = scope.line;
+            const computeEnd = (nodes) => {
+                for (const n of nodes) {
+                    if (n.end && n.end.line > maxLine)
+                        maxLine = n.end.line;
+                    if (n.children)
+                        computeEnd(n.children);
+                }
+            };
+            computeEnd(scope.body);
+            const lineCount = maxLine - scope.line + 1;
+            if (lineCount > maxLines) {
+                addIssue('function_complexity', scope.line, (0, locale_1.t)('function_complexity.lines', scope.name, String(lineCount), String(maxLines)));
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=visitor-runner.js.map