@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.97

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

@@ -55,13 +55,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     if (!node.members || node.members.length === 0) {
                         return true;
                     }
-                    return node.members.some((member) => {
-                        if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                            member.typeAnnotation) {
-                            return hasInvalidType(member.typeAnnotation.typeAnnotation);
-                        }
-                        return false;
-                    });
+                    return membersHaveInvalidType(node.members);
                 case utils_1.AST_NODE_TYPES.TSTypeReference:
                     if (node.typeParameters) {
                         return node.typeParameters.params.some(hasInvalidType);
@@ -74,17 +68,9 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         }
                         // Prevent infinite recursion
                         typeCache.set(typeName, false);
-                        const program = context.sourceCode.ast;
-                        const interfaceDecl = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
-                            n.id.name === typeName);
-                        if (interfaceDecl) {
-                            const result = interfaceDecl.body.body.some((member) => {
-                                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                                    member.typeAnnotation) {
-                                    return hasInvalidType(member.typeAnnotation.typeAnnotation);
-                                }
-                                return false;
-                            });
+                        const members = declaredMembersOf(typeName);
+                        if (members) {
+                            const result = membersHaveInvalidType(members);
                             typeCache.set(typeName, result);
                             return result;
                         }
@@ -120,6 +106,73 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     return false;
             }
         }
