@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/no-hungarian.js

@@ -17,8 +17,10 @@ const COMMON_TYPES = [
     'Symbol',
     'BigInt',
 ];
-// Combined type markers (former Hungarian prefixes and type suffixes)
-const TYPE_MARKERS = [
+// Abbreviation type markers (e.g. str, arr, obj). No English word is spelled this
+// way, so their presence as a segment — even in the middle of a name — is
+// unambiguously a type tag (strName, USER_STR_NAME, ConfigArrSettings).
+const ABBREVIATION_MARKERS = [
     'str',
     'num',
     'int',
@@ -27,6 +29,10 @@ const TYPE_MARKERS = [
     'obj',
     'fn',
     'func',
+];
+// Combined type markers (former Hungarian prefixes and type suffixes)
+const TYPE_MARKERS = [
+    ...ABBREVIATION_MARKERS,
     'array',
     ...COMMON_TYPES,
     'Class',
@@ -34,6 +40,20 @@ const TYPE_MARKERS = [
     //'Type', people like to use 'type' as a general purpose noun
     'Enum',
 ];
+const ABBREVIATION_MARKER_SET = new Set(ABBREVIATION_MARKERS);
+// Single-letter Hungarian type prefixes (b=boolean, i=integer/index).
+// Only matched as a strict camelCase prefix (e.g. bIsActive, iCount); never as
+// a suffix/middle/SCREAMING_SNAKE segment, where a lone letter is almost always
+// a real word fragment (tab, lib, ui) rather than a type tag.
+const SINGLE_LETTER_PREFIXES = new Set(['b', 'i']);
+// Full type-concept words (spelled out). When one of these appears as a clean
+// PascalCase segment inside a multi-word TYPE name (alias/interface/class), it
+// denotes a type concept/relation (e.g. StringToNumber, CapitalizedString,
+// PromiseOrValue) rather than a redundant Hungarian type tag — comparable to the
+// allowed compound noun PhoneNumber. Abbreviation markers (str/arr/obj/...) are
+// deliberately excluded: no English word is spelled that way, so their presence
+// as a segment is unambiguously a type tag even inside a type name.
+const FULL_TYPE_WORDS = new Set([...COMMON_TYPES, 'Func'].map((word) => word.toLowerCase()));
 // Allowed descriptive suffixes that should not be flagged as Hungarian notation
 const ALLOWED_SUFFIXES = [
     'Formatted',
@@ -190,6 +210,30 @@ const BUILT_IN_METHODS = new Set([
     'catch',
     'finally',
 ]);
+// Split a PascalCase/camelCase identifier into its word segments
+// (e.g. "StringToNumber" -> ["String","To","Number"], "FuncKeys" -> ["Func","Keys"]).
+function splitCamelSegments(name) {
+    return name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? [];
+}
+// A TYPE name (alias/interface/class) is exempt from a full-type-word marker when
+// that marker is one clean PascalCase segment among OTHER descriptive segments —
+// i.e. the word denotes a type concept/relation, not a redundant type tag.
+// Examples: StringToNumber, CapitalizedString, PromiseOrValue, FuncKeys.
+// Abbreviation markers (str/arr/obj/...) never qualify, so genuine Hungarian type
+// names like UserStrName / ConfigArrSettings / UserObjData still fire.
+function isSemanticTypeConcept(typeName) {
+    const segments = splitCamelSegments(typeName);
+    if (segments.length < 2) {
+        return false;
+    }
+    const fullTypeWordSegments = segments.filter((segment) => FULL_TYPE_WORDS.has(segment.toLowerCase()));
+    if (fullTypeWordSegments.length === 0) {
+        return false;
+    }
+    // At least one segment must be a non-type-word descriptor so the name reads as a
+    // concept (e.g. Extract+Number) rather than bare type tags glued together.
+    return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
+}
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
@@ -208,8 +252,28 @@ exports.noHungarian = (0, createRule_1.createRule)({
     create(context) {
         // Track identifiers that have already been checked to prevent double reporting
         const checkedIdentifiers = new Set();
-        // Check if a variable name contains a type marker with proper word boundaries
-        function hasTypeMarker(variableName) {
+        // Names declared as generic type parameters (e.g. TNumber, TKey). The leading
+        // `T` is the TypeScript convention for "Type parameter", not a Hungarian tag,
+        // so neither the declaration nor any reference to it is ever flagged.
+        const typeParameterNames = new Set();
+        // Check if a variable name contains a type marker with proper word boundaries.
+        // `isTypeName` is true for PascalCase type declarations (type aliases,
+        // interfaces, classes), enabling the semantic-type-concept exemption.
+        function hasTypeMarker(variableName, isTypeName = false) {
+            // Type names whose type-word denotes a concept/relation (StringToNumber,
+            // CapitalizedString, FuncKeys, PromiseOrValue) are not Hungarian — the word
+            // is part of the type's meaning, like the allowed compound noun PhoneNumber.
+            if (isTypeName && isSemanticTypeConcept(variableName)) {
+                return false;
+            }
+            // Single-letter Hungarian prefixes (bIsActive, iCount): a lone b/i directly
+            // followed by an uppercase letter is a type tag. Restricted to camelCase
+            // (lowercase first letter) to avoid PascalCase type names like IButton.
+            if (variableName.length > 1 &&
+                SINGLE_LETTER_PREFIXES.has(variableName[0]) &&
+                /[A-Z]/.test(variableName[1])) {
+                return true;
+            }
             // Check if the variable name is exactly one of the allowed compound nouns
             // or if it contains one of the allowed compound nouns but is not a prefix like "strPhoneNumber"
             for (const compoundNoun of ALLOWED_COMPOUND_NOUNS) {
@@ -244,22 +308,28 @@ exports.noHungarian = (0, createRule_1.createRule)({
                 if (!variableName.includes('_')) {
                     return false;
                 }
+                const parts = variableName.split('_');
+                const lastIndex = parts.length - 1;
                 return TYPE_MARKERS.some((marker) => {
                     const markerUpper = marker.toUpperCase();
-                    // Check if it's a prefix (PREFIX_REST)
-                    if (variableName.startsWith(markerUpper + '_') &&
-                        variableName.length > markerUpper.length + 1) {
-                        return true;
-                    }
-                    // Check if it's a suffix (REST_SUFFIX)
-                    if (variableName.endsWith('_' + markerUpper) &&
-                        variableName.length > markerUpper.length + 1) {
-                        return true;
-                    }
-                    // Check if it's in the middle (PART_MARKER_PART)
-                    const parts = variableName.split('_');
-                    // Only consider exact matches for parts, not substrings
-                    return parts.some((part) => part === markerUpper);
+                    const normalizedMarker = marker.toLowerCase();
+                    const isAbbreviation = ABBREVIATION_MARKER_SET.has(normalizedMarker);
+                    return parts.some((part, index) => {
+                        if (part !== markerUpper) {
+                            return false;
+                        }
+                        // Abbreviation markers (STR/ARR/OBJ/...) are type tags in any
+                        // position — no English word is spelled that way.
+                        if (isAbbreviation) {
+                            return true;
+                        }
+                        // A FULL type word tags the entity's type only at the start (prefix),
+                        // the end (suffix), or directly before the final noun
+                        // (..._STRING_NAME). Buried deeper (EDITABLE_WRAPPER_NUMBER_PROPS_…)
+                        // it qualifies an intermediate segment — a descriptive variant, not a
+                        // type tag.
+                        return (index === 0 || index === lastIndex || index === lastIndex - 1);
+                    });
                 });
             }
             // For camelCase, PascalCase, etc.
@@ -328,9 +398,27 @@ exports.noHungarian = (0, createRule_1.createRule)({
             }
             return false;
         }
-        // Check identifier for type markers (Hungarian notation)
-        function checkIdentifier(node) {
+        // Determine whether an identifier is (or references) a generic type parameter.
+        function isTypeParameter(node) {
+            // The type-parameter declaration itself: <TNumber>
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameter &&
+                node.parent.name === node) {
+                return true;
+            }
+            // A reference to a declared type parameter (e.g. x: TNumber).
+            return typeParameterNames.has(node.name);
+        }
+        // Check identifier for type markers (Hungarian notation).
+        // `isTypeName` enables the semantic-type-concept exemption for type
+        // declarations (aliases, interfaces, classes).
+        function checkIdentifier(node, isTypeName = false) {
             const name = node.name;
+            // Generic type parameters (TNumber, TKey, ...) are a TypeScript naming
+            // convention, never Hungarian — skip the declaration and all references.
+            if (isTypeParameter(node)) {
+                return;
+            }
             // Create a unique ID for this node to avoid checking it twice
             // Use the name along with source location for uniqueness
             const nodeId = `${name}:${node.loc.start.line}:${node.loc.start.column}`;
@@ -344,7 +432,7 @@ exports.noHungarian = (0, createRule_1.createRule)({
             if (isExternalOrBuiltIn(node))
                 return;
             // Check for type markers
-            if (hasTypeMarker(name)) {
+            if (hasTypeMarker(name, isTypeName)) {
                 context.report({
                     node,
                     messageId: 'noHungarian',
@@ -388,10 +476,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     }
                 }
             },
+            // Record generic type-parameter names so neither the declaration nor any
+            // reference to them is flagged (the leading `T` is a TS convention).
+            TSTypeParameter(node) {
+                if (node.name.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    typeParameterNames.add(node.name.name);
+                }
+            },
             // Check class declarations
             ClassDeclaration(node) {
                 if (node.id) {
-                    checkIdentifier(node.id);
+                    checkIdentifier(node.id, true);
                 }
                 // Check class methods and properties
                 for (const member of node.body.body) {
@@ -421,11 +516,11 @@ exports.noHungarian = (0, createRule_1.createRule)({
             },
             // Check type aliases
             TSTypeAliasDeclaration(node) {
-                checkIdentifier(node.id);
+                checkIdentifier(node.id, true);
             },
             // Check interface declarations
             TSInterfaceDeclaration(node) {
-                checkIdentifier(node.id);
+                checkIdentifier(node.id, true);
             },
         };
     },

package/lib/rules/no-inline-component-prop.js

@@ -190,9 +190,9 @@ function isInModuleScope(node) {
     }
     return true;
 }
-function isComponentLikeFunction(fn, displayName) {
+function isComponentLikeFunction(fn, context, displayName) {
     const body = fn.body;
-    const hasJSX = !!body && ASTHelpers_1.ASTHelpers.returnsJSX(body);
+    const hasJSX = !!body && ASTHelpers_1.ASTHelpers.returnsJSX(body, context);
     const expressionBody = fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
         fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement
         ? fn.body
@@ -204,7 +204,15 @@ function isComponentLikeFunction(fn, displayName) {
 }
 function findVariableInScopes(context, identifier) {
     const sourceCode = context.sourceCode;
-    let scope = sourceCode.getScope?.(identifier) ?? context.getScope();
+    let scope = null;
+    try {
+        // Tolerate ESLint API variations across versions/configurations.
+        // Some contexts may not provide getScope or may throw unexpectedly.
+        scope = sourceCode.getScope?.(identifier) ?? context.getScope();
+    }
+    catch {
+        scope = null;
+    }
     while (scope) {
         const variable = scope.variables.find((v) => v.name === identifier.name);
         if (variable)
@@ -340,7 +348,7 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             }
             if (!fnNode)
                 return false;
-            return isComponentLikeFunction(fnNode, displayName);
+            return isComponentLikeFunction(fnNode, context, displayName);
         }
         function report(node, propName, componentName) {
             context.report({
@@ -394,13 +402,14 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
                 return;
             }
             const fnNode = findObjectPropertyFunction(defNode.init, member.property.name);
-            if (fnNode && isComponentLikeFunction(fnNode, member.property.name)) {
+            if (fnNode &&
+                isComponentLikeFunction(fnNode, context, member.property.name)) {
                 report(member, propName, member.property.name);
             }
         }
         function handleInlineFunctionExpression(fn, propName) {
             const explicitName = fn.type === utils_1.AST_NODE_TYPES.FunctionExpression ? fn.id?.name : undefined;
-            if (!isComponentLikeFunction(fn, explicitName)) {
+            if (!isComponentLikeFunction(fn, context, explicitName)) {
                 return;
             }
             const displayName = (fn.type === utils_1.AST_NODE_TYPES.FunctionExpression && fn.id?.name) ||
@@ -411,7 +420,7 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             const fnNode = getFunctionFromCall(call);
             if (!fnNode)
                 return;
-            if (isComponentLikeFunction(fnNode)) {
+            if (isComponentLikeFunction(fnNode, context)) {
                 report(call, propName, INLINE_COMPONENT_NAME);
             }
         }

package/lib/rules/no-margin-properties.js

@@ -67,7 +67,13 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
             const normalizedName = normalizePropertyName(propertyName);
             return MARGIN_PROPERTIES.has(normalizedName);
         }
-        // Check if a node is within an sx prop context or theme override context
+        /**
+         * True if node is in a flagged MUI styling context (sx attribute, sx
+         * object property, or css() call). Excludes createTheme styleOverrides:
+         * theme margins ARE the container-controlled styling (viewport insets,
+         * resets of MUI's built-in margins, internal layout), not the
+         * sibling-spacing this rule targets.
+         */
         function isMuiStylingContext(node) {
             let current = node;
             while (current?.parent) {
@@ -83,13 +89,6 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                     current.parent.key.name === 'sx') {
                     return true;
                 }
-                // Check for theme overrides (MUI's createTheme)
-                if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
-                    current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (current.parent.key.name === 'styleOverrides' ||
-                        current.parent.key.name === 'components')) {
-                    return true;
-                }
                 // Check for MUI's css function
                 if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
                     current.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -290,36 +289,6 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                         checkObjectExpression(arg);
                     }
                 }
-                // Handle createTheme for MUI theme overrides
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.name === 'createTheme' &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    const themeObj = node.arguments[0];
-                    // Find components property in theme object
-                    const componentsProperty = themeObj.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        prop.key.name === 'components' &&
-                        prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
-                    if (componentsProperty &&
-                        componentsProperty.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // Check each component override
-                        componentsProperty.value.properties.forEach((componentProp) => {
-                            if (componentProp.type === utils_1.AST_NODE_TYPES.Property &&
-                                componentProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                // Find styleOverrides property
-                                const styleOverrides = componentProp.value.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    prop.key.name === 'styleOverrides' &&
-                                    prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
-                                if (styleOverrides &&
-                                    styleOverrides.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                    checkObjectExpression(styleOverrides.value);
-                                }
-                            }
-                        });
-                    }
-                }
             },
         };
     },

package/lib/rules/no-passthrough-getters.d.ts

@@ -1,4 +1,4 @@
-import { TSESTree } from '@typescript-eslint/utils';
-export declare const noPassthroughGetters: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noPassthroughGetter", never[], {
+import { TSESTree, TSESLint } from '@typescript-eslint/utils';
+export declare const noPassthroughGetters: TSESLint.RuleModule<"noPassthroughGetter", never[], {
     MethodDefinition(node: TSESTree.MethodDefinition): void;
 }>;

package/lib/rules/no-passthrough-getters.js

@@ -1,9 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noPassthroughGetters = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
 const getMethodName_1 = require("../utils/getMethodName");
+const ts = __importStar(require("typescript"));
 const COMPLEX_EXPRESSION_TYPES = new Set([
     utils_1.AST_NODE_TYPES.CallExpression,
     utils_1.AST_NODE_TYPES.TemplateLiteral,
@@ -14,7 +38,7 @@ const COMPLEX_EXPRESSION_TYPES = new Set([
 ]);
 exports.noPassthroughGetters = (0, createRule_1.createRule)({
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         return {
             // Target getter methods in classes
             MethodDefinition(node) {
@@ -26,6 +50,10 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
                 if (node.decorators && node.decorators.length > 0) {
                     return;
                 }
+                // Check if this getter satisfies an interface or overrides a base class member
+                if (isRequiredByInterfaceOrBaseClass(node, sourceCode)) {
+                    return;
+                }
                 const methodBody = node.value.body;
                 if (!methodBody) {
                     return;
@@ -74,6 +102,60 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
                 }
             },
         };
+        /**
+         * Check if the getter is required by an implemented interface or overrides a base class member
+         */
+        function isRequiredByInterfaceOrBaseClass(node, sourceCode) {
+            const parserServices = sourceCode.parserServices;
+            if (!parserServices ||
+                !parserServices.program ||
+                !parserServices.esTreeNodeToTSNodeMap) {
+                return false;
+            }
+            const checker = parserServices.program.getTypeChecker();
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            if (!tsNode) {
+                return false;
+            }
+            const symbol = checker.getSymbolAtLocation(tsNode.name);
+            if (!symbol ||
+                !tsNode.parent ||
+                !(ts.isClassDeclaration(tsNode.parent) ||
+                    ts.isClassExpression(tsNode.parent))) {
+                return false;
+            }
+            const classNode = tsNode.parent;
+            const classType = checker.getTypeAtLocation(classNode);
+            const classSymbol = classType.getSymbol();
+            if (!classSymbol) {
+                return false;
+            }
+            const instanceType = checker.getDeclaredTypeOfSymbol(classSymbol);
+            const name = symbol.getName();
+            // Check base classes
+            const baseTypes = instanceType.getBaseTypes() || [];
+            for (const baseType of baseTypes) {
+                if (baseType.getProperty(name)) {
+                    return true;
+                }
+            }
+            // Check interfaces
+            if (classNode.heritageClauses) {
+                for (const clause of classNode.heritageClauses) {
+                    // Only check implemented interfaces as base classes are already checked via getBaseTypes()
+                    if (clause.token !== ts.SyntaxKind.ImplementsKeyword) {
+                        continue;
+                    }
+                    for (const typeNode of clause.types) {
+                        const type = checker.getTypeAtLocation(typeNode);
+                        if (type.getProperty(name)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
         /**
          * Check if the node is a simple property access from a constructor parameter
          * like this.settings.property or this.settings['property'] or this.settings.nested.deep.property

package/lib/rules/no-redundant-this-params.js

@@ -21,6 +21,7 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const classInfoMap = new WeakMap();
+        const classStatsMap = new WeakMap();
         function isFunctionLike(node) {
             return (node?.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
                 node?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -412,6 +413,24 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
         return {
             'ClassDeclaration, ClassExpression'(node) {
                 collectClassInfo(node);
+                classStatsMap.set(node, { methods: new Map() });
+            },
+            'ClassDeclaration, ClassExpression:exit'(node) {
+                const stats = classStatsMap.get(node);
+                if (!stats) {
+                    return;
+                }
+                for (const [methodName, methodStats] of stats.methods) {
+                    for (const [argIndex, argProperties] of methodStats.argStats) {
+                        for (const [, propStats] of argProperties) {
+                            if (propStats.callsWithProperty === methodStats.totalCalls) {
+                                for (const violation of propStats.violations) {
+                                    reportAccess(methodName, violation.methodMeta, argIndex, violation.access);
+                                }
+                            }
+                        }
+                    }
+                }
             },
             CallExpression(node) {
                 const methodName = getMethodNameFromCallee(node.callee);
@@ -442,6 +461,18 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
                         return;
                     }
                 }
+                const stats = classStatsMap.get(classNode);
+                if (!stats) {
+                    return;
+                }
+                let methodStats = stats.methods.get(methodName);
+                if (!methodStats) {
+                    methodStats = { totalCalls: 0, argStats: new Map() };
+                    stats.methods.set(methodName, methodStats);
+                }
+                const currentMethodStats = methodStats;
+                currentMethodStats.totalCalls++;
+                const seenInThisCall = new Set();
                 node.arguments.forEach((arg, index) => {
                     if (!arg) {
                         return;
@@ -449,7 +480,25 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
                     const targetNode = arg.type === utils_1.AST_NODE_TYPES.SpreadElement ? arg.argument : arg;
                     const accesses = collectThisAccesses(targetNode);
                     for (const access of accesses) {
-                        reportAccess(methodName, methodMeta, index, access);
+                        const key = `${index}:${access.propertyName}`;
+                        let argMap = currentMethodStats.argStats.get(index);
+                        if (!argMap) {
+                            argMap = new Map();
+                            currentMethodStats.argStats.set(index, argMap);
+                        }
+                        let propStats = argMap.get(access.propertyName);
+                        if (!propStats) {
+                            propStats = { callsWithProperty: 0, violations: [] };
+                            argMap.set(access.propertyName, propStats);
+                        }
+                        propStats.violations.push({
+                            methodMeta: methodMeta,
+                            access,
+                        });
+                        if (!seenInThisCall.has(key)) {
+                            propStats.callsWithProperty++;
+                            seenInThisCall.add(key);
+                        }
                     }
                 });
             },

package/lib/rules/no-unmemoized-memo-without-props.js

@@ -274,7 +274,7 @@ exports.noUnmemoizedMemoWithoutProps = (0, createRule_1.createRule)({
             if (!node.body) {
                 return;
             }
-            const returnsJsx = ASTHelpers_1.ASTHelpers.returnsJSX(node.body);
+            const returnsJsx = ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
             if (!returnsJsx) {
                 return;
             }

package/lib/rules/no-unnecessary-destructuring-rename.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnnecessaryDestructuringRename = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const BINDABLE_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const RESERVED_BINDINGS = new Set([
     'break',
@@ -113,11 +114,7 @@ exports.noUnnecessaryDestructuringRename = (0, createRule_1.createRule)({
         const sourceCode = context.getSourceCode();
         const candidates = [];
         const getDeclaredVariables = (node) => {
-            const sourceCodeWithDeclarations = sourceCode;
-            if (typeof sourceCodeWithDeclarations.getDeclaredVariables === 'function') {
-                return sourceCodeWithDeclarations.getDeclaredVariables(node);
-            }
-            return context.getDeclaredVariables(node);
+            return ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, node);
         };
         function collectDeclaredVariablesUpTree(node) {
             const variables = [];