@blumintinc/eslint-plugin-blumint 1.21.13 → 1.21.15

package/lib/rules/global-const-style.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 const isUpperSnakeCase = (str) => /^[A-Z][A-Z0-9_]*$/.test(str);
 /**
@@ -270,6 +271,68 @@ const isMutatingMethodCall = (path) => {
     return (callee.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
         callee.parent.callee === callee);
 };
+/**
+ * The mutating methods that INSERT a value into the receiver, mapped to the
+ * argument positions that value can occupy.
+ *
+ * The positions are carried per method rather than taken as "every argument",
+ * because two of these spend leading or trailing arguments on INDICES:
+ * `splice(start, deleteCount, ...items)` inserts from the third argument on,
+ * and `fill(value, start, end)` inserts at the first alone.
+ *
+ * `sort`, `reverse`, `pop`, `shift` and `copyWithin` are absent because they
+ * insert nothing — they reorder, remove or copy elements the receiver already
+ * holds, so no element type can reject what they write. (`sort`'s argument is a
+ * comparator function, `copyWithin`'s three are indices.)
+ */
+const INSERTED_VALUE_POSITIONS_BY_METHOD = new Map([
+    ['push', { first: 0 }],
+    ['unshift', { first: 0 }],
+    ['splice', { first: 2 }],
+    ['fill', { first: 0, last: 0 }],
+]);
+/**
+ * Whether a mutating call INTRODUCES a value the receiver's element type would
+ * have to accept from outside the constant.
+ *
+ * This is the question that decides a mutating call through a receiver-array
+ * parameter the lib declares MUTABLE, where no readonly violation is possible
+ * and the only way the assertion can break the call is by narrowing what the
+ * array accepts — see `MUTABLE_ARRAY_PARAMETER_METHODS`. Three answers, and the
+ * boundary sits between the second and the third:
+ *
+ * - a method that inserts nothing (`arr.sort()`) cannot narrow-break, because
+ *   it writes back only elements the receiver already holds;
+ * - an inserted value that is a REFERENCE to a binding already enrolled for
+ *   this constant (`arr.push(item)`, where `item` is the element the callback
+ *   was handed) is typed from the constant itself, so the assertion narrows the
+ *   argument and the parameter together and the call keeps compiling;
+ * - an inserted value from anywhere else (`arr.push({ n: 3 })`) is typed
+ *   independently of the constant, so narrowing the element type can reject it:
+ *   TS2322 for an input that compiled (Issue #2340).
+ *
+ * A SPREAD argument is treated as introducing a foreign value even when it
+ * spreads the constant. Its elements do satisfy the narrowed type, so this
+ * withholds the assertion from a call that would have compiled — the cheap
+ * error of the two, and the one this predicate exists to prefer.
+ */
+const introducesForeignElement = (path, isEnrolledReference) => {
+    const method = accessedPropertyName(path);
+    const positions = method === null
+        ? undefined
+        : INSERTED_VALUE_POSITIONS_BY_METHOD.get(method);
+    if (!positions) {
+        return false;
+    }
+    const call = outermostValueOf(path).parent;
+    if (call?.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const last = positions.last ?? call.arguments.length - 1;
+    return call.arguments
+        .slice(positions.first, last + 1)
+        .some((argument) => !isEnrolledReference(argument));
+};
 /**
  * Whether `node` sits in a position that writes to it: the left of an
  * assignment (plain or compound), the operand of `++`/`--` or `delete`, the
@@ -396,14 +459,123 @@ const isStructuredCloneCallee = (callee) => {
     const value = outermostValueOf(callee);
     return (value.type === utils_1.AST_NODE_TYPES.Identifier && value.name === 'structuredClone');
 };
+const FUNCTION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.FunctionDeclaration,
+    utils_1.AST_NODE_TYPES.FunctionExpression,
+    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    utils_1.AST_NODE_TYPES.TSDeclareFunction,
+]);
+/**
+ * The identifier an ACCESS PATH is rooted at — `x` for `x`, `x.n`, `x.a[0]`,
+ * `x?.n` and `x!.n` alike — or the expression itself when it is not an access
+ * path at all. Descends through the wrappers `outermostValueOf` climbs out of,
+ * so the root cannot depend on which type syntax annotates a step of the path.
+ */
+const accessPathRootOf = (node) => {
+    let current = unwrapValueWrappers(node);
+    for (;;) {
+        if (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+            current = unwrapValueWrappers(current.expression);
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            current = unwrapValueWrappers(current.object);
+            continue;
+        }
+        return current;
+    }
+};
+/**
+ * Every value a function hands back: its expression body, or the argument of
+ * each `return` in its block.
+ *
+ * Descent stops at a nested function, whose `return` answers for THAT function
+ * rather than this one — the same boundary `ASTHelpers.hasReturnStatement`
+ * keeps, for the same reason.
+ */
+const returnedValuesOf = (callback) => {
+    if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return [callback.body];
+    }
+    const returned = [];
+    const visit = (node) => {
+        if (FUNCTION_TYPES.has(node.type)) {
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+            if (node.argument) {
+                returned.push(node.argument);
+            }
+            return;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'parent') {
+                continue;
+            }
+            for (const child of Array.isArray(value) ? value : [value]) {
+                if (ASTHelpers_1.ASTHelpers.isNode(child)) {
+                    visit(child);
+                }
+            }
+        }
+    };
+    visit(callback.body);
+    return returned;
+};
+/**
+ * Whether a callback hands back the value it is given at `elementIndex`, or an
+ * access path rooted at it.
+ *
+ * This is what decides whether a `map`-shaped call keeps the receiver's element
+ * type. `(x) => x.n` over a frozen `[{ n: 1 }]` yields `1[]` rather than
+ * `number[]`, so `ns.push(3)` is TS2345 for an input that compiled — and that
+ * mapper is the commonest one written, not the no-op spelling the exclusion was
+ * justified against (Issue #2342). A callback that COMPUTES (`(x) => x * 2`,
+ * `() => Math.random()`) widens, carries nothing of the constant into its
+ * result, and keeps its report.
+ *
+ * The parameter is matched by NAME within the callback's own body, the single
+ * span this question is asked over, because a derivation resolver is handed a
+ * node and no scope. A name a nested function rebinds is unreachable — descent
+ * stops at every function boundary — so the worst a shadow can do is withhold
+ * the assertion from a call that would have kept it, the cheap error of the two.
+ *
+ * ANY returned value rooted at the element is enough. Branches returning
+ * different things widen their union, so the assertion may then reach nothing
+ * and the withhold costs a report; demanding EVERY branch would instead ship a
+ * `--fix` that stops the file compiling.
+ */
+const returnsHandedElement = (callback, elementIndex) => {
+    if (!callback || !isFunctionValue(callback)) {
+        return false;
+    }
+    const parameter = callback.params[elementIndex];
+    if (!parameter || parameter.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return returnedValuesOf(callback).some((value) => {
+        const root = accessPathRootOf(value);
+        return (root.type === utils_1.AST_NODE_TYPES.Identifier && root.name === parameter.name);
+    });
+};
+/**
+ * The position the receiver's element arrives in for `Array.from`'s mapper.
+ *
+ * Named because the mapper is the SECOND argument while its element is the
+ * first parameter, so two different zeroes and ones sit beside each other here.
+ */
+const ARRAY_FROM_MAPPER_ELEMENT_INDEX = 0;
 /**
  * Whether a call COPIES the argument at `index` while keeping its type.
  *
  * `Array.from(X)` and `structuredClone(X)` both hand back a fresh, mutable
  * value whose element or property types are the argument's — so freezing the
- * argument narrows the copy exactly as a spread does. `Array.from(X, fn)` is
- * excluded for the same reason `map` is: a mapper retypes the result, so
- * nothing of the constant's type survives into it.
+ * argument narrows the copy exactly as a spread does.
+ *
+ * `Array.from(X, fn)` is decided per CALL for the reason `map` is: a mapper
+ * that hands back the element or a property of it keeps the frozen type, so
+ * `Array.from(ITEMS, (x) => x.n)` is TS2345 on a later `push` for an input that
+ * compiled, while a mapper that COMPUTES widens and carries nothing.
  */
 const isCopyingCall = (call, index) => {
     if (isObjectAssignCallee(call.callee)) {
@@ -416,16 +588,26 @@ const isCopyingCall = (call, index) => {
         return true;
     }
     if (isNamespacedCallee(call.callee, 'Array', 'from')) {
-        return call.arguments.length === 1;
+        return (call.arguments.length === 1 ||
+            returnsHandedElement(call.arguments[1], ARRAY_FROM_MAPPER_ELEMENT_INDEX));
     }
     return false;
 };
 /**
- * Array methods whose result keeps the receiver's ELEMENT type. `map` is
- * absent because its result is typed from the CALLBACK, so the constant's type
- * reaches it only for a callback that returns its argument unchanged — a no-op
- * `map`. Admitting it would withhold the assertion from every derived array
- * anything is computed from, to cover a spelling nobody writes.
+ * The copying array methods whose result is typed from a CALLBACK, mapped to
+ * the position the receiver's element arrives in.
+ *
+ * They are carried apart from `TYPE_PRESERVING_COPY_METHODS` because the
+ * question they raise is answered per CALL rather than per method — see
+ * `returnsHandedElement`.
+ */
+const CALLBACK_TYPED_COPY_METHODS = new Map([['map', 0]]);
+/**
+ * Array methods whose result keeps the receiver's ELEMENT type WHATEVER the
+ * call spells: nothing they are passed can retype what they hand back.
+ *
+ * `map` is carried separately rather than absent — see
+ * `CALLBACK_TYPED_COPY_METHODS`.
  */
 const TYPE_PRESERVING_COPY_METHODS = new Set([
     'concat',
@@ -476,15 +658,66 @@ const copyExpressionOf = (node) => {
         const callee = outermostValueOf(parent);
         // A method REFERENCE (`const take = ITEMS.concat;`) builds nothing, so the
         // copy only exists once the method is actually called.
-        if (method !== null &&
-            TYPE_PRESERVING_COPY_METHODS.has(method) &&
-            callee.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
-            callee.parent.callee === callee) {
+        if (method === null ||
+            callee.parent?.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+            callee.parent.callee !== callee) {
+            return null;
+        }
+        if (TYPE_PRESERVING_COPY_METHODS.has(method)) {
             return callee.parent;
         }
+        const elementIndex = CALLBACK_TYPED_COPY_METHODS.get(method);
+        return elementIndex !== undefined &&
+            returnsHandedElement(callee.parent.arguments[0], elementIndex)
+            ? callee.parent
+            : null;
     }
     return null;
 };
+/**
+ * Array methods whose result is an ELEMENT of the receiver rather than a fresh
+ * array over it.
+ *
+ * `as const` freezes in depth, so the element they hand back carries the
+ * assertion exactly as one reached by index does: `const first = ITEMS.at(0)!;
+ * first.n = 2;` is TS2540 once `ITEMS` is frozen, for an input that compiled
+ * (Issue #2341). They belong with the element family rather than with
+ * `TYPE_PRESERVING_COPY_METHODS`, whose members hand back a container.
+ */
+const ELEMENT_RETURNING_METHODS = new Set(['at', 'find', 'findLast']);
+/**
+ * The folds whose result is an element of the receiver, in the SEEDLESS
+ * spelling alone.
+ *
+ * `ITEMS.reduce((a, b) => b)` is typed `T` because the overload without an
+ * initial value takes the first element as the seed. Given a seed the result is
+ * typed from THAT value, which the constant need not have given —
+ * `NUMS.reduce((sum, n) => sum + n, 0)` is `number` however `NUMS` is frozen —
+ * so enrolling the seeded spelling would withhold the assertion for a break
+ * that cannot happen.
+ */
+const ELEMENT_FOLD_METHODS = new Set(['reduce', 'reduceRight']);
+/** The call that hands back an ELEMENT of this value — see the two sets above. */
+const elementExpressionOf = (node) => {
+    const parent = node.parent;
+    if (parent?.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        parent.object !== node) {
+        return null;
+    }
+    const method = accessedPropertyName(parent);
+    if (method === null) {
+        return null;
+    }
+    const callee = outermostValueOf(parent);
+    const call = callee.parent;
+    if (call?.type !== utils_1.AST_NODE_TYPES.CallExpression || call.callee !== callee) {
+        return null;
+    }
+    return ELEMENT_RETURNING_METHODS.has(method) ||
+        (ELEMENT_FOLD_METHODS.has(method) && call.arguments.length === 1)
+        ? call
+        : null;
+};
 /** Pattern nodes a parameter's binding can be nested inside. */
 const PATTERN_CONTAINERS = new Set([
     utils_1.AST_NODE_TYPES.AssignmentPattern,
@@ -497,12 +730,6 @@ const PATTERN_CONTAINERS = new Set([
     // constructor's params and `constructor(public stage = DEFAULT)` narrows.
     utils_1.AST_NODE_TYPES.TSParameterProperty,
 ]);
-const FUNCTION_TYPES = new Set([
-    utils_1.AST_NODE_TYPES.FunctionDeclaration,
-    utils_1.AST_NODE_TYPES.FunctionExpression,
-    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
-    utils_1.AST_NODE_TYPES.TSDeclareFunction,
-]);
 /**
  * Whether a default value is what a PARAMETER's type is inferred FROM.
  *
@@ -625,12 +852,12 @@ const ELEMENT_PARAMETER_INDEX_BY_METHOD = new Map([
  * `reduce`/`reduceRight` push it to fourth, having spent the first position on
  * the accumulator.
  *
- * `flatMap` is listed even though its lib signature declares the parameter
- * `T[]` where every sibling declares it `readonly T[]` — measured against
- * `lib.es2020`, so a mutating METHOD through it survives the assertion. Its
- * ELEMENTS are frozen regardless, so `arr[0].n = 2` inside a `flatMap` callback
- * is TS2540 for an input that compiled, and the walk's write check reaches it
- * only once the parameter is enrolled.
+ * `flatMap` is listed for its ELEMENTS alone. Its lib signature declares the
+ * parameter `T[]` where every sibling declares it `readonly T[]` — measured
+ * against `lib.es2020` — so `arr[0].n = 2` inside a `flatMap` callback is
+ * TS2540 for an input that compiled, while a mutating method called through the
+ * parameter compiles unchanged. `MUTABLE_ARRAY_PARAMETER_METHODS` carries that
+ * second half, which enrolment alone cannot express (Issue #2340).
  */
 const ARRAY_PARAMETER_INDEX_BY_METHOD = new Map([
     ['forEach', 2],
@@ -646,6 +873,26 @@ const ARRAY_PARAMETER_INDEX_BY_METHOD = new Map([
     ['reduce', 3],
     ['reduceRight', 3],
 ]);
+/**
+ * The methods above whose receiver-array parameter is declared MUTABLE `T[]`.
+ *
+ * Enrolling that parameter answers two questions at once, and each needs its own
+ * answer. Its ELEMENTS are frozen with the constant, so an element write through
+ * it is TS2540 and the assertion is withheld. A mutating METHOD through it is no
+ * readonly violation at all — the declared type is mutable, so there is no
+ * TS2339 to have — and withholding the assertion for one costs a report for a
+ * break that does not happen: `ITEMS.flatMap((x, i, arr) => { arr.sort(); return
+ * [x]; })` and the `arr.push(x)` spelling both compile under the assertion,
+ * measured by appending it by hand and reading the checker.
+ *
+ * What such a call CAN break is assignability, and only by introducing a value
+ * from outside the constant: `arr.push({ n: 3 })` is TS2322 once the assertion
+ * narrows the element type. That is decided per CALL by
+ * `introducesForeignElement`, not per method — an exemption keyed on the method
+ * alone would trade two over-declines for a `--fix` that stops the file
+ * compiling, which is the defect this walk exists to prevent (Issue #2340).
+ */
+const MUTABLE_ARRAY_PARAMETER_METHODS = new Set(['flatMap']);
 /**
  * The `Object.values(X)` / `Object.entries(X)` call this value feeds — a fresh
  * array whose ELEMENTS are the constant's own property values, so freezing the
@@ -670,6 +917,399 @@ const elementProjectionCallOf = (node) => {
         ? parent
         : null;
 };
+/**
+ * Constructors that build a collection out of the argument's ELEMENTS.
+ *
+ * `new Set(ITEMS)` holds the constant's own contents, so iterating it hands out
+ * the frozen elements and `for (const item of new Set(ITEMS)) { item.n = 2; }`
+ * is TS2540 for an input that compiled (Issue #2340).
+ *
+ * The construction is not a copy in `copyExpressionOf`'s sense — the result has
+ * a different shape from the argument, so a write to the collection says
+ * nothing about the constant — which is why it is resolved here, where only the
+ * ITERATION question is asked. `WeakSet`/`WeakMap` are absent because they are
+ * not iterable, so no binding can be taken from one.
+ */
+const ELEMENT_PRESERVING_COLLECTION_NAMES = new Set(['Set', 'Map']);
+/** Whether an expression CONSTRUCTS one of those collections. */
+const isElementPreservingCollection = (node) => {
+    const value = unwrapValueWrappers(node);
+    if (value.type !== utils_1.AST_NODE_TYPES.NewExpression) {
+        return false;
+    }
+    const callee = unwrapValueWrappers(value.callee);
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        ELEMENT_PRESERVING_COLLECTION_NAMES.has(callee.name));
+};
+const elementCollectionOf = (node) => {
+    const parent = node.parent;
+    return parent?.type === utils_1.AST_NODE_TYPES.NewExpression &&
+        parent.arguments[0] === node &&
+        isElementPreservingCollection(parent)
+        ? parent
+        : null;
+};
+/**
+ * Array methods whose result ITERATES the receiver's own elements.
+ *
+ * The result is an iterator rather than an array, which is why it belongs to
+ * neither of the maps the walk already reads: nothing is copied, so
+ * `TYPE_PRESERVING_COPY_METHODS` refuses it, and nothing is handed to a
+ * callback, so `ELEMENT_PARAMETER_INDEX_BY_METHOD` refuses it too. Every
+ * binding taken from it still carries the constant's element type, so
+ * `for (const item of ITEMS.values()) { item.n = 2; }` is TS2540 once `ITEMS`
+ * is frozen, for an input that compiled (Issue #2340). `entries` yields
+ * `[index, element]` pairs, which carry the element exactly as `values` does.
+ *
+ * `keys` is absent for an ARRAY receiver, for the reason `Object.keys` is: it
+ * yields INDICES, numbers whatever the receiver holds, which the assertion
+ * cannot reach.
+ */
+const ELEMENT_ITERATOR_METHODS = new Set(['values', 'entries']);
+/**
+ * The same methods for a Set/Map receiver, where `keys` joins them.
+ *
+ * `Set.prototype.keys` is an alias for `values`, and a `Map`'s hands back the
+ * frozen key of each entry, so `for (const item of new Set(ITEMS).keys()) {
+ * item.n = 2; }` is TS2540 once `ITEMS` is frozen, for an input that compiled
+ * — while the `for…of` and `forEach` spellings over the same `new Set(ITEMS)`
+ * already decline (Issue #2341). One set per receiver, because a single set
+ * would decide the two receivers by the same name and be wrong for one of them.
+ *
+ * The receiver is read syntactically: the collection this iterator is reached
+ * through is the `new Set(ITEMS)` expression the derivation walk just resolved.
+ */
+const COLLECTION_ELEMENT_ITERATOR_METHODS = new Set([
+    'values',
+    'entries',
+    'keys',
+]);
+const iteratorProjectionCallOf = (node) => {
+    const parent = node.parent;
+    if (parent?.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        parent.object !== node) {
+        return null;
+    }
+    const method = accessedPropertyName(parent);
+    const iteratorMethods = isElementPreservingCollection(node)
+        ? COLLECTION_ELEMENT_ITERATOR_METHODS
+        : ELEMENT_ITERATOR_METHODS;
+    if (method === null || !iteratorMethods.has(method)) {
+        return null;
+    }
+    // A method REFERENCE (`const walk = ITEMS.values;`) iterates nothing, so the
+    // iterator exists only once the method is called — the same terms
+    // `copyExpressionOf` reads a copy on.
+    const callee = outermostValueOf(parent);
+    return callee.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        callee.parent.callee === callee
+        ? callee.parent
+        : null;
+};
+/**
+ * The expressions a reference denotes a FROZEN value through: the reference
+ * itself and every property access rooted at it — `CONFIG`, `CONFIG.list`,
+ * `CONFIG.list.rows` for `CONFIG.list.rows`.
+ *
+ * `as const` freezes the value in depth, so a property of the constant carries
+ * the assertion exactly as the constant does, and an iteration is routinely
+ * reached through one (`CONFIG.list.values()`, `Array.from(CONFIG.list, fn)`).
+ * A derivation resolver reads a node's immediate parent, so it sees only the
+ * innermost access unless each step of the path is offered to it in turn
+ * (Issue #2340).
+ */
+const accessPathsRootedAt = (identifier) => {
+    const paths = [];
+    let current = outermostValueOf(identifier);
+    for (;;) {
+        paths.push(current);
+        const parent = current.parent;
+        if (!parent ||
+            parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+            parent.object !== current) {
+            return paths;
+        }
+        current = outermostValueOf(parent);
+    }
+};
+/**
+ * Whether `as const` reaches INTO this value, or stops at the property that
+ * holds it.
+ *
+ * The assertion retypes the literal it is written on: nested array and object
+ * literals become `readonly`, and primitive literals narrow to their literal
+ * type. A value the literal merely refers to keeps whatever type it already
+ * had, and an explicit `as T` cast is exactly such a value — so
+ * `{ items: [] as string[] } as const` freezes the `items` PROPERTY while
+ * leaving the array it holds a mutable `string[]`.
+ *
+ * Only the cast is screened, because it is the one spelling that PROVES the
+ * assertion cannot deepen. Anything else answers true, so an unrecognized value
+ * is still enrolled and the walk keeps declining — the direction that withholds
+ * an assertion rather than breaking a build (Issue #2341).
+ */
+const assertionDeepensInto = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.TSAsExpression &&
+        node.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        return true;
+    }
+    return (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.typeAnnotation.typeName.name === 'const');
+};
+/**
+ * The value a single access step reads out of a literal, or `undefined` when
+ * the step cannot be resolved statically.
+ *
+ * A spread makes an object literal's own properties an incomplete account of
+ * what it holds, so a miss under one is unresolved rather than absent.
+ */
+const literalValueAtKey = (value, key) => {
+    if (value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+        if (typeof key !== 'string') {
+            return undefined;
+        }
+        let resolved;
+        for (const property of value.properties) {
+            if (property.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                return undefined;
+            }
+            const propertyKey = property.key;
+            const keyName = !property.computed && propertyKey.type === utils_1.AST_NODE_TYPES.Identifier
+                ? propertyKey.name
+                : propertyKey.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof propertyKey.value === 'string'
+                    ? propertyKey.value
+                    : null;
+            // The LAST matching key wins, as it does at runtime.
+            if (keyName === key) {
+                resolved = property.value;
+            }
+        }
+        return resolved;
+    }
+    if (value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+        if (typeof key !== 'number') {
+            return undefined;
+        }
+        const element = value.elements[key];
+        return element === null ||
+            element === undefined ||
+            element.type === utils_1.AST_NODE_TYPES.SpreadElement
+            ? undefined
+            : element;
+    }
+    return undefined;
+};
+/**
+ * The value a single MEMBER ACCESS step reads out of a literal, or `undefined`
+ * when the step cannot be resolved statically.
+ *
+ * Delegates to `literalValueAtKey` so a property reached by a member access and
+ * the same property reached by a destructuring pattern cannot be read on
+ * different terms — the divergence between those two spellings is what this
+ * screen exists to close (Issue #2341).
+ */
+const literalValueAtStep = (value, step) => {
+    const name = accessedPropertyName(step);
+    if (name !== null) {
+        return literalValueAtKey(value, name);
+    }
+    return step.computed &&
+        step.property.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof step.property.value === 'number'
+        ? literalValueAtKey(value, step.property.value)
+        : undefined;
+};
+/**
+ * The names a destructuring pattern binds to values `as const` does NOT reach.
+ *
+ * A pattern binds a property WITHOUT writing a member access, so the step
+ * screen in `frozenAccessPathsRootedAt` never sees `const { items } = CONFIG`
+ * — it only sees `CONFIG.items`. Reading the pattern against the same literal
+ * keeps the two spellings of one extraction on identical terms. They must
+ * agree: `prefer-destructuring-no-class` rewrites the first into the second
+ * under `--fix`, so a screen applied to one spelling alone lets a sibling fixer
+ * flip this rule's verdict on unchanged semantics (Issue #2341).
+ *
+ * A `RestElement` is left enrolled because it gathers whatever the pattern did
+ * not name, which no single literal value answers for.
+ */
+const collectUnfrozenPatternNames = (id, value, unfrozen) => {
+    if (value === undefined) {
+        return;
+    }
+    if (id.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        collectUnfrozenPatternNames(id.left, value, unfrozen);
+        return;
+    }
+    if (id.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (!assertionDeepensInto(value)) {
+            unfrozen.add(id.name);
+        }
+        return;
+    }
+    const literal = unwrapValueWrappers(value);
+    if (id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        for (const property of id.properties) {
+            if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                continue;
+            }
+            const key = property.key;
+            const name = !property.computed && key.type === utils_1.AST_NODE_TYPES.Identifier
+                ? key.name
+                : key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string'
+                    ? key.value
+                    : null;
+            if (name === null) {
+                continue;
+            }
+            collectUnfrozenPatternNames(property.value, literalValueAtKey(literal, name), unfrozen);
+        }
+        return;
+    }
+    if (id.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        id.elements.forEach((element, index) => {
+            if (!element || element.type === utils_1.AST_NODE_TYPES.RestElement) {
+                return;
+            }
+            collectUnfrozenPatternNames(element, literalValueAtKey(literal, index), unfrozen);
+        });
+    }
+};
+/**
+ * The access paths rooted at a reference that the assertion actually FREEZES,
+ * read against the literal the constant is declared from.
+ *
+ * The climb stops before the first step whose value `as const` cannot deepen
+ * into, because neither that value nor anything reached through it carries the
+ * assertion — a binding taken from it is no second name for frozen contents and
+ * enrolling it would withhold the assertion for a break that cannot happen.
+ *
+ * Without a literal to read, every step answers unresolved and the result is
+ * the whole path, which is what `accessPathsRootedAt` returns on its own.
+ */
+const frozenAccessPathsRootedAt = (identifier, frozenValue) => {
+    const paths = [];
+    let current = outermostValueOf(identifier);
+    let value = frozenValue
+        ? unwrapValueWrappers(frozenValue)
+        : undefined;
+    for (;;) {
+        paths.push({ node: current, literal: value });
+        const parent = current.parent;
+        if (!parent ||
+            parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+            parent.object !== current) {
+            return paths;
+        }
+        if (value !== undefined) {
+            const stepValue = literalValueAtStep(value, parent);
+            if (stepValue === undefined) {
+                value = undefined;
+            }
+            else if (!assertionDeepensInto(stepValue)) {
+                return paths;
+            }
+            else {
+                value = unwrapValueWrappers(stepValue);
+            }
+        }
+        current = outermostValueOf(parent);
+    }
+};
+/**
+ * Every way a value derived from this one keeps the constant's ELEMENT types:
+ * a copy of it, the `Object.values`/`Object.entries` array over it, the
+ * iterator its own `values`/`entries` hands back, and the collection built out
+ * of it. Each resolver returns an ANCESTOR of the node it is given, which is
+ * what lets the iteration walk follow them transitively without looping.
+ */
+const DERIVATION_RESOLVERS = [
+    copyExpressionOf,
+    elementProjectionCallOf,
+    iteratorProjectionCallOf,
+    elementCollectionOf,
+];
+/**
+ * The derivations that carry the constant's frozen type into a value a BINDING
+ * can be initialized from: a copy of it and an element taken out of it.
+ *
+ * The three iteration resolvers are absent because each hands back a value of a
+ * DIFFERENT SHAPE whose container is fresh and mutable — `Object.values(CONFIG)`
+ * and `new Set(ITEMS)` are arrays and sets nothing frozen was written to, so a
+ * write to the container itself is no readonly violation. Only their ELEMENTS
+ * carry the assertion, which is the question the iteration walk asks.
+ */
+const ALIAS_DERIVATION_RESOLVERS = [copyExpressionOf, elementExpressionOf];
+/**
+ * Every expression that denotes a value typed from this reference: the
+ * reference and each step of the access path rooted at it, then — transitively
+ * — whatever `resolvers` derive from any of them.
+ *
+ * Grown in place and walked by index, so a derivation OF a derivation is
+ * reached by the same loop without recursion of its own. Every resolver returns
+ * an ANCESTOR of the node it is given, so the walk strictly ascends and
+ * terminates; `visited` keeps a node two resolvers agree on from being expanded
+ * twice.
+ */
+const derivedValueExpressionsOf = (identifier, resolvers, frozenValue) => {
+    const pending = frozenAccessPathsRootedAt(identifier, frozenValue);
+    const visited = new Set(pending.map(({ node }) => node));
+    for (let index = 0; index < pending.length; index += 1) {
+        for (const resolveDerivation of resolvers) {
+            const derived = resolveDerivation(pending[index].node);
+            if (!derived || visited.has(derived)) {
+                continue;
+            }
+            visited.add(derived);
+            // A copy or an element call hands back a value with no literal of its
+            // own, so nothing downstream of one is screened — the direction that
+            // keeps enrolling rather than withholding the assertion.
+            pending.push({ node: derived, literal: undefined });
+        }
+    }
+    return pending;
+};
+const enrolFully = (variables) => variables.map((variable) => ({
+    variable,
+    breaksOnAnyMutatingMethod: true,
+}));
+/**
+ * The bindings a callback's parameters at `positions` introduce, each carrying
+ * the question its position can break on.
+ *
+ * A callback routinely declares fewer parameters than the caller passes, so a
+ * position is taken only where the signature actually spells it.
+ *
+ * The scope manager answers for the WHOLE function — every parameter, and a
+ * function expression's own name — so the enrolled parameters' bindings are
+ * picked out by the spans they are declared in. Taking the function's list
+ * whole would enrol the accumulator of a `reduce`, typed from the seed value
+ * rather than from the constant, and the index, which the assertion cannot
+ * reach.
+ */
+const parameterBindingsOf = (callback, positions, declaredVariablesOf) => {
+    const enrolled = positions.flatMap(({ index, breaksOnAnyMutatingMethod }) => {
+        const param = callback.params[index];
+        return param ? [{ param, breaksOnAnyMutatingMethod }] : [];
+    });
+    if (enrolled.length === 0) {
+        return [];
+    }
+    return declaredVariablesOf(callback).flatMap((variable) => {
+        const position = enrolled.find(({ param }) => variable.defs.some((def) => def.name.range[0] >= param.range[0] &&
+            def.name.range[1] <= param.range[1]));
+        return position
+            ? [
+                {
+                    variable,
+                    breaksOnAnyMutatingMethod: position.breaksOnAnyMutatingMethod,
+                },
+            ]
+            : [];
+    });
+};
 /**
  * The bindings a construct that ITERATES `iterable` introduces: the head of a
  * `for…of` over it, the parameter an array method hands each element to, and —
@@ -696,9 +1336,9 @@ const elementProjectionCallOf = (node) => {
  */
 const bindingsOfIterationOver = (iterable, declaredVariablesOf, iteratesConstantValue) => {
     // The member path is resolved first because the iterated expression is
-    // routinely a PROPERTY of the constant (`for (const x of CONFIG.list)`),
-    // which the alias walk refuses precisely because it arrives through a member
-    // access — the property is frozen with the object that holds it.
+    // routinely a PROPERTY of the constant (`for (const x of CONFIG.list)`): the
+    // property is frozen with the object that holds it, so iterating it hands the
+    // body the constant's own frozen contents.
     const path = accessPathOf(iterable);
     const value = outermostValueOf(path ?? iterable);
     const parent = value.parent;
@@ -708,7 +1348,23 @@ const bindingsOfIterationOver = (iterable, declaredVariablesOf, iteratesConstant
     if (parent.type === utils_1.AST_NODE_TYPES.ForOfStatement &&
         parent.right === value &&
         parent.left.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
-        return declaredVariablesOf(parent.left);
+        return enrolFully(declaredVariablesOf(parent.left));
+    }
+    // `Array.from(X, mapfn)` hands each element of `X` to `mapfn` exactly as
+    // `X.map` hands it to a callback, so the mapper's first parameter is typed
+    // from the constant and `Array.from(ITEMS, (item) => { item.n = 2; … })` is
+    // TS2540 once `ITEMS` is frozen. The two-argument form reaches the walk
+    // nowhere else: `isCopyingCall` admits `Array.from` at one argument alone,
+    // because a mapper retypes the RESULT — which says nothing about the element
+    // it is handed (Issue #2340). The mapper takes the element first and the
+    // index second, and is handed no receiver array at all.
+    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        parent.arguments[0] === value &&
+        isNamespacedCallee(parent.callee, 'Array', 'from')) {
+        const mapper = parent.arguments[1];
+        return mapper && isFunctionValue(mapper)
+            ? parameterBindingsOf(mapper, [{ index: 0, breaksOnAnyMutatingMethod: true }], declaredVariablesOf)
+            : [];
     }
     if (path === null) {
         return [];
@@ -730,23 +1386,17 @@ const bindingsOfIterationOver = (iterable, declaredVariablesOf, iteratesConstant
     const arrayIndex = iteratesConstantValue
         ? ARRAY_PARAMETER_INDEX_BY_METHOD.get(method)
         : undefined;
-    // A callback routinely declares fewer parameters than the method passes, so
-    // each position is taken only where the signature actually spells it.
-    const enrolled = [
-        callback.params[elementIndex],
-        arrayIndex === undefined ? undefined : callback.params[arrayIndex],
-    ].filter((param) => param !== undefined);
-    if (enrolled.length === 0) {
-        return [];
-    }
-    // The scope manager answers for the WHOLE function — every parameter, and a
-    // function expression's own name — so the enrolled parameters' bindings are
-    // picked out by the spans they are declared in. Taking the function's list
-    // whole would enrol the accumulator of a `reduce`, typed from the seed value
-    // rather than from the constant, and the index, which the assertion cannot
-    // reach.
-    return declaredVariablesOf(callback).filter((variable) => variable.defs.some((def) => enrolled.some((param) => def.name.range[0] >= param.range[0] &&
-        def.name.range[1] <= param.range[1])));
+    return parameterBindingsOf(callback, [
+        { index: elementIndex, breaksOnAnyMutatingMethod: true },
+        ...(arrayIndex === undefined
+            ? []
+            : [
+                {
+                    index: arrayIndex,
+                    breaksOnAnyMutatingMethod: !MUTABLE_ARRAY_PARAMETER_METHODS.has(method),
+                },
+            ]),
+    ], declaredVariablesOf);
 };
 /**
  * The bindings ITERATING this reference introduces, directly or through a value
@@ -763,15 +1413,25 @@ const bindingsOfIterationOver = (iterable, declaredVariablesOf, iteratesConstant
  * only READS its element fixable.
  *
  * The derivations are followed because the receiver of the iteration is
- * routinely one step removed from the constant (`[...ITEMS].forEach(…)`,
- * `ITEMS.filter(Boolean).forEach(…)`, `Object.values(CONFIG).forEach(…)`): each
- * builds a fresh OUTER value whose elements are still the frozen ones, so the
- * element binding breaks identically. One derivation step is followed, matching
- * the depth the alias walk already follows a copy to.
+ * routinely removed from the constant (`[...ITEMS].forEach(…)`,
+ * `ITEMS.filter(Boolean).forEach(…)`, `Object.values(CONFIG).forEach(…)`,
+ * `ITEMS.values()`, `new Set(ITEMS)`): each builds a fresh OUTER value whose
+ * elements are still the frozen ones, so the element binding breaks
+ * identically.
+ *
+ * Following them is TRANSITIVE, on the same reasoning as the alias walk — every
+ * hop keeps the element type, so a chain of them keeps it too, and
+ * `ITEMS.filter(Boolean).slice().forEach((item) => { item.n = 2; })` is the
+ * same TS2540 as the one-hop spelling that already declines. A single step
+ * gave two spellings of one construct opposite verdicts (Issue #2340).
+ *
+ * The derivations are resolved from each step of the reference's own access
+ * path as well as from the reference, since the value a derivation is taken
+ * from is routinely a PROPERTY of the constant — see `accessPathsRootedAt`.
  *
  * The receiver ARRAY parameter is enrolled for the constant's own value or
- * member path ALONE, which is the one iterable of the three that hands the
- * callback the constant itself. A derivation hands it the fresh outer value it
+ * member path ALONE, the one iterable that hands the callback the constant
+ * itself. A derivation hands it the fresh outer value it
  * built, and mutating that is no readonly violation:
  * `[...ITEMS].forEach((item, index, arr) => { arr.push(3); })` does break after
  * the fix, but as TS2345 — the spread narrows the element type, so `3` is not
@@ -781,13 +1441,21 @@ const bindingsOfIterationOver = (iterable, declaredVariablesOf, iteratesConstant
  */
 const iterationBindingsOf = (identifier, declaredVariablesOf) => {
     const value = outermostValueOf(identifier);
-    const derivations = [copyExpressionOf(value), elementProjectionCallOf(value)];
-    return [
+    const bindings = [
         ...bindingsOfIterationOver(value, declaredVariablesOf, true),
-        ...derivations.flatMap((iterable) => iterable
-            ? bindingsOfIterationOver(iterable, declaredVariablesOf, false)
-            : []),
     ];
+    // The constant's own value and access path are iterated by the call above,
+    // which resolves the path itself; every DERIVED value is iterated on the
+    // narrower terms — it hands a callback a fresh outer value rather than the
+    // constant.
+    const ownValues = new Set(accessPathsRootedAt(value));
+    for (const { node: derived } of derivedValueExpressionsOf(value, DERIVATION_RESOLVERS)) {
+        if (ownValues.has(derived)) {
+            continue;
+        }
+        bindings.push(...bindingsOfIterationOver(derived, declaredVariablesOf, false));
+    }
+    return bindings;
 };
 /**
  * Whether anything in the file stops this binding taking `as const`, under its
@@ -840,12 +1508,49 @@ const iterationBindingsOf = (identifier, declaredVariablesOf) => {
  * `--fix`.
  */
 const blocksAsConstAssertion = (variable, declaredVariablesOf) => {
+    // The literal the constant is declared from, so an access path through it can
+    // be screened against what `as const` actually freezes. Only the constant's
+    // own declarator carries one: an ALIAS is initialized from a path into that
+    // same literal, and resolving through it would need the path carried too, so
+    // an alias is left unresolved and every step of it stays enrolled.
+    const declaredValue = variable.defs.find((def) => def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator)?.node;
+    const frozenValue = declaredValue?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        declaredValue.init
+        ? declaredValue.init
+        : undefined;
     // Grown in place and walked by index: an alias found mid-walk is appended and
     // reached by the same loop, so the traversal needs no recursion of its own.
-    const pending = [variable];
-    const visited = new Set(pending);
+    const pending = [
+        { variable, breaksOnAnyMutatingMethod: true, frozenValue },
+    ];
+    const visited = new Set([variable]);
+    /**
+     * Whether a node is a REFERENCE to a binding already enrolled for this
+     * constant, and so holds a value typed from the constant itself.
+     *
+     * Answered from the scope manager's reference lists rather than by name, on
+     * the same terms as the rest of the walk: a same-named binding from another
+     * scope names another value and must not exempt anything.
+     *
+     * A binding enrolled LATER in the walk than the one being examined answers
+     * false here. That can only withhold an exemption, never grant one wrongly,
+     * so the walk order costs a report at worst.
+     */
+    const isEnrolledReference = (node) => {
+        const value = unwrapValueWrappers(node);
+        if (value.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        for (const enrolledVariable of visited) {
+            if (enrolledVariable.references.some((enrolledReference) => enrolledReference.identifier === value)) {
+                return true;
+            }
+        }
+        return false;
+    };
     for (let index = 0; index < pending.length; index += 1) {
-        for (const reference of pending[index].references) {
+        const { variable: enrolled, breaksOnAnyMutatingMethod, frozenValue: enrolledValue, } = pending[index];
+        for (const reference of enrolled.references) {
             // Reassigning an alias is as disqualifying as writing through one. A
             // binding that takes its type from the constant narrows to the frozen
             // literal, so `let stage = DEFAULT; stage = 'live';` becomes TS2322 for
@@ -858,30 +1563,64 @@ const blocksAsConstAssertion = (variable, declaredVariablesOf) => {
                 return true;
             }
             const path = accessPathOf(reference.identifier);
+            // The ELEMENT question is asked of every binding alike: the elements are
+            // frozen whatever the container's own declaration says.
+            if (path !== null && isWriteTarget(path)) {
+                return true;
+            }
+            // The mutating-method question is asked in full of every binding the
+            // assertion types `readonly`, where any such call is a TS2339. A
+            // parameter the lib declares MUTABLE has no such break to have, so it is
+            // asked the narrower question that remains: does this call introduce a
+            // value the narrowed element type would have to accept (Issue #2340).
             if (path !== null &&
-                (isMutatingMethodCall(path) || isWriteTarget(path))) {
+                isMutatingMethodCall(path) &&
+                (breaksOnAnyMutatingMethod ||
+                    introducesForeignElement(path, isEnrolledReference))) {
                 return true;
             }
-            // A copy carries the constant's frozen type into a second binding, so it
-            // is enrolled on the same terms as an alias — but it is reached through a
-            // member access (`ITEMS.concat()`), which the alias walk deliberately
-            // refuses, so it is resolved before that refusal applies.
-            const copy = copyExpressionOf(outermostValueOf(reference.identifier));
-            const declarator = copy
-                ? aliasDeclaratorOf(copy)
-                : path === null
-                    ? aliasDeclaratorOf(reference.identifier)
-                    : null;
+            // A binding is initialized from any expression that denotes the
+            // constant's frozen contents, not from the reference alone. A PROPERTY or
+            // ELEMENT of the constant carries the assertion exactly as the constant
+            // does, so `const list = CONFIG.list; list.push(3);` is the same TS2339
+            // the rule already declines for when the identical call is written
+            // directly — only the extracted spelling escaped it, while the
+            // DESTRUCTURED spelling of the same extraction was enrolled all along
+            // (Issue #2341). A copy taken of the constant or of any step of that path
+            // (`ITEMS.concat()`, `[...CONFIG.a.b]`) carries the frozen TYPE into a
+            // fresh value on the same terms.
+            const aliases = derivedValueExpressionsOf(reference.identifier, ALIAS_DERIVATION_RESOLVERS, enrolledValue).flatMap(({ node, literal }) => {
+                const declarator = aliasDeclaratorOf(node);
+                if (!declarator) {
+                    return [];
+                }
+                const variables = declaredVariablesOf(declarator);
+                // The pattern screen applies only where the declarator destructures
+                // THIS value directly. Reached through a storage container
+                // (`const HOLDER = { ITEMS }`), the pattern names the container's own
+                // properties, which this literal does not answer for.
+                if (literal === undefined ||
+                    declarator.init !== outermostValueOf(node)) {
+                    return variables;
+                }
+                const unfrozen = new Set();
+                collectUnfrozenPatternNames(declarator.id, literal, unfrozen);
+                return unfrozen.size === 0
+                    ? variables
+                    : variables.filter((variable) => !unfrozen.has(variable.name));
+            });
             // A binding introduced by ITERATING the constant is enrolled beside the
             // aliases: it names the constant's CONTENTS, which the assertion freezes
-            // with the constant itself — see `iterationBindingsOf`.
+            // with the constant itself — see `iterationBindingsOf`. An alias is
+            // enrolled on the constant's own terms, because it denotes the constant's
+            // value and so carries its readonly-ness whole.
             const derived = [
-                ...(declarator ? declaredVariablesOf(declarator) : []),
+                ...enrolFully(aliases),
                 ...iterationBindingsOf(reference.identifier, declaredVariablesOf),
             ];
             for (const alias of derived) {
-                if (!visited.has(alias)) {
-                    visited.add(alias);
+                if (!visited.has(alias.variable)) {
+                    visited.add(alias.variable);
                     pending.push(alias);
                 }
             }