@blumintinc/eslint-plugin-blumint 1.20.7 → 1.20.8

package/lib/index.js

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

package/lib/rules/enforce-props-argument-name.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'usePropsParameterName' | 'usePropsParameterNameWithPrefix';
-export declare const enforcePropsArgumentName: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforcePropsArgumentName: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

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

@@ -4,6 +4,97 @@ exports.enforcePropsArgumentName = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+/**
+ * A body-less signature (an interface method signature, or an abstract /
+ * `declare` / overload class method) has no statements, so its parameter name
+ * is documentation-only and can never be referenced in-file. A
+ * declaration-only rename is therefore complete rather than partial, and stays
+ * safe even if the scope analyzer declines to model the parameter.
+ */
+const isBodylessSignature = (owner) => owner.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+    owner.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
+/**
+ * Rewrites only the identifier's first token. A TSESTree `Identifier` range
+ * spans its type annotation and optional marker (`props?: RunnerProps`), so
+ * `fixer.replaceText(id, newName)` would delete the annotation along with the
+ * name (Issue #1351).
+ */
+const renameIdentifierToken = (fixer, sourceCode, identifier, text) => {
+    const token = sourceCode.getFirstToken(identifier);
+    if (!token) {
+        return null;
+    }
+    return fixer.replaceTextRange([token.range[0], token.range[1]], text);
+};
+/**
+ * Walks the scope chain upward from `scope` (inclusive) and reports whether
+ * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
+ * Mirrors how the engine resolves an identifier at a use site: the first scope
+ * on the chain that declares the name wins. Used to detect whether a rewritten
+ * reference would be captured by a binding sitting between it and the
+ * declaration it currently resolves to.
+ */
+const isNameBoundInChain = (scope, stopScope, targetName) => {
+    let current = scope;
+    while (current) {
+        if (current.set.has(targetName)) {
+            return true;
+        }
+        if (current === stopScope) {
+            break;
+        }
+        current = current.upper;
+    }
+    return false;
+};
+/**
+ * Reports whether `targetName` is used as an identifier anywhere inside
+ * `scope` or its nested scopes. Such a use currently resolves to some other
+ * binding (an outer constant, a nested declaration); giving the parameter that
+ * same name would capture it, silently rebinding working code.
+ */
+const scopeSubtreeReferencesName = (scope, targetName) => {
+    const pending = [scope];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current.references.some((reference) => reference.identifier.name === targetName)) {
+            return true;
+        }
+        pending.push(...current.childScopes);
+    }
+    return false;
+};
+/**
+ * Returns true when renaming `variable` to `newName` would collide with an
+ * existing binding in any scope the rename touches, making the autofix
+ * semantics-changing (and thus unsafe). The fixer rewrites the declaration
+ * plus every in-file reference; if `newName` already resolves to a different
+ * binding, the rewrite would redeclare a name already bound in the declaration
+ * scope, capture a reference onto an intervening binding, or swallow a use of
+ * an outer binding that shares the name. In every such case the fix is
+ * suppressed (report-only).
+ */
+const renameWouldCollide = (variable, newName) => {
+    const declarationScope = variable.scope;
+    // (1) Declaration site: `newName` already bound in the scope that holds the
+    //     parameter would make the rename a redeclaration/shadow.
+    if (declarationScope.set.has(newName)) {
+        return true;
+    }
+    // (2) Reference sites: a binding of `newName` sitting between a reference and
+    //     the declaration scope would swallow the rewritten identifier — the
+    //     reference would resolve to that binding instead of the parameter.
+    for (const reference of variable.references) {
+        const referenceScope = reference.from ?? declarationScope;
+        if (isNameBoundInChain(referenceScope, declarationScope, newName)) {
+            return true;
+        }
+    }
+    // (3) Capture: the parameter's own scope (or a nested one) already uses
+    //     `newName` for something else, so introducing the parameter under that
+    //     name would shadow whatever those uses resolve to.
+    return scopeSubtreeReferencesName(declarationScope, newName);
+};
 exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
     name: 'enforce-props-argument-name',
     meta: {
@@ -153,6 +244,65 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             }
             return null;
         }
