@blumintinc/eslint-plugin-blumint 1.20.185 → 1.20.186

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.185',
+        version: '1.20.186',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -154,13 +154,23 @@ const prologueLengthOf = (statements) => {
     return first === -1 ? statements.length : first;
 };
 /**
- * The children of `node` that the async function's own execution reaches.
+ * Whether the async function's own execution stops AT `node` rather than
+ * running what it holds.
  *
  * A nested function, a class static block and a `namespace` body are cut, the
  * same boundary {@link referenceSitesOf} draws: what they hold runs when THEY
  * are invoked, which is not a moment the relocated `await` moves, so their
  * contents say nothing about the placement.
+ *
+ * The predicate is asked of every node a reach walk touches, the handed root
+ * included. The boundary belongs to the NODE, not to the edge it is reached
+ * by: cutting children alone lets a walk seeded ON one — a hoisted `function`
+ * declaration standing as a statement of the region, or an `if` test that IS a
+ * closure — run through it and credit its body's guards and reads to the
+ * region (#2172, #2173).
  */
+const isReachBoundary = (node) => isFunctionNode(node) || AWAIT_OPAQUE_BODIES.has(node.type);
+/** The children of `node` that the async function's own execution reaches. */
 const reachedChildrenOf = (node) => {
     const children = [];
     for (const [key, value] of Object.entries(node)) {
@@ -170,17 +180,23 @@ const reachedChildrenOf = (node) => {
             continue;
         }
         for (const child of Array.isArray(value) ? value : [value]) {
-            if (ASTHelpers_1.ASTHelpers.isNode(child) &&
-                !isFunctionNode(child) &&
-                !AWAIT_OPAQUE_BODIES.has(child.type)) {
+            if (ASTHelpers_1.ASTHelpers.isNode(child) && !isReachBoundary(child)) {
                 children.push(child);
             }
         }
     }
     return children;
 };
+/**
+ * Visits every node the async function's own execution reaches from `root`.
+ *
+ * `root` takes the same cut as the nodes below it: a walk handed a boundary
+ * visits nothing, because the question the callers ask — what runs behind the
+ * relocated `await` — has one answer for a nested body whether it is reached
+ * as a child or handed in directly.
+ */
 const walkReached = (root, visit) => {
-    const pending = [root];
+    const pending = isReachBoundary(root) ? [] : [root];
     while (pending.length > 0) {
         const node = pending.pop();
         visit(node);
@@ -211,6 +227,12 @@ const pathTextOf = (node) => {
     return null;
 };
 const readPathsInto = (node, paths) => {
+    // The handed node takes the same cut as the children below it: a test that IS
+    // a function literal (`if (() => busy)`) evaluates to the closure, never to
+    // what the closure would read when called.
+    if (isReachBoundary(node)) {
+        return;
+    }
     const path = pathTextOf(node);
     if (path !== null) {
         paths.add(path);

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -101,10 +101,22 @@ const childNodesOf = (node) => {
     }
     return children;
 };
-/** The type nodes a declaration states about the type it declares. */
+/**
+ * The type nodes a declaration states about the type it declares.
+ *
+ * An alias hands over its whole right-hand side, so every type its members name
+ * is reached. The interface spelling has to hand over as much or the two answer
+ * differently about the same declaration: its heritage clauses state what it
+ * inherits, and its body states what it declares. Reading the clauses alone
+ * left a reference type written as an interface MEMBER invisible, so
+ * `as Schema['user']` reported a schema the file states in full — while the
+ * alias `prefer-type-over-interface --fix` rewrites that interface into was
+ * already exempt, making one fix pass the difference between reporting and
+ * silence (#2189).
+ */
 const statedTypeNodesOf = (declaration) => declaration.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration
     ? [declaration.typeAnnotation]
-    : declaration.extends ?? [];
+    : [...(declaration.extends ?? []), declaration.body];
 /**
  * The expression an optional link wraps, so a receiver spelled with `?.` is
  * read as the expression it actually evaluates.

package/lib/rules/enforce-positive-naming.js

@@ -1146,19 +1146,40 @@ function classifyFunctionReturn(fn) {
 function isExemptFromBooleanNaming(fn) {
     return classifyFunctionReturn(fn) !== 'boolean';
 }
+/**
+ * Strips the type-only expression wrappers (`fn as T`, `fn satisfies T`, `fn!`,
+ * `<T>fn`) that can sit between a name and the value it is bound to. None of
+ * them changes what the value is at runtime, so a wrapped function's return
+ * shape is the shape of the function inside. Reading only the outermost node
+ * made the validator carve-out depend on the assertion's presence (#2174).
+ */
+function unwrapTypeOnlyExpression(node) {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        current = current.expression;
+    }
+    return current;
+}
 /**
  * When a declarator/property value is a function, whether that function is
- * exempt from boolean negative-naming.
+ * exempt from boolean negative-naming. The value is unwrapped first: exemption
+ * turns on what the function returns, never on how the binding is asserted.
  */
 function isExemptFunctionValue(node) {
-    return (!!node &&
-        (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-            node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-            // `abstract isNotBlank(value?: string): string | true;` declares the
-            // validator without a body, and must be exempt on the same grounds as
-            // the implementation that satisfies it.
-            node.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) &&
-        isExemptFromBooleanNaming(node));
+    if (!node) {
+        return false;
+    }
+    const value = unwrapTypeOnlyExpression(node);
+    return ((value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        value.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        // `abstract isNotBlank(value?: string): string | true;` declares the
+        // validator without a body, and must be exempt on the same grounds as
+        // the implementation that satisfies it.
+        value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) &&
+        isExemptFromBooleanNaming(value));
 }
 /**
  * A member declared with a function type but no initializer
@@ -1548,6 +1569,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                 !(node.typeAnnotation?.typeAnnotation.type ===
                     utils_1.AST_NODE_TYPES.TSBooleanKeyword))
                 return;
+            // A signature has no value, so its function type is the only place its
+            // return shape can live. Skipping the annotation here exempted a
+            // validator declared as a class field while reporting the identical
+            // member declared in an interface or type literal (#2175).
+            if (isExemptFunctionTypeAnnotation(node.typeAnnotation))
+                return;
             // Ensure we have a valid property name
             const propertyName = node.key.name;
             if (!propertyName)

package/lib/rules/enforce-props-argument-name.js

@@ -95,6 +95,108 @@ const renameWouldCollide = (variable, newName) => {
     //     name would shadow whatever those uses resolve to.
     return scopeSubtreeReferencesName(declarationScope, newName);
 };
+/**
+ * The member name a `this.<x>` access reads, whatever its spelling.
+ *
+ * Keying the check on the dot spelling alone left `this['settings']` invisible,
+ * so the rename shipped and stranded it — the class no longer had the member the
+ * getter reads (#1881/#1882). A computed access with a static string is the SAME
+ * member as the dot form, and the fixer cannot rewrite it either, so it has to
+ * count. `null` marks a genuinely dynamic key, which names no member statically
+ * and therefore strands nothing.
+ */
+const staticMemberName = (node) => {
+    if (!node.computed) {
+        return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+            ? node.property.name
+            : null;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.property.value === 'string') {
+        return node.property.value;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.property.expressions.length === 0 &&
+        node.property.quasis.length === 1) {
+        return node.property.quasis[0].value.cooked;
+    }
+    return null;
+};
+/**
+ * How far from its declaration a stranded read of a parameter property can sit.
+ *
+ * A parameter property declares a class FIELD as well as a constructor-local
+ * binding, and `private` is what confines the field's legal readers to the class
+ * body: for a private field the class node is a complete scan root. Every other
+ * visibility — `public`, `protected`, and a modifier-less `readonly`, which is
+ * public — publishes the field to the whole file, so `widget.settings` in a
+ * sibling function, or `this.settings` in a subclass declared elsewhere in the
+ * file, outlives a declaration-only rename and points at a member the class no
+ * longer has. Handing the scan the enclosing class hid exactly those reads, so
+ * the fixer corrupted the file it was fixing (#2177/#2178).
+ */
+const parameterPropertyScanRoot = (param, enclosingClass) => {
+    if (param.accessibility === 'private') {
+        return enclosingClass;
+    }
+    let root = enclosingClass;
+    while (root.parent) {
+        root = root.parent;
+    }
+    return root;
+};
+/**
+ * Reports whether renaming a constructor parameter property is unsafe to
+ * autofix.
+ *
+ * A parameter property (`private readonly settings: FooProps`) declares BOTH a
+ * constructor-local binding and a `this.settings` class field. The scope
+ * analyzer only models the binding, so a scope-driven rename rewrites the
+ * declaration while leaving every member read pointing at a name that no longer
+ * exists (Issue #1358). Since the field half of the rename cannot be resolved
+ * through scope analysis, the fix is withheld whenever the name occurs anywhere
+ * under `scanRoot` other than at its declaration.
+ *
+ * The member check is object-agnostic on purpose: `widget.settings` reads the
+ * same field as `this.settings`, and the fixer can rewrite neither.
+ */
+const parameterPropertyRenameIsUnsafe = (scanRoot, name, declarationId) => {
+    let unsafe = false;
+    const visit = (node) => {
+        if (unsafe) {
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            staticMemberName(node) === name) {
+            unsafe = true;
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.name === name &&
+            node !== declarationId) {
+            unsafe = true;
+            return;
+        }
+        for (const key of Object.keys(node)) {
+            if (key === 'parent') {
+                continue;
+            }
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (ASTHelpers_1.ASTHelpers.isNode(child)) {
+                        visit(child);
+                    }
+                }
+            }
+            else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                visit(value);
+            }
+        }
+    };
+    visit(scanRoot);
+    return unsafe;
+};
 exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
     name: 'enforce-props-argument-name',
     meta: {
@@ -340,78 +442,6 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
             });
         }