+        function membersHaveInvalidType(members) {
+            return members.some((member) => {
+                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                    member.typeAnnotation) {
+                    return hasInvalidType(member.typeAnnotation.typeAnnotation);
+                }
+                return false;
+            });
+        }
+        /**
+         * Wrappers an alias may place around its type literal without changing the
+         * fields the document declares. `Readonly<{...}>` written inline at the
+         * reference is already looked through by the type-argument recursion in
+         * `hasInvalidType`, so reading it here keeps the two spellings in agreement.
+         * A wrapper that drops fields, such as `Omit`, is excluded: its members are
+         * not the document's members, and checking them invents reports.
+         */
+        const FIELD_PRESERVING_WRAPPERS = new Set(['Readonly']);
+        /**
+         * Reads the type literal an alias declares, looking through at most one
+         * field-preserving wrapper. Anything else — a union, an intersection, a
+         * mapped type, a reference to another named or imported type — has no
+         * members this rule can read syntactically, and guessing at them is how
+         * false positives arrive, so it stays unresolved.
+         */
+        function aliasedTypeLiteral(typeNode) {
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                return typeNode;
+            }
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+                typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !FIELD_PRESERVING_WRAPPERS.has(typeNode.typeName.name)) {
+                return undefined;
+            }
+            const wrapperArguments = typeNode.typeParameters?.params;
+            if (!wrapperArguments || wrapperArguments.length !== 1) {
+                return undefined;
+            }
+            const [wrapped] = wrapperArguments;
+            return wrapped.type === utils_1.AST_NODE_TYPES.TSTypeLiteral
+                ? wrapped
+                : undefined;
+        }
+        /**
+         * Resolves a named generic to the members its declaration lists, reading an
+         * interface and a type alias alike.
+         *
+         * The alias spelling is not an extra convenience: `prefer-type-over-interface`
+         * ships in the same recommended config and is fixable, so a single
+         * `eslint --fix` pass rewrites every interface into a type alias. A lookup
+         * that reads interfaces alone therefore resolves nothing on a codebase that
+         * has run the config, and a nested `any` in a document schema goes
+         * unreported.
+         */
+        function declaredMembersOf(typeName) {
+            for (const statement of context.sourceCode.ast.body) {
+                if (statement.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
+                    statement.id.name === typeName) {
+                    return statement.body.body;
+                }
+                if (statement.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                    statement.id.name === typeName) {
+                    return aliasedTypeLiteral(statement.typeAnnotation)?.members;
+                }
+            }
+            return undefined;
+        }
         function hasTypeAnnotation(node) {
             if (nodeCache.has(node)) {
                 return nodeCache.get(node);

package/lib/rules/enforce-mui-rounded-icons.d.ts

@@ -1 +1,2 @@
-export declare const enforceMuiRoundedIcons: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceRoundedVariant", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceMuiRoundedIcons: TSESLint.RuleModule<"enforceRoundedVariant", [], TSESLint.RuleListener>;

package/lib/rules/enforce-mui-rounded-icons.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMuiRoundedIcons = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+const renameFixes_1 = require("../utils/renameFixes");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const MUI_ICONS_BARREL = '@mui/icons-material';
 const MUI_ICONS_DEEP_PREFIX = `${MUI_ICONS_BARREL}/`;
 /**
@@ -66,6 +68,52 @@ const toRoundedIconName = (iconName) => {
     }
     return `${baseIconName}Rounded`;
 };
+/** The icon a deep module path names, e.g. `AddReactionOutlined`. */
+const deepImportIconName = (source) => source.split('/').pop();
+/** The binding a deep import introduces for the icon its path names. */
+const deepImportBinding = (node) => {
+    const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+    return defaultSpecifier ? defaultSpecifier.local : null;
+};
+/**
+ * The Rounded names this declaration would give to *bindings* if its fix ran.
+ *
+ * Only a binding whose name is the icon name being replaced is ever renamed, so
+ * an aliased specifier — whose fix touches the imported name alone — claims no
+ * name here. Collected across the file so two variants of one icon
+ * (`PersonOutlined` and `PersonSharp`, both retargeting to `PersonRounded`) can
+ * be spotted before either fix runs: renaming both bindings would declare the
+ * same name twice.
+ */
+const claimedRoundedNames = (node) => {
+    if (node.source.type !== utils_1.AST_NODE_TYPES.Literal ||
+        typeof node.source.value !== 'string') {
+        return [];
+    }
+    const source = node.source.value;
+    if (source.startsWith(MUI_ICONS_DEEP_PREFIX)) {
+        const iconName = deepImportIconName(source);
+        const roundedVariant = iconName ? toRoundedIconName(iconName) : null;
+        const local = deepImportBinding(node);
+        return roundedVariant && local?.name === iconName ? [roundedVariant] : [];
+    }
+    if (source !== MUI_ICONS_BARREL || node.importKind === 'type') {
+        return [];
+    }
+    const claimed = [];
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+            specifier.importKind === 'type' ||
+            specifier.local.name !== specifier.imported.name) {
+            continue;
+        }
+        const roundedVariant = toRoundedIconName(specifier.imported.name);
+        if (roundedVariant) {
+            claimed.push(roundedVariant);
+        }
+    }
+    return claimed;
+};
 exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     name: 'enforce-mui-rounded-icons',
     meta: {
@@ -82,19 +130,124 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        /**
+         * Rounded names that more than one binding in the file would take. Renaming
+         * every claimant would declare the same name twice, so no claimant of a
+         * contested name is renamed.
+         */
+        const contestedNames = new Set();
+        /**
+         * Rewrites one reference to a renamed binding, or answers null when that
+         * site cannot be rewritten without changing more than the name.
+         */
+        const referenceRenameFixes = (fixer, referenceId, newName) => {
+            const parent = referenceId.parent;
+            // `export { PersonOutlined }` binds the module's public export name to
+            // this token, so renaming it would change an API contract whose importers
+            // a single-file fix cannot reach.
+            if (parent?.type === utils_1.AST_NODE_TYPES.ExportSpecifier) {
+                return null;
+            }
+            // A shorthand property is one token serving as both key and value:
+            // rewriting it renames the key too, and expanding it to `key: value`
+            // reshapes source the rule has no business reshaping.
+            if (parent?.type === utils_1.AST_NODE_TYPES.Property && parent.shorthand) {
+                return null;
+            }
+            // `<Icon.Sub />` and `<svg:icon />` name the binding through a compound
+            // tag whose closing half is not a scope reference, so the two tags cannot
+            // be kept in sync from here.
+            if (parent?.type === utils_1.AST_NODE_TYPES.JSXMemberExpression ||
+                parent?.type === utils_1.AST_NODE_TYPES.JSXNamespacedName) {
+                return null;
+            }
+            const fix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, referenceId, newName);
+            if (!fix) {
+                return null;
+            }
+            if (parent?.type !== utils_1.AST_NODE_TYPES.JSXOpeningElement ||
+                parent.name !== referenceId) {
+                return [fix];
+            }
+            // The scope manager records the opening tag's name as a reference but not
+            // the closing tag's, so renaming the opening half alone would leave
+            // `<PersonRounded></PersonOutlined>` — code that no longer parses.
+            const element = parent.parent;
+            const closingName = element?.type === utils_1.AST_NODE_TYPES.JSXElement
+                ? element.closingElement?.name
+                : undefined;
+            if (!closingName) {
+                return [fix];
+            }
+            // JSX requires the closing name to spell the opening one, so its first
+            // token is the same name this rename replaces.
+            const closingFix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, closingName, newName);
+            return closingFix ? [fix, closingFix] : null;
+        };
+        /**
+         * Builds the rewrites that rename the binding an icon import introduces:
+         * the declaring token(s) plus every in-file reference to it.
+         *
+         * Answers null when the rename cannot be applied everywhere — the caller
+         * then keeps the retarget that leaves the binding alone, or reports without
+         * a fix where no such retarget exists.
+         */
+        const bindingRenameFixes = (fixer, declaration, localIdentifier, declarationTokens, newName) => {
+            if (contestedNames.has(newName)) {
+                return null;
+            }
+            // Resolved by declaration identity rather than by name: a file may bind
+            // the same name in several scopes, and only this declaration's symbol
+            // carries the references the fix has to rewrite.
+            const variable = ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, declaration).find((candidate) => candidate.defs.some((def) => def.name === localIdentifier));
+            if (!variable || (0, renameFixes_1.renameWouldCollide)(variable, newName)) {
+                return null;
+            }
+            const fixes = [];
+            for (const token of declarationTokens) {
+                const fix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, token, newName);
+                if (!fix) {
+                    return null;
+                }
+                fixes.push(fix);
+            }
+            for (const reference of variable.references) {
+                if (reference.identifier === localIdentifier) {
+                    continue;
+                }
+                const referenceFixes = referenceRenameFixes(fixer, reference.identifier, newName);
+                if (!referenceFixes) {
+                    return null;
+                }
+                fixes.push(...referenceFixes);
+            }
+            return fixes;
+        };
         /** `import LogoutIcon from '@mui/icons-material/Logout'` — the icon is named by the module path. */
         const checkDeepImport = (node, iconPath) => {
-            const iconName = iconPath.split('/').pop();
+            const iconName = deepImportIconName(iconPath);
             const roundedVariant = iconName ? toRoundedIconName(iconName) : null;
             if (!roundedVariant) {
                 return;
             }
+            const local = deepImportBinding(node);
+            // A hand-chosen alias (`import BellIcon from '.../NotificationsActive'`)
+            // names the icon's role, not its variant, so only a binding that repeats
+            // the icon name is renamed with the path.
+            const renamedBinding = local?.name === iconName ? local : null;
             context.report({
                 node,
                 messageId: 'enforceRoundedVariant',
-                // The local binding is untouched: only the module the icon comes from
-                // changes.
-                fix: (fixer) => fixer.replaceText(node.source, `'${MUI_ICONS_DEEP_PREFIX}${roundedVariant}'`),
+                fix: (fixer) => {
+                    const pathFix = fixer.replaceText(node.source, `'${MUI_ICONS_DEEP_PREFIX}${roundedVariant}'`);
+                    const renameFixes = renamedBinding
+                        ? bindingRenameFixes(fixer, node, renamedBinding, [renamedBinding], roundedVariant)
+                        : null;
+                    // Path and binding move together: one fixer emits both, so a binding
+                    // rename can never land without the retarget that motivates it.
+                    return renameFixes ? [pathFix, ...renameFixes] : pathFix;
+                },
             });
         };
         /** `import { Logout } from '@mui/icons-material'` — the icon is named by each specifier. */