+        // Build the complete rename: the parameter declaration AND every in-scope
+        // reference to it. A declaration-only rename leaves every use site bound to
+        // a now-undefined name, so `--fix` exits 0 while producing code that no
+        // longer compiles (Issue #1355, same defect class as #1313 and #1256).
+        // Returns null whenever the rename cannot be applied everywhere, so the
+        // report stands on its own rather than corrupting the source.
+        function buildParameterRenameFixes(fixer, owner, id, newName) {
+            const sourceCode = context.sourceCode;
+            const declarationFix = renameIdentifierToken(fixer, sourceCode, id, newName);
+            if (!declarationFix) {
+                return null;
+            }
+            // `getDeclaredVariables` on a function returns every parameter plus
+            // `arguments` and, for a declaration, the function's own name — and those
+            // can share a name (`function config(config: XProps)`), so the lookup
+            // matches on declaration identity instead of on the name.
+            const variable = context
+                .getDeclaredVariables(owner)
+                .find((candidate) => candidate.defs.some((def) => def.name === id)) ??
+                null;
+            if (!variable) {
+                return isBodylessSignature(owner) ? [declarationFix] : null;
+            }
+            if (renameWouldCollide(variable, newName)) {
+                return null;
+            }
+            const fixes = [declarationFix];
+            for (const reference of variable.references) {
+                const referenceId = reference.identifier;
+                // A parameter with a default value carries a write reference whose
+                // identifier is the declaration itself, already rewritten above.
+                // Skipping it also avoids overlapping fix ranges, which ESLint rejects.
+                if (referenceId === id) {
+                    continue;
+                }
+                const referenceParent = referenceId.parent;
+                // An object-literal shorthand `{ runnerProps }` desugars to
+                // `{ runnerProps: runnerProps }`: the single token is both the property
+                // key and its value. Rewriting it to `{ props }` would rename the KEY
+                // too, silently changing the object's shape. Expand to
+                // `oldKey: newName` so only the value is renamed.
+                if (referenceParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                    referenceParent.shorthand &&
+                    referenceParent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const shorthandFix = renameIdentifierToken(fixer, sourceCode, referenceId, `${id.name}: ${newName}`);
+                    if (!shorthandFix) {
+                        return null;
+                    }
+                    fixes.push(shorthandFix);
+                    continue;
+                }
+                const referenceFix = renameIdentifierToken(fixer, sourceCode, referenceId, newName);
+                if (!referenceFix) {
+                    return null;
+                }
+                fixes.push(referenceFix);
+            }
+            return fixes;
+        }
         // Check function parameters
         function checkFunctionParams(node) {
             // Skip function expressions that are part of method definitions
@@ -162,7 +312,6 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                 return;
             }
-            const sourceCode = context.sourceCode;
             const propsParams = getPropsParams(node.params);
             node.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
@@ -184,12 +333,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                     typeName,
                                     suggestedName,
                                 },
-                                fix: (fixer) => {
-                                    const token = sourceCode.getFirstToken(id);
-                                    if (!token)
-                                        return null;
-                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
-                                },
+                                fix: (fixer) => buildParameterRenameFixes(fixer, node, id, suggestedName),
                             });
                         }
                     }
@@ -258,7 +402,6 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         // Check class method parameters (including constructors)
         function checkClassMethod(node) {
             const method = node.value;
-            const sourceCode = context.sourceCode;
             const propsParams = getPropsParams(method.params);
             // When the enclosing class extends a base class, a constructor parameter
             // property (e.g. `private readonly fullProps: SubProps`) cannot be safely
@@ -305,10 +448,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                         parameterPropertyRenameIsUnsafe(enclosingClass, id.name, id)) {
                                         return null;
                                     }
-                                    const token = sourceCode.getFirstToken(id);
-                                    if (!token)
-                                        return null;
-                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
+                                    return buildParameterRenameFixes(fixer, method, id, suggestedName);
                                 },
                             });
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.7",
+  "version": "1.20.8",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.8",
+    "date": "2026-07-28T15:39:20.357Z",
+    "rules": [
+      {
+        "name": "enforce-props-argument-name",
+        "changeType": "fix",
+        "issues": [
+          1355
+        ],
+        "summary": "rename parameter references, not just the declaration (closes #1355)"
+      }
+    ]
+  },
   {
     "version": "1.20.7",
     "date": "2026-07-28T05:35:51.746Z",