-        /**
-         * The member name a `this.<x>` access reads, whatever its spelling.
-         *
-         * Keying the check on the dot spelling alone left `this['settings']`
-         * invisible, so the rename shipped and stranded it — the class no longer had
-         * the member the getter reads (#1881). A computed access with a static
-         * string is the SAME member as the dot form, and the fixer cannot rewrite it
-         * either, so it has to count. `null` marks a genuinely dynamic key, which
-         * names no member statically.
-         */
-        function staticMemberName(node) {
-            if (!node.computed) {
-                return node.property.type === utils_1.AST_NODE_TYPES.Identifier
-                    ? node.property.name
-                    : null;
-            }
-            if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.property.value === 'string') {
-                return node.property.value;
-            }
-            if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
-                node.property.expressions.length === 0 &&
-                node.property.quasis.length === 1) {
-                return node.property.quasis[0].value.cooked;
-            }
-            return null;
-        }
-        // Determine whether renaming a constructor parameter property is unsafe to
-        // autofix. A parameter property (`private readonly foo: T`) creates BOTH a
-        // constructor-local binding and a `this.foo` class field, so a
-        // declaration-only rename would leave dangling references: plain `foo`
-        // usages inside the constructor (e.g. `super(foo)`) and `this.foo` accesses
-        // anywhere in the class. Mirrors #1123 — when a rename cannot be applied
-        // everywhere syntactically, emit no fix rather than corrupt the code.
-        function parameterPropertyRenameIsUnsafe(classNode, name, declarationId) {
-            let unsafe = false;
-            const visit = (node) => {
-                if (unsafe) {
-                    return;
-                }
-                if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-                    staticMemberName(node) === name) {
-                    unsafe = true;
-                    return;
-                }
-                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.name === name &&
-                    node !== declarationId) {
-                    unsafe = true;
-                    return;
-                }
-                for (const key of Object.keys(node)) {
-                    if (key === 'parent') {
-                        continue;
-                    }
-                    const value = node[key];
-                    if (Array.isArray(value)) {
-                        for (const child of value) {
-                            if (ASTHelpers_1.ASTHelpers.isNode(child)) {
-                                visit(child);
-                            }
-                        }
-                    }
-                    else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
-                        visit(value);
-                    }
-                }
-            };
-            visit(classNode);
-            return unsafe;
-        }
         // Find the class (declaration or expression) that owns a method definition.
         function getEnclosingClass(node) {
             const classBody = node.parent;
@@ -467,11 +497,11 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                 fix: (fixer) => {
                                     // A parameter-property rename touches both the parameter and
                                     // the `this.<name>` field; refuse to autofix when the name is
-                                    // referenced elsewhere, since a declaration-only rename would
-                                    // leave dangling references.
+                                    // referenced anywhere within reach of that field, since a
+                                    // declaration-only rename would leave dangling references.
                                     if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
                                         enclosingClass &&
-                                        parameterPropertyRenameIsUnsafe(enclosingClass, id.name, id)) {
+                                        parameterPropertyRenameIsUnsafe(parameterPropertyScanRoot(param, enclosingClass), id.name, id)) {
                                         return null;
                                     }
                                     return buildParameterRenameFixes(fixer, method, id, suggestedName);

package/lib/rules/enforce-props-naming-consistency.js

@@ -30,27 +30,50 @@ const getEnclosingClass = (node) => {
     return null;
 };
 /**
- * Reports whether renaming a constructor parameter property is unsafe to
- * autofix.
+ * The identifier a parameter declares, whatever wrappers it carries.
  *
- * A parameter property (`private readonly settings: FooProps`) declares BOTH a
- * constructor-local binding and a `this.settings` class field. The scope
- * analyzer only models the binding, so a scope-driven rename silently rewrites
- * the field declaration while leaving every `this.settings` access — and every
- * plain `settings` use the analyzer attributes elsewhere — pointing at a name
- * that no longer exists (Issue #1358). Since the field half of the rename
- * cannot be resolved through scope analysis, the fix is withheld whenever the
- * name occurs anywhere in the class other than at its declaration.
+ * A default value nests the identifier in an `AssignmentPattern`, and a
+ * constructor parameter property nests it in a `TSParameterProperty` — possibly
+ * both at once (`private readonly alpha: AProps = fallback`). Keying the
+ * multi-Props deferral counter on a bare `Identifier` dropped every defaulted
+ * parameter, so a two-Props signature counted as one and this rule reported a
+ * rename to `props` that its authoritative sibling contradicts with a prefixed
+ * name (#2180). Mirrors `getIdFromParam` in enforce-props-argument-name so both
+ * rules count the same parameters.
  */
+const getIdFromParam = (param) => {
+    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return param;
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+        param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return param.left;
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+        const inner = param.parameter;
+        if (inner.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return inner;
+        }
+        if (inner.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+            inner.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return inner.left;
+        }
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.RestElement &&
+        param.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return param.argument;
+    }
+    return null;
+};
 /**
  * The member name a `this.<x>` access reads, whatever its spelling.
  *
  * Keying the check on the dot spelling alone left `this['settings']` invisible,
  * so the rename shipped and stranded it — the class no longer had the member the
- * getter reads (#1882, the sibling of #1881). A computed access with a static
- * string is the SAME member as the dot form, and the fixer cannot rewrite it
- * either, so it has to count. `null` marks a genuinely dynamic key, which names
- * no member statically and therefore strands nothing.
+ * getter reads (#1881/#1882). A computed access with a static string is the SAME
+ * member as the dot form, and the fixer cannot rewrite it either, so it has to
+ * count. `null` marks a genuinely dynamic key, which names no member statically
+ * and therefore strands nothing.
  */
 const staticMemberName = (node) => {
     if (!node.computed) {
@@ -69,14 +92,51 @@ const staticMemberName = (node) => {
     }
     return null;
 };
-const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
+/**
+ * How far from its declaration a stranded read of a parameter property can sit.
+ *
+ * A parameter property declares a class FIELD as well as a constructor-local
+ * binding, and `private` is what confines the field's legal readers to the class
+ * body: for a private field the class node is a complete scan root. Every other
+ * visibility — `public`, `protected`, and a modifier-less `readonly`, which is
+ * public — publishes the field to the whole file, so `widget.settings` in a
+ * sibling function, or `this.settings` in a subclass declared elsewhere in the
+ * file, outlives a declaration-only rename and points at a member the class no
+ * longer has. Handing the scan the enclosing class hid exactly those reads, so
+ * the fixer corrupted the file it was fixing (#2177/#2178).
+ */
+const parameterPropertyScanRoot = (param, enclosingClass) => {
+    if (param.accessibility === 'private') {
+        return enclosingClass;
+    }
+    let root = enclosingClass;
+    while (root.parent) {
+        root = root.parent;
+    }
+    return root;
+};
+/**
+ * Reports whether renaming a constructor parameter property is unsafe to
+ * autofix.
+ *
+ * A parameter property (`private readonly settings: FooProps`) declares BOTH a
+ * constructor-local binding and a `this.settings` class field. The scope
+ * analyzer only models the binding, so a scope-driven rename rewrites the
+ * declaration while leaving every member read pointing at a name that no longer
+ * exists (Issue #1358). Since the field half of the rename cannot be resolved
+ * through scope analysis, the fix is withheld whenever the name occurs anywhere
+ * under `scanRoot` other than at its declaration.
+ *
+ * The member check is object-agnostic on purpose: `widget.settings` reads the
+ * same field as `this.settings`, and the fixer can rewrite neither.
+ */
+const parameterPropertyRenameIsUnsafe = (scanRoot, name, declarationId) => {
     let unsafe = false;
     const visit = (node) => {
         if (unsafe) {
             return;
         }
         if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-            node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
             staticMemberName(node) === name) {
             unsafe = true;
             return;
@@ -104,7 +164,7 @@ const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
             }
         }
     };