@@ -116,22 +269,50 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
                     continue;
                 }
                 // An alias keeps the local binding independent of the imported name, so
-                // swapping the imported name is a self-contained edit. Without one, a
-                // fix would rename the binding and would have to rewrite every
-                // reference to it (shorthand properties, export specifiers, JSX) — so
-                // that form is reported without a fix rather than risking a corrupting
-                // edit.
-                const isAliased = specifier.local.name !== importedName;
+                // swapping the imported name is a self-contained edit that leaves the
+                // binding — and every reference to it — alone.
+                if (specifier.local.name !== importedName) {
+                    context.report({
+                        node: specifier,
+                        messageId: 'enforceRoundedVariant',
+                        fix: (fixer) => fixer.replaceText(specifier.imported, roundedVariant),
+                    });
+                    continue;
+                }
+                // Without an alias the imported name IS the local binding, so changing
+                // it renames the binding: the fix must own every reference to it or not
+                // exist at all. `import { Logout }` spells the imported name and the
+                // local one with a single token, which is rewritten once; the redundant
+                // `import { Logout as Logout }` spells them separately, so both move.
+                const declarationTokens = specifier.imported.range[0] === specifier.local.range[0]
+                    ? [specifier.local]
+                    : [specifier.imported, specifier.local];
                 context.report({
                     node: specifier,
                     messageId: 'enforceRoundedVariant',
-                    fix: isAliased
-                        ? (fixer) => fixer.replaceText(specifier.imported, roundedVariant)
-                        : null,
+                    fix: (fixer) => bindingRenameFixes(fixer, node, specifier.local, declarationTokens, roundedVariant),
                 });
             }
         };
         return {
+            // Every import is a top-level statement, so the names the file's fixes
+            // would introduce are all knowable before the first report.
+            Program(node) {
+                const claimCounts = new Map();
+                for (const statement of node.body) {
+                    if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                        continue;
+                    }
+                    for (const claimed of claimedRoundedNames(statement)) {
+                        claimCounts.set(claimed, (claimCounts.get(claimed) ?? 0) + 1);
+                    }
+                }
+                for (const [name, count] of claimCounts) {
+                    if (count > 1) {
+                        contestedNames.add(name);
+                    }
+                }
+            },
             ImportDeclaration(node) {
                 if (node.source.type !== utils_1.AST_NODE_TYPES.Literal ||
                     typeof node.source.value !== 'string') {

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

@@ -973,6 +973,78 @@ function isDefinitelyNonBooleanExpression(node) {
             return false;
     }
 }
+// Operators whose result is always a boolean, regardless of operand types.
+const BOOLEAN_BINARY_OPERATORS = new Set([
+    '==',
+    '!=',
+    '===',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    'in',
+    'instanceof',
+]);
+/**
+ * Detects an expression that is definitively a boolean — a boolean literal, a
+ * negation, a comparison, or a branch/`Boolean()` call built from those. Opaque
+ * expressions (calls, identifiers, member accesses) yield no verdict here: they
+ * are the shapes a validator's body takes once its return annotation is gone,
+ * and assuming boolean for them is what produced the false positive in #1692.
+ */
+function isDefinitelyBooleanExpression(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            return typeof node.value === 'boolean';
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return node.operator === '!' || node.operator === 'delete';
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            return BOOLEAN_BINARY_OPERATORS.has(node.operator);
+        case utils_1.AST_NODE_TYPES.LogicalExpression:
+            return (isDefinitelyBooleanExpression(node.left) &&
+                isDefinitelyBooleanExpression(node.right));
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return (isDefinitelyBooleanExpression(node.consequent) &&
+                isDefinitelyBooleanExpression(node.alternate));
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            // `Boolean(x)` is the one call whose result is boolean by construction.
+            return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'Boolean');
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            // `x as boolean` asserts booleanness; `x as const` and other assertions
+            // say nothing, so the asserted expression decides.
+            return (isBooleanOnlyType(node.typeAnnotation) ||
+                isDefinitelyBooleanExpression(node.expression));
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isDefinitelyBooleanExpression(node.expression);
+        default:
+            return false;
+    }
+}
+function classifyExpression(node) {
+    // A definitively non-boolean shape wins over a boolean one: a validator's
+    // `return 'Must not be blank'` proves the function is not a predicate even
+    // though its success path returns `true`.
+    if (isDefinitelyNonBooleanExpression(node))
+        return 'nonBoolean';
+    if (isDefinitelyBooleanExpression(node))
+        return 'boolean';
+    return 'indeterminate';
+}
+/**
+ * Combines the verdicts of a body's returns under the same precedence:
+ * non-boolean beats boolean, and boolean beats no verdict at all. An empty list
+ * (a body with no returns) is `indeterminate`.
+ */
+function combineReturnKinds(kinds) {
+    if (kinds.includes('nonBoolean'))
+        return 'nonBoolean';
+    if (kinds.includes('boolean'))
+        return 'boolean';
+    return 'indeterminate';
+}
 /**
  * Yields the immediate AST-node children of `node`, skipping the `parent`
  * back-reference so traversal only walks downward.
@@ -995,10 +1067,12 @@ function childNodesOf(node) {
     return children;
 }
 /**
- * Whether any `return` statement belonging to `fn`'s own body (not a nested
- * function's) yields a definitively non-boolean value.
+ * Classifies the `return` statements belonging to `fn`'s own body (not a nested
+ * function's). A bare `return;` carries no verdict, so it neither exempts the
+ * function nor keeps a sibling boolean return from deciding.
  */
