@blumintinc/eslint-plugin-blumint 1.20.1 → 1.20.3

package/lib/index.js

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

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -166,6 +166,28 @@ function isExported(node) {
     }
     return false;
 }
+/**
+ * Renames `identifier` to `newName` while leaving every other token inside the
+ * identifier's range intact.
+ *
+ * A TSESTree `Identifier` node's range spans the tokens that trail its name:
+ * a type annotation (`validateBy: Validator`), a definite-assignment assertion
+ * (`validateBy!: Validator`) and an optional marker (`cbBy?: Fn`). Replacing the
+ * whole node therefore deletes them, and dropping a contextual type turns
+ * inferred parameters into implicit `any` so the file no longer compiles — a
+ * silent corruption, since the rule reports nothing afterwards (#1351). The name
+ * is always the identifier's first token, so replacing that token's range alone
+ * renames the symbol and nothing else.
+ */
+function renameIdentifier(fixer, sourceCode, identifier, newName) {
+    const nameToken = sourceCode.getFirstToken(identifier);
+    // The token store yields the name for every real identifier; the arithmetic
+    // end keeps the range narrowed even if a token is somehow unavailable.
+    const nameEnd = nameToken
+        ? nameToken.range[1]
+        : identifier.range[0] + identifier.name.length;
+    return fixer.replaceTextRange([identifier.range[0], nameEnd], newName);
+}
 /**
  * Walks a scope chain upward from `scope` (inclusive) and reports whether
  * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
@@ -206,6 +228,183 @@ function isNameBoundInSubtree(root, targetName) {
     }
     return false;
 }
+/**
+ * Annotations that impose no excess-property check. A value annotated `any` or
+ * `unknown` may carry members its annotation never declares, so the annotation
+ * proves nothing about where a member name came from (#1350).
+ */
+const UNCHECKED_ANNOTATION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAnyKeyword,
+    utils_1.AST_NODE_TYPES.TSUnknownKeyword,
+]);
+/**
+ * The declared type of an annotation-bearing node (`const x: T`, `field: T`),
+ * or null when the node carries no annotation.
+ */
+function declaredTypeNode(node) {
+    const { typeAnnotation } = node;
+    return typeAnnotation?.typeAnnotation ?? null;
+}
+function checksExcessProperties(typeNode) {
+    return typeNode !== null && !UNCHECKED_ANNOTATION_TYPES.has(typeNode.type);
+}
+/**
+ * Reports whether `node` sits inside a value whose shape TypeScript checks
+ * against a declared type — a type-annotated variable or class field, or a
+ * `satisfies` clause. Excess-property checking makes such a literal unable to
+ * carry a member the target type does not declare, so a member name there is
+ * dictated by that type rather than chosen by the author, and renaming it would
+ * break conformance (#1350). No member resolution is needed: the signal alone
+ * is proof, because code carrying an undeclared member does not compile.
+ *
+ * The walk climbs object/array containers so an outer signal covers nested
+ * members, and stops at anything else — notably `as` assertions, which do not
+ * reject undeclared members the same way.
+ */
+function hasConformanceSignal(node) {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (!parent) {
+            return false;
+        }
+        switch (parent.type) {
+            case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+                return (parent.expression === current &&
+                    checksExcessProperties(parent.typeAnnotation));
+            case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                return (parent.init === current &&
+                    checksExcessProperties(declaredTypeNode(parent.id)));
+            case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                return (parent.value === current &&
+                    checksExcessProperties(declaredTypeNode(parent)));
+            case utils_1.AST_NODE_TYPES.Property:
+            case utils_1.AST_NODE_TYPES.ObjectExpression:
+            case utils_1.AST_NODE_TYPES.ArrayExpression:
+                current = parent;
+                break;
+            default:
+                return false;
+        }
+    }
+}
+function buildDeclarationIndex(sourceCode) {
+    const index = {
+        interfaces: new Map(),
+        typeAliases: new Map(),
+        classes: new Map(),
+    };
+    // Declarations are collected from the whole file rather than from
+    // `Program.body` alone so contracts declared inside modules, blocks or
+    // functions resolve as well as top-level ones.
+    const stack = [sourceCode.ast];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: {
+                const merged = index.interfaces.get(current.id.name) ?? [];
+                merged.push(current);
+                index.interfaces.set(current.id.name, merged);
+                break;
+            }
+            case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+                index.typeAliases.set(current.id.name, current);
+                break;
+            case utils_1.AST_NODE_TYPES.ClassDeclaration:
+            case utils_1.AST_NODE_TYPES.ClassExpression:
+                if (current.id) {
+                    index.classes.set(current.id.name, current);
+                }
+                break;
+            default:
+                break;
+        }
+        for (const key of sourceCode.visitorKeys[current.type] ?? []) {
+            const value = current[key];
+            const children = Array.isArray(value) ? value : [value];
+            for (const child of children) {
+                if (child && typeof child === 'object' && 'type' in child) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+    return index;
+}
+function heritageTypeName(expression) {
+    return expression.type === utils_1.AST_NODE_TYPES.Identifier ? expression.name : null;
+}
+function membersDeclareName(members, memberName) {
+    return members.some((member) => (member.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+        member.type === utils_1.AST_NODE_TYPES.TSPropertySignature) &&
+        member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+        member.key.name === memberName);
+}
+function classBodyDeclaresName(members, memberName) {
+    return members.some((member) => (member.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+        member.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+        member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+        member.key.name === memberName);
+}
+/**
+ * Reports whether the contract named `typeName` accounts for `memberName`,
+ * either by declaring it or by being unreadable from this file. A class may add
+ * members its contract never declares, so presence of a heritage clause alone
+ * cannot exempt a name — but an imported or otherwise unresolvable contract
+ * hides its members from a purely syntactic rule, and this plugin prefers a
+ * false negative over a false positive (#1350).
+ */
+function contractCoversName(typeName, memberName, index, visited) {
+    // A name already inspected on this path adds nothing and would loop on a
+    // circular heritage chain.
+    if (visited.has(typeName)) {
+        return false;
+    }
+    visited.add(typeName);
+    const interfaces = index.interfaces.get(typeName);
+    if (interfaces) {
+        return interfaces.some((declaration) => membersDeclareName(declaration.body.body, memberName) ||
+            heritageCoversName(declaration.extends ?? [], memberName, index, visited));
+    }
+    const alias = index.typeAliases.get(typeName);
+    if (alias) {
+        // An alias to anything but a type literal (an intersection, a mapped type,
+        // a reference to an imported type) hides its member list from a syntactic
+        // reader, so it is treated as unreadable.
+        return (alias.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral ||
+            membersDeclareName(alias.typeAnnotation.members, memberName));
+    }
+    const classDeclaration = index.classes.get(typeName);
+    if (classDeclaration) {
+        return (classBodyDeclaresName(classDeclaration.body.body, memberName) ||
+            classContractCoversName(classDeclaration, memberName, index, visited));
+    }
+    // Nothing under this name in the file: the contract lives in another module
+    // and its members are unreadable here.
+    return true;
+}
+function heritageCoversName(heritage, memberName, index, visited) {
+    return heritage.some((clause) => {
+        const typeName = heritageTypeName(clause.expression);
+        // A namespaced or computed heritage expression cannot be followed
+        // syntactically, so it counts as an unreadable contract.
+        return (typeName === null ||
+            contractCoversName(typeName, memberName, index, visited));
+    });
+}
+function classContractCoversName(classNode, memberName, index, visited) {
+    if (heritageCoversName(classNode.implements ?? [], memberName, index, visited)) {
+        return true;
+    }
+    const { superClass } = classNode;
+    if (!superClass) {
+        return false;
+    }
+    const superName = heritageTypeName(superClass);
+    // A computed superclass (a mixin call) is unreadable, like an imported one.
+    return (superName === null ||
+        contractCoversName(superName, memberName, index, visited));
+}
 exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     name: 'no-unnecessary-verb-suffix',
     meta: {
@@ -222,6 +421,37 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // Built on first heritage question only, since most files never ask one.
+        let declarationIndex = null;
+        function getDeclarationIndex() {
+            if (declarationIndex === null) {
+                declarationIndex = buildDeclarationIndex(context.sourceCode);
+            }
+            return declarationIndex;
+        }
+        /**
+         * Reports whether a class member's name comes from a contract the class
+         * declares conformance to, rather than from its author (#1350).
+         */
+        function isDictatedByHeritage(node, memberName) {
+            const classBody = node.parent;
+            if (!classBody || classBody.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+                return false;
+            }
+            const classNode = classBody.parent;
+            if (!classNode ||
+                (classNode.type !== utils_1.AST_NODE_TYPES.ClassDeclaration &&
+                    classNode.type !== utils_1.AST_NODE_TYPES.ClassExpression)) {
+                return false;
+            }
+            // Indexing the file's declarations is only worth its cost once a class
+            // declares conformance to something.
+            if ((classNode.implements ?? []).length === 0 &&
+                classNode.superClass === null) {
+                return false;
+            }
+            return classContractCoversName(classNode, memberName, getDeclarationIndex(), new Set());
+        }
         /**
          * Returns true when renaming the symbol to `suggestion` would collide with
          * an existing binding in any scope the rename touches, making the autofix
@@ -353,16 +583,19 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                                 // Scope-tracked symbols (FunctionDeclaration, VariableDeclarator
                                 // arrows/functions, named FunctionExpression): rename the
                                 // declaration identifier and every in-file reference together so
-                                // no call site is left pointing at the old name.
+                                // no call site is left pointing at the old name. Every rewrite
+                                // goes through renameIdentifier, because an identifier's range
+                                // can carry trailing tokens that must survive a rename (#1351).
+                                const { sourceCode } = context;
                                 const fixes = [
-                                    fixer.replaceText(declarationIdNode, suggestion),
+                                    renameIdentifier(fixer, sourceCode, declarationIdNode, suggestion),
                                 ];
                                 if (targetVariable) {
                                     for (const ref of targetVariable.references) {
                                         // Skip the declaration identifier itself — already handled.
                                         if (ref.identifier === declarationIdNode)
                                             continue;
-                                        fixes.push(fixer.replaceText(ref.identifier, suggestion));
+                                        fixes.push(renameIdentifier(fixer, sourceCode, ref.identifier, suggestion));
                                     }
                                 }
                                 return fixes;
@@ -387,6 +620,11 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
             },
             MethodDefinition(node) {
                 if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // A member implementing a contract the class declares conformance to
+                    // is named by that contract, so renaming it would break conformance.
+                    if (isDictatedByHeritage(node, node.key.name)) {
+                        return;
+                    }
                     // Class methods are called via member expressions (`this.method()`,
                     // `instance.method()`) that the scope manager does not track as
                     // references. A syntactic single-file fixer therefore cannot find and
@@ -408,6 +646,12 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                 if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                     (node.value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                         node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    // A literal checked against a declared type can only hold members
+                    // that type declares, so its member names are not the author's to
+                    // rename.
+                    if (hasConformanceSignal(node)) {
+                        return;
+                    }
                     // Object-literal method properties are accessed via member expressions
                     // (`obj.method()`) the scope manager does not track. As with class
                     // methods, the fix is suppressed to avoid orphaning call sites.

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.3",
+    "date": "2026-07-25T02:54:46.197Z",
+    "rules": [
+      {
+        "name": "no-unnecessary-verb-suffix",
+        "changeType": "fix",
+        "issues": [
+          1351
+        ],
+        "summary": "preserve type annotations when the rename autofix renames an identifier (closes #1351)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.2",
+    "date": "2026-07-25T02:42:18.863Z",
+    "rules": [
+      {
+        "name": "no-unnecessary-verb-suffix",
+        "changeType": "fix",
+        "issues": [
+          1350
+        ],
+        "summary": "exempt member names dictated by a declared contract (closes #1350)"
+      }
+    ]
+  },
   {
     "version": "1.20.1",
     "date": "2026-07-24T22:02:37.444Z",