-    visit(classNode);
+    visit(scanRoot);
     return unsafe;
 };
 exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
@@ -133,6 +193,20 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
             }
             return null;
         }
+        // Whether a parameter carries a `*Props` type, counted for the multi-Props
+        // deferral. The identifier is unwrapped from its default value and/or
+        // parameter-property wrapper first: a parameter this misses is a Props
+        // parameter this rule cannot see, which turns a multi-Props signature — the
+        // case it defers to enforce-props-argument-name — into a lone parameter it
+        // renames to `props` against the sibling's prefixed suggestion (#2180).
+        function isPropsTypedParam(param) {
+            const id = getIdFromParam(param);
+            if (!id || !id.typeAnnotation || !id.typeAnnotation.typeAnnotation) {
+                return false;
+            }
+            const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
+            return !!typeName && typeName.endsWith('Props');
+        }
         // Check if a parameter should be named "props"
         function shouldBeNamedProps(param) {
             // Only check non-destructured parameters
@@ -205,14 +279,7 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
                 return;
             }
             // Skip functions with multiple parameters that have Props types
-            const propsTypeParams = node.params.filter((param) => {
-                if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
-                    return false;
-                if (!param.typeAnnotation || !param.typeAnnotation.typeAnnotation)
-                    return false;
-                const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
-                return typeName && typeName.endsWith('Props');
-            });
+            const propsTypeParams = node.params.filter(isPropsTypedParam);
             if (propsTypeParams.length > 1) {
                 return; // Skip functions with multiple Props parameters
             }
