@eslint-sh/eslint-plugin 0.7.0 → 0.8.0

package/dist/rules/compat/nounset-array-proof.js

@@ -0,0 +1,563 @@
+/**
+ * Local proofs for the empty-array nounset gate. Facts belong to one sequential
+ * statement list: a successful literal assignment, a static option change, or
+ * a length test whose empty path exits. Calls and compound statements discard
+ * facts instead of guessing their effects. Function/loop/branch bodies start
+ * afresh; only a positive length condition supplies a fact to an if's then arm.
+ *
+ * This is deliberately not a shell interpreter or interprocedural analysis.
+ * Dynamic code, traps and redefined proof builtins disable proofs for the file;
+ * readonly, integer and reference attributes disable local proofs, since an
+ * apparent assignment may fail, write through another name, or evaluate arithmetic. Unknown means
+ * report, never assume safety from source order across execution boundaries.
+ */
+import { AndStmt, AssignUnset, AssignUnsetOrNull, TsEql, TsGeq, TsGtr, TsLeq, TsLss, TsNeq, TsVarSet, } from 'sh-ast';
+import { walkShell } from '../../language/syntax-view.js';
+import { parseSetArguments } from '../set-options.js';
+import { hasSpecialBashIntegerSetter } from '../bash-variable-semantics.js';
+/** No local evidence is available on an unexamined execution path. */
+const UNKNOWN = { nounsetOff: false, nonEmpty: new Set() };
+/** These commands can install effects that outlive a later simple assignment. */
+const DYNAMIC_ENVIRONMENT = new Set([
+    'eval',
+    'source',
+    '.',
+    'trap',
+    'alias',
+    'unalias',
+    'enable',
+    'fc',
+    'read',
+    'mapfile',
+    'readarray',
+    'getopts',
+    'unset',
+    'let',
+]);
+/** Length/exit/option proofs require these names to retain their builtin meaning. */
+const PROOF_BUILTINS = new Set([
+    'set',
+    '[',
+    'test',
+    'return',
+    'exit',
+    'builtin',
+    'command',
+    'printf',
+]);
+/** Numeric [[ tests recursively evaluate their operands as arithmetic. */
+const NUMERIC_TESTS = new Set([
+    TsEql,
+    TsNeq,
+    TsGtr,
+    TsGeq,
+    TsLss,
+    TsLeq,
+]);
+/** Only these simple string conversions are known not to write printf's %n destination. */
+const INERT_PRINTF_FORMAT = /^(?:[^%]|%%|%[sbqc])*$/u;
+/** Fixed unary tests inspect their operand as data, without looking up a variable by name. */
+const INERT_TEST_UNARY = new Set([
+    '!',
+    '-n',
+    '-z',
+    '-a',
+    '-b',
+    '-c',
+    '-d',
+    '-e',
+    '-f',
+    '-g',
+    '-h',
+    '-k',
+    '-p',
+    '-r',
+    '-s',
+    '-t',
+    '-u',
+    '-w',
+    '-x',
+    '-G',
+    '-L',
+    '-N',
+    '-O',
+    '-S',
+]);
+/** Command-based numeric tests parse integers, unlike [[ arithmetic evaluation. */
+const INERT_TEST_BINARY = new Set([
+    '=',
+    '==',
+    '!=',
+    '<',
+    '>',
+    '-eq',
+    '-ne',
+    '-gt',
+    '-ge',
+    '-lt',
+    '-le',
+    '-nt',
+    '-ot',
+    '-ef',
+]);
+/** Names accepted for an ordinary array, excluding arbitrary parameter syntax. */
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+/** These variables hold interpreter state or a trace prefix whose expansions can change that state. */
+function interpreterVariable(name) {
+    return (name !== undefined &&
+        (name.startsWith('BASH_') || name === 'PS4' || hasSpecialBashIntegerSetter(name)));
+}
+/** Redirections can fail before an assignment/builtin; background work need not finish. */
+function sequential(stmt) {
+    return (!stmt.background && !stmt.coprocess && !stmt.disown && !stmt.negated && stmt.redirs.length === 0);
+}
+/** A subscript that cannot evaluate arithmetic, indirection or another command. */
+function wholeArrayIndex(index) {
+    return (index?.type === 'Word' &&
+        index.parts.length === 1 &&
+        index.parts[0].type === 'Lit' &&
+        ['@', '*'].includes(index.parts[0].value));
+}
+/** Words eligible for a proof cannot mutate state while their arguments expand. */
+function inert(node) {
+    switch (node.type) {
+        case 'Word':
+            return node.parts.every(inert);
+        case 'DblQuoted':
+            return !node.dollar && node.parts.every(inert);
+        case 'Lit':
+        case 'SglQuoted':
+            return true;
+        case 'ParamExp':
+            return (node.exp === undefined &&
+                node.slice === undefined &&
+                node.repl === undefined &&
+                !node.excl &&
+                !node.width &&
+                !node.isset &&
+                node.modifiers.length === 0 &&
+                (node.index === undefined || wholeArrayIndex(node.index)));
+        default:
+            return false;
+    }
+}
+/**
+ * Binds a proof query to one parsed file. The rule retains responsibility for
+ * selecting expansions and version gating; this helper only answers safety.
+ * @internal
+ */
+export function createArraySafetyProof(source) {
+    let dynamicEnvironment = false;
+    let variableAttributes = false;
+    /** One snapshot per statement; the first lookup fills the entire sibling list. */
+    // eslint-disable-next-line @api-extractor-tools/forgotten-export -- Cached entry facts are closure-private and are not exposed by the exported query.
+    const before = new WeakMap();
+    walkShell(source.ast, (node) => {
+        if (node.type === 'FuncDecl' &&
+            (!IDENTIFIER.test(node.name?.value ?? '') || PROOF_BUILTINS.has(node.name?.value ?? ''))) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'CallExpr' && node.args.length > 0) {
+            const args = node.args.map((word) => source.resolveWordText(word));
+            let index = 0;
+            // Wrappers do not make dynamic code or attribute writes transparent.
+            while (args[index] === 'builtin' || args[index] === 'command') {
+                index += 1;
+                while (args[index]?.startsWith('-')) {
+                    const option = args[index];
+                    if (option !== '--' && option !== '-p') {
+                        dynamicEnvironment = true;
+                    }
+                    index += 1;
+                    if (option === '--') {
+                        break;
+                    }
+                }
+            }
+            const name = args.at(index);
+            if (name === null || name === undefined || DYNAMIC_ENVIRONMENT.has(name)) {
+                dynamicEnvironment = true;
+            }
+            if ((name === '[' || name === 'test') && !inertTest(name, node.args.slice(index + 1))) {
+                dynamicEnvironment = true;
+            }
+            if (name === 'printf' && !inertPrintf(args.slice(index + 1))) {
+                dynamicEnvironment = true;
+            }
+            if (name !== null &&
+                name !== undefined &&
+                ['declare', 'local', 'typeset', 'readonly', 'nameref', 'export'].includes(name)) {
+                variableAttributes = true;
+            }
+        }
+        // for/select bind their variable without an Assign node; special setters still run.
+        if (node.type === 'WordIter' &&
+            (node.name === undefined ||
+                !IDENTIFIER.test(node.name.value) ||
+                interpreterVariable(node.name.value))) {
+            dynamicEnvironment = true;
+        }
+        // Special Bash arrays can install aliases or other interpreter state.
+        if (node.type === 'Assign' && interpreterVariable(node.name?.value)) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'ParamExp' &&
+            interpreterVariable(node.param?.value) &&
+            (node.exp?.op === AssignUnset || node.exp?.op === AssignUnsetOrNull)) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'DeclClause') {
+            const attributes = node.variant?.value !== 'export';
+            variableAttributes ||=
+                ['readonly', 'nameref'].includes(node.variant?.value ?? '') ||
+                    node.args.some((arg) => {
+                        if (!arg.naked) {
+                            return false;
+                        }
+                        if (arg.name !== undefined) {
+                            return !IDENTIFIER.test(arg.name.value);
+                        }
+                        const text = arg.value === undefined ? null : source.resolveWordText(arg.value);
+                        // A naked declaration word can introduce options or an assignment at runtime.
+                        return (text === null ||
+                            (text !== '--' && !/^[-+][A-Za-z]+$/u.test(text)) ||
+                            (attributes && /^-[^-]*[rniA]/u.test(text)));
+                    });
+        }
+        // Arithmetic operands can recursively evaluate variable text and write interpreter arrays.
+        if ((node.type === 'ArithmCmd' || node.type === 'ArithmExp') && !simpleArithmetic(node.x)) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'BinaryArithm' ||
+            node.type === 'UnaryArithm' ||
+            node.type === 'LetClause' ||
+            node.type === 'CStyleLoop' ||
+            node.type === 'CoprocClause') {
+            dynamicEnvironment = true;
+        }
+        if ((node.type === 'Assign' || node.type === 'ArrayElem') &&
+            node.index !== undefined &&
+            !simpleArithmetic(node.index)) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'ParamExp' &&
+            (node.excl ||
+                node.slice !== undefined ||
+                (node.index !== undefined && !wholeArrayIndex(node.index) && !simpleArithmetic(node.index)))) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'BinaryTest' &&
+            NUMERIC_TESTS.has(node.op) &&
+            (!simpleArithmetic(node.x) || !simpleArithmetic(node.y))) {
+            dynamicEnvironment = true;
+        }
+        // Translated text is expanded by the shell, beyond the syntax visible here.
+        if (node.type === 'DblQuoted' && node.dollar) {
+            dynamicEnvironment = true;
+        }
+        if (node.type === 'UnaryTest' && node.op === TsVarSet) {
+            dynamicEnvironment = true;
+        }
+    });
+    /** The named array's length as a single quoted or unquoted word. */
+    function lengthName(word, quotedOnly = false) {
+        if (word?.type !== 'Word' || word.parts.length !== 1) {
+            return undefined;
+        }
+        const part = word.parts[0];
+        if (quotedOnly && (part.type !== 'DblQuoted' || part.dollar)) {
+            return undefined;
+        }
+        const exp = part.type === 'DblQuoted' && part.parts.length === 1 ? part.parts[0] : part;
+        if (exp.type !== 'ParamExp' || !exp.length || !inert(exp) || !wholeArrayIndex(exp.index)) {
+            return undefined;
+        }
+        const name = exp.param?.value;
+        return name !== undefined && IDENTIFIER.test(name) ? name : undefined;
+    }
+    /** Literal integers and direct array lengths cannot recursively evaluate variable text. */
+    function simpleArithmetic(node) {
+        return (lengthName(node) !== undefined ||
+            (node?.type === 'Word' && /^\d+$/u.test(source.resolveWordText(node) ?? '')));
+    }
+    /** Only ordinary destinations and known string formats rule out persistent printf writes. */
+    function inertPrintf(args) {
+        let index = 0;
+        if (args[0] === '-v') {
+            const destination = args.at(1);
+            if (destination === null ||
+                destination === undefined ||
+                !IDENTIFIER.test(destination) ||
+                interpreterVariable(destination) ||
+                destination === 'FUNCNAME') {
+                return false;
+            }
+            index = 2;
+        }
+        const ended = args[index] === '--';
+        if (ended) {
+            index += 1;
+        }
+        const format = args.at(index);
+        return (format !== null &&
+            format !== undefined &&
+            (ended || !format.startsWith('-')) &&
+            INERT_PRINTF_FORMAT.test(format));
+    }
+    /** A quoted scalar is one test operand; array/positional @ expansions can inject operators. */
+    function singleTestArgument(word) {
+        if (source.resolveWordText(word) !== null) {
+            return true;
+        }
+        if (word.parts.length !== 1 || word.parts[0].type !== 'DblQuoted' || word.parts[0].dollar) {
+            return false;
+        }
+        let single = true;
+        walkShell(word.parts[0], (part) => {
+            if (part.type === 'ParamExp' &&
+                !part.length &&
+                (part.param?.value === '@' ||
+                    (part.index !== undefined &&
+                        wholeArrayIndex(part.index) &&
+                        source.getText(part.index) === '@'))) {
+                single = false;
+            }
+        });
+        return single;
+    }
+    /** Fixed test operators plus one-word operands exclude hidden -v/-R variable-name evaluation. */
+    function inertTest(name, words) {
+        const args = [...words];
+        if (name === '[') {
+            const close = args.at(-1);
+            if (close === undefined || source.resolveWordText(close) !== ']') {
+                return false;
+            }
+            args.pop();
+        }
+        if (!args.every(singleTestArgument)) {
+            return false;
+        }
+        if (args.length < 2) {
+            return true;
+        }
+        if (args.length === 2) {
+            return INERT_TEST_UNARY.has(source.resolveWordText(args[0]) ?? '');
+        }
+        return args.length === 3 && INERT_TEST_BINARY.has(source.resolveWordText(args[1]) ?? '');
+    }
+    /** Exact zero/nonzero length predicates, with no other commands or arithmetic. */
+    function testedArray(stmt, empty) {
+        if (!sequential(stmt)) {
+            return undefined;
+        }
+        const cmd = stmt.cmd;
+        if (cmd?.type === 'CallExpr' && cmd.assigns.length === 0) {
+            const name = source.getCommandName(cmd);
+            const args = cmd.args.slice(1);
+            if (name === '[' &&
+                args.length > 0 &&
+                source.resolveWordText(args[args.length - 1]) === ']') {
+                args.pop();
+            }
+            else if (name !== 'test') {
+                return undefined;
+            }
+            if (args.length !== 3 || source.resolveWordText(args[2]) !== '0') {
+                return undefined;
+            }
+            const op = source.resolveWordText(args[1]);
+            if (empty ? op !== '-eq' : op !== '-gt' && op !== '-ne') {
+                return undefined;
+            }
+            return lengthName(args[0], true);
+        }
+        if (cmd?.type === 'TestClause' && cmd.x?.type === 'BinaryTest') {
+            const { op, x, y } = cmd.x;
+            if (y?.type !== 'Word' || source.resolveWordText(y) !== '0') {
+                return undefined;
+            }
+            if (empty ? op !== TsEql : op !== TsGtr && op !== TsNeq) {
+                return undefined;
+            }
+            return lengthName(x);
+        }
+        if (!empty && cmd?.type === 'ArithmCmd') {
+            return lengthName(cmd.x);
+        }
+        return undefined;
+    }
+    /** A return exits only a function here; a standalone file might not be sourced. */
+    function exits(stmt) {
+        if (!sequential(stmt) || stmt.cmd?.type !== 'CallExpr' || stmt.cmd.assigns.length > 0) {
+            return false;
+        }
+        const cmd = stmt.cmd;
+        const name = source.getCommandName(cmd);
+        if (name !== 'exit' && name !== 'return') {
+            return false;
+        }
+        if (cmd.args.length > 2) {
+            return false;
+        }
+        if (cmd.args.length === 2 && !/^\d{1,3}$/u.test(source.resolveWordText(cmd.args[1]) ?? '')) {
+            return false;
+        }
+        if (name === 'exit') {
+            return true;
+        }
+        for (let up = source.getParent(stmt); up !== undefined; up = source.getParent(up)) {
+            if (up.type === 'FuncDecl') {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Literal members cannot disappear through splitting or nullglob. Quoted empty
+     * strings count as members; an unquoted pattern or a computed word does not.
+     */
+    function literalArray(assign) {
+        return (!variableAttributes &&
+            assign.name?.value !== 'FUNCNAME' &&
+            !assign.append &&
+            assign.index === undefined &&
+            assign.array !== undefined &&
+            assign.array.elems.length > 0 &&
+            assign.array.elems.every((elem) => elem.index === undefined &&
+                elem.value !== undefined &&
+                source.resolveWordText(elem.value) !== null));
+    }
+    /** Ordinary assignments preserve other names only when no expansion can write indirectly. */
+    function inertAssignment(assign) {
+        return (assign.index === undefined &&
+            !assign.naked &&
+            (assign.value === undefined || inert(assign.value)) &&
+            (assign.array === undefined ||
+                assign.array.elems.every((elem) => elem.index === undefined && elem.value !== undefined && inert(elem.value))));
+    }
+    /** Transfer only the few operations whose successful effect is known locally. */
+    function after(stmt, facts) {
+        if (!sequential(stmt)) {
+            return UNKNOWN;
+        }
+        const cmd = stmt.cmd;
+        if (cmd?.type === 'BinaryCmd' &&
+            cmd.op === AndStmt &&
+            cmd.x !== undefined &&
+            cmd.y !== undefined &&
+            exits(cmd.y)) {
+            const name = testedArray(cmd.x, true);
+            if (name !== undefined && !variableAttributes) {
+                return { nounsetOff: facts.nounsetOff, nonEmpty: new Set([...facts.nonEmpty, name]) };
+            }
+        }
+        if (cmd?.type !== 'CallExpr') {
+            return UNKNOWN;
+        }
+        if (cmd.args.length === 0 && cmd.assigns.every(inertAssignment)) {
+            const nonEmpty = new Set(facts.nonEmpty);
+            for (const assign of cmd.assigns) {
+                const name = assign.name?.value;
+                if (name === undefined) {
+                    return UNKNOWN;
+                }
+                nonEmpty.delete(name);
+                if (literalArray(assign)) {
+                    nonEmpty.add(name);
+                }
+            }
+            return { nounsetOff: facts.nounsetOff, nonEmpty };
+        }
+        if (source.getCommandName(cmd) === 'set' && cmd.assigns.length === 0) {
+            const parsed = parseSetArguments(cmd.args.slice(1).map((arg) => source.resolveWordText(arg)));
+            if (parsed.stoppedBy === 'unknown' || parsed.stoppedBy === 'malformed') {
+                return UNKNOWN;
+            }
+            let nounsetOff = facts.nounsetOff;
+            for (const change of parsed.changes) {
+                if (change.option === 'nounset') {
+                    nounsetOff = !change.enable;
+                }
+            }
+            return { nounsetOff, nonEmpty: facts.nonEmpty };
+        }
+        return UNKNOWN;
+    }
+    /** A list is a proof boundary, rather than evidence that neighboring lists ran. */
+    function siblings(stmt) {
+        const parent = source.getParent(stmt);
+        switch (parent?.type) {
+            case 'File':
+            case 'Block':
+            case 'Subshell':
+            case 'CaseItem':
+                return parent.stmts;
+            case 'IfClause':
+                return parent.then.includes(stmt) ? parent.then : parent.cond;
+            case 'ForClause':
+                return parent.do;
+            case 'WhileClause':
+                return parent.do.includes(stmt) ? parent.do : parent.cond;
+            default:
+                return [];
+        }
+    }
+    /** Entry facts never cross functions or loops; an if condition can prove its then arm. */
+    function entry(stmt) {
+        const cached = before.get(stmt);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const parent = source.getParent(stmt);
+        // The left side of &&/|| runs first; no evidence flows to their right side.
+        if (parent?.type === 'BinaryCmd' && parent.x === stmt) {
+            const outer = source.getParent(parent);
+            return outer?.type === 'Stmt' ? entry(outer) : UNKNOWN;
+        }
+        let facts = UNKNOWN;
+        if (!variableAttributes &&
+            parent?.type === 'IfClause' &&
+            parent.then.includes(stmt) &&
+            parent.cond.length === 1) {
+            const name = testedArray(parent.cond[0], false);
+            if (name !== undefined) {
+                facts = { nounsetOff: false, nonEmpty: new Set([name]) };
+            }
+        }
+        for (const sibling of siblings(stmt)) {
+            before.set(sibling, facts);
+            facts = after(sibling, facts);
+        }
+        return before.get(stmt) ?? UNKNOWN;
+    }
+    return (node, name) => {
+        if (dynamicEnvironment || variableAttributes) {
+            return false;
+        }
+        let stmt = source.getParent(node);
+        while (stmt !== undefined && stmt.type !== 'Stmt') {
+            stmt = source.getParent(stmt);
+        }
+        if (stmt?.type !== 'Stmt' || !sequential(stmt)) {
+            return false;
+        }
+        const cmd = stmt.cmd;
+        if (cmd?.type === 'CallExpr') {
+            if (cmd.assigns.length > 0 || !cmd.args.every(inert)) {
+                return false;
+            }
+        }
+        else if (cmd?.type === 'ForClause' && cmd.loop?.type === 'WordIter') {
+            if (!cmd.loop.items.every(inert) ||
+                !cmd.loop.items.some((word) => word.range[0] <= node.range[0] && word.range[1] >= node.range[1])) {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+        const facts = entry(stmt);
+        return facts.nounsetOff || facts.nonEmpty.has(name);
+    };
+}

package/dist/rules/compat/posix-absent-command.d.ts

@@ -1,12 +1,11 @@
-import type { ShellSourceCode } from '../../language/shell-source-code.js';
+import type { TransparentWrappersBindingContext } from '../resolve-transparent-wrappers.js';
 import type { ShellNode, ShellNodeOf } from '../../language/syntax-view.js';
 /**
- * The word that names `command` in `node`, when `command` is what `node`
- * effectively runs and a shell without it can reach `node` (see the module
- * comment), or `undefined` otherwise. Reporting this word rather than the whole
- * command matters for `[[`: the parser ends that command at the first `&&` or
- * `||`, so the node would cover an arbitrary part of the expression.
- *
+ * Builds a lookup for the word that names `command` when an invocation runs it
+ * and the target shell can reach it outside a shell-version guard. Resolve
+ * the wrapper table once for the file, rather than once per invocation.
+ * Reporting this word matters for `[[`: the parser can end that command at
+ * the first boolean operator, so the whole node is not the expression.
  * @internal
  */
-export declare function reachableCommandWord(sourceCode: ShellSourceCode, node: ShellNodeOf<'CallExpr'>, command: string): ShellNode | undefined;
+export declare function reachableCommandWord(context: TransparentWrappersBindingContext, command: string): (node: ShellNodeOf<'CallExpr'>) => ShellNode | undefined;

package/dist/rules/compat/posix-absent-command.js

@@ -23,6 +23,7 @@
  * reports.
  */
 import { DEFAULT_TRANSPARENT_WRAPPERS } from 'sh-ast/analyze';
+import { resolveTransparentWrappers } from '../resolve-transparent-wrappers.js';
 import { BUILTIN_WRAPPER } from '../transparent-wrappers.js';
 /**
  * The wrappers followed to find the command an invocation runs:
@@ -114,21 +115,22 @@ function isGuarded(sourceCode, node) {
     return false;
 }
 /**
- * The word that names `command` in `node`, when `command` is what `node`
- * effectively runs and a shell without it can reach `node` (see the module
- * comment), or `undefined` otherwise. Reporting this word rather than the whole
- * command matters for `[[`: the parser ends that command at the first `&&` or
- * `||`, so the node would cover an arbitrary part of the expression.
- *
+ * Builds a lookup for the word that names `command` when an invocation runs it
+ * and the target shell can reach it outside a shell-version guard. Resolve
+ * the wrapper table once for the file, rather than once per invocation.
+ * Reporting this word matters for `[[`: the parser can end that command at
+ * the first boolean operator, so the whole node is not the expression.
  * @internal
  */
-export function reachableCommandWord(sourceCode, node, command) {
-    const invoked = sourceCode.resolveInvokedCommand(node, {
-        transparentWrappers: TRANSPARENT_WRAPPERS,
-    });
-    if (invoked?.effective.static !== true || invoked.effective.text !== command)
-        return undefined;
-    if (isGuarded(sourceCode, node))
-        return undefined;
-    return node.args[invoked.chainIndices.at(-1) ?? 0];
+export function reachableCommandWord(context, command) {
+    const { sourceCode } = context;
+    const transparentWrappers = resolveTransparentWrappers(context, TRANSPARENT_WRAPPERS);
+    return (node) => {
+        const invoked = sourceCode.resolveInvokedCommand(node, { transparentWrappers });
+        if (invoked?.effective.static !== true || invoked.effective.text !== command)
+            return undefined;
+        if (isGuarded(sourceCode, node))
+            return undefined;
+        return node.args[invoked.chainIndices.at(-1) ?? 0];
+    };
 }

package/dist/rules/compat/shopt-options.js

@@ -10,6 +10,7 @@
  * static word cannot be read, so none of those count.
  */
 import { DEFAULT_TRANSPARENT_WRAPPERS } from 'sh-ast/analyze';
+import { resolveTransparentWrappers } from '../resolve-transparent-wrappers.js';
 import { BUILTIN_WRAPPER } from '../transparent-wrappers.js';
 /**
  * The wrappers followed to find the `shopt` command: `sh-ast/analyze`'s
@@ -27,10 +28,11 @@ const TRANSPARENT_WRAPPERS = [
  */
 export function shoptEnableVisitor(context, option, report) {
     const { sourceCode } = context;
+    const transparentWrappers = resolveTransparentWrappers(context, TRANSPARENT_WRAPPERS);
     return {
         CallExpr(node) {
             const invoked = sourceCode.resolveInvokedCommand(node, {
-                transparentWrappers: TRANSPARENT_WRAPPERS,
+                transparentWrappers,
             });
             if (invoked?.effective.static !== true || invoked.effective.text !== 'shopt')
                 return;