-function blockReturnsNonBoolean(block) {
+function classifyBlockReturns(block) {
+    const kinds = [];
     const stack = [block];
     while (stack.length > 0) {
         const current = stack.pop();
@@ -1009,41 +1083,54 @@ function blockReturnsNonBoolean(block) {
                 current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
             continue;
         }
-        if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-            current.argument &&
-            isDefinitelyNonBooleanExpression(current.argument)) {
-            return true;
+        if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement && current.argument) {
+            kinds.push(classifyExpression(current.argument));
         }
         for (const child of childNodesOf(current)) {
             stack.push(child);
         }
     }
-    return false;
+    return combineReturnKinds(kinds);
 }
 /**
- * Whether a function backing an `is`/`has`-prefixed name actually returns a
- * non-boolean value — e.g. a validator predicate returning `string | true`. An
+ * The booleanness of a function backing an `is`/`has`-prefixed name. An
  * explicit return-type annotation is authoritative; otherwise the body's own
- * `return` statements (or the concise-arrow expression) are inspected.
+ * `return` statements (or the concise-arrow expression) decide.
  */
-function functionReturnsNonBoolean(fn) {
+function classifyFunctionReturn(fn) {
     if (fn.returnType) {
-        return !isBooleanOnlyType(fn.returnType.typeAnnotation);
+        return isBooleanOnlyType(fn.returnType.typeAnnotation)
+            ? 'boolean'
+            : 'nonBoolean';
     }
     if (fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-        return isDefinitelyNonBooleanExpression(fn.body);
+        return classifyExpression(fn.body);
     }
-    return blockReturnsNonBoolean(fn.body);
+    return classifyBlockReturns(fn.body);
+}
+/**
+ * Whether a function backing an `is`/`has`-prefixed name must be exempt from
+ * boolean negative-naming. Only a function proven to return a boolean is
+ * flagged: a validator predicate returning `string | true` is exempt, and so is
+ * one whose returns are syntactically opaque (`=> validate(value)`). That
+ * matters because `no-explicit-return-type` deletes the very annotation that
+ * spells the validator's non-boolean return, leaving nothing but the name to go
+ * on — and guessing "boolean" from the name alone reports a rename that inverts
+ * the predicate's meaning (#1692). Preferring a false negative here is the
+ * repository's stated trade-off.
+ */
+function isExemptFromBooleanNaming(fn) {
+    return classifyFunctionReturn(fn) !== 'boolean';
 }
 /**
- * When a declarator/property value is a function, whether that function is a
- * non-boolean predicate that must be exempt from boolean negative-naming.
+ * When a declarator/property value is a function, whether that function is
+ * exempt from boolean negative-naming.
  */
-function isNonBooleanFunctionValue(node) {
+function isExemptFunctionValue(node) {
     return (!!node &&
         (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
             node.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
-        functionReturnsNonBoolean(node));
+        isExemptFromBooleanNaming(node));
 }
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
@@ -1280,7 +1367,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // with `is`/`has` but is not a boolean, so its domain-correct negation
             // ("isNotBlank") must not be flagged. The name heuristic alone cannot
             // tell them apart; the initializer's return shape can.
-            if (isNonBooleanFunctionValue(node.init))
+            if (isExemptFunctionValue(node.init))
                 return;
             const variableName = node.id.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(variableName);
@@ -1323,8 +1410,9 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             if (!isBooleanLike(node.id || node))
                 return;
             // Skip validator predicates that return a non-boolean value (e.g.
-            // `string | true`), whose negation is the domain-correct term.
-            if (functionReturnsNonBoolean(node))
+            // `string | true`), whose negation is the domain-correct term, and any
+            // function whose returns give no syntactic verdict.
+            if (isExemptFromBooleanNaming(node))
                 return;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(functionName);
             if (isNegative) {
@@ -1348,7 +1436,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             if (!isBooleanLike(node.key))
                 return;
             // Skip validator predicates returning a non-boolean value.
-            if (isNonBooleanFunctionValue(node.value))
+            if (isExemptFunctionValue(node.value))
                 return;
             const methodName = node.key.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(methodName);
@@ -1373,7 +1461,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             if (!isBooleanLike(node.key))
                 return;
             // Skip validator predicates returning a non-boolean value.
-            if (isNonBooleanFunctionValue(node.value))
+            if (isExemptFunctionValue(node.value))
                 return;
             const propertyName = node.key.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);

package/lib/rules/generic-starts-with-t.js

@@ -2,10 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genericStartsWithT = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * A module augmentation targets either an external module
+ * (`declare module 'pkg'`, whose id is a string literal) or the global scope
+ * (`declare global`). TypeScript requires every declaration of a merged entity
+ * to spell its type parameters identically (TS2428, "All declarations of 'X'
+ * must have identical type parameters"), so the name inside an augmentation is
+ * fixed by the upstream declaration rather than chosen by the author. Renaming
+ * it to satisfy the convention breaks the merge.
+ *
+ * A plain `namespace X` — including the ambient `declare namespace X` and
+ * `declare module Foo`, both of which carry an identifier id — augments nothing
+ * upstream, so its type parameters stay author-owned and reportable.
+ */
+function isModuleAugmentation(node) {
+    if (node.id.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.id.value === 'string') {
+        return true;
+    }
+    // `declare global` carries a dedicated flag, which also covers the bare
+    // `global { ... }` form nested inside an ambient module (that form has no
+    // `declare` of its own).
+    if (node.global === true) {
+        return true;
+    }
+    // Parser versions that predate the `global` flag spell the same block as an
+    // ambient module whose id is the `global` keyword. Requiring `declare` keeps
+    // an ordinary `namespace global { ... }` reportable.
+    return (node.declare === true &&
+        node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.id.name === 'global');
+}
+/**
+ * The declaration need not be a direct child of the augmentation block; it can
+ * sit inside a nested namespace, an interface member signature or any other
+ * container within it, so the whole ancestor chain is inspected.
+ */
+function isInsideModuleAugmentation(node) {
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+        if (ancestor.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+            isModuleAugmentation(ancestor)) {
+            return true;
+        }
+    }
+    return false;
+}
 exports.genericStartsWithT = (0, createRule_1.createRule)({
     create(context) {
         return {
             TSTypeParameterDeclaration(node) {
+                if (isInsideModuleAugmentation(node)) {
+                    return;
+                }
                 for (const param of node.params) {
                     if (typeof param.name.name === 'string' &&
                         param.name.name[0] !== 'T') {