@@ -236,28 +303,27 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
             }
             const constructor = node.value;
             // Skip constructors with multiple parameters that have Props types
-            const propsTypeParams = constructor.params.filter((param) => {
-                if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    if (!param.typeAnnotation || !param.typeAnnotation.typeAnnotation)
-                        return false;
-                    const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
-                    return typeName && typeName.endsWith('Props');
-                }
-                else if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
-                    param.parameter.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    if (!param.parameter.typeAnnotation ||
-                        !param.parameter.typeAnnotation.typeAnnotation)
-                        return false;
-                    const typeName = getTypeName(param.parameter.typeAnnotation.typeAnnotation);
-                    return typeName && typeName.endsWith('Props');
-                }
-                return false;
-            });
+            const propsTypeParams = constructor.params.filter(isPropsTypedParam);
             if (propsTypeParams.length > 1) {
                 return; // Skip constructors with multiple Props parameters
             }
             const enclosingClass = getEnclosingClass(node);
+            // When the enclosing class extends a base class, a constructor parameter
+            // property (e.g. `private readonly fullProps: SubProps`) cannot be safely
+            // renamed to `props`: the base class may already declare a private `props`
+            // field/parameter-property, so the rename would create a TS2415 private-
+            // field collision, and it would also leave `super(fullProps)` /
+            // `this.fullProps` references dangling. enforce-props-argument-name — the
+            // authoritative rule this one defers to — treats a distinct name on a
+            // subclass parameter property as intentional (#1276), so reporting it here
+            // would make that carve-out void in the shipped config and hand the
+            // consumer an error it cannot satisfy (#2179).
+            const classExtendsBase = !!enclosingClass?.superClass;
             for (const param of constructor.params) {
+                if (classExtendsBase &&
+                    param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                    continue;
+                }
                 if (shouldBeNamedProps(param) &&
                     param.type === utils_1.AST_NODE_TYPES.Identifier &&
                     !isPropsNameWithPrefix(param.name)) {
@@ -280,9 +346,9 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
                         fix: (fixer) => {
                             // A parameter property also declares a `this.<name>` field the
                             // scope analyzer does not model, so renaming it is only safe
-                            // when the name appears nowhere else in the class.
+                            // when the name appears nowhere else within reach of that field.
                             if (!enclosingClass ||
-                                parameterPropertyRenameIsUnsafe(enclosingClass, declarationId.name, declarationId)) {
+                                parameterPropertyRenameIsUnsafe(parameterPropertyScanRoot(param, enclosingClass), declarationId.name, declarationId)) {
                                 return null;
                             }
                             return buildParameterRenameFixes(fixer, constructor, declarationId);

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -1297,27 +1297,37 @@ function collectFunctionBodyDependencies(fn, dependencies, context) {
         includeFunctionCaptures: true,
     });
     let resolved = true;
-    traverseAst(fn.body, {
-        skipFunctions: true,
-        visit(current) {
-            if (current.type !== utils_1.AST_NODE_TYPES.CallExpression &&
-                current.type !== utils_1.AST_NODE_TYPES.ChainExpression) {
-                return undefined;
-            }
-            const callExpression = current.type === utils_1.AST_NODE_TYPES.CallExpression
-                ? current
-                : extractCallExpression(current);
-            if (!callExpression) {
+    const resolveCallsIn = (region) => {
+        traverseAst(region, {
+            skipFunctions: true,
+            visit(current) {
+                if (current.type !== utils_1.AST_NODE_TYPES.CallExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.ChainExpression) {
+                    return undefined;
+                }
+                const callExpression = current.type === utils_1.AST_NODE_TYPES.CallExpression
+                    ? current
+                    : extractCallExpression(current);
+                if (!callExpression) {
+                    return undefined;
+                }
+                const nestedResolved = collectCalleeDependencies(context.body, callExpression.callee, dependencies, context.callIndex, context.visitedCallees);
+                if (!nestedResolved) {
+                    resolved = false;
+                    return { skipChildren: true };
+                }
                 return undefined;
-            }
-            const nestedResolved = collectCalleeDependencies(context.body, callExpression.callee, dependencies, context.callIndex, context.visitedCallees);
-            if (!nestedResolved) {
-                resolved = false;
-                return { skipChildren: true };
-            }
-            return undefined;
-        },
-    });
+            },
+        });
+    };
+    // Parameter initializers run on entry, so a call sitting in a default reaches
+    // the callee's captures exactly as a call in the body does. Restricting this
+    // walk to the body contributes the callee's NAME without any of its captures,
+    // and the reordering fix then hoists the effect above a binding that callee
+    // reads -- a TDZ ReferenceError at runtime with no lint-visible symptom.
+    // `collectFunctionCaptures` above spans `fn.params` for the same reason.
+    fn.params.forEach((param) => resolveCallsIn(param));
+    resolveCallsIn(fn.body);
     return resolved;
 }
 function resolveValueForIdentifier(body, name, beforeIndex) {

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -661,7 +661,12 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
             const callback = getCallbackArg(callExpression);
             if (!callback)
                 return;
-            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback.body, context))
+            // The exemption is for a callback that RENDERS. Handing `callback.body`
+            // let a callback returning a FUNCTION claim it, because returnsJSX
+            // unwraps a handed function instead of judging it as a value — so
+            // `useCallback(() => () => <div/>, [])` was exempt while the identical
+            // block-bodied spelling reported (#2192).
+            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback, context))
                 return;
             const extraTypeRoots = [];
             if (callExpression.parent &&