@typescript-eslint/eslint-plugin 8.58.3-alpha.4 → 8.58.3-alpha.5

package/dist/rules/no-deprecated.js

@@ -330,7 +330,8 @@ exports.default = (0, util_1.createRule)({
                 const objectType = services.getTypeAtLocation(node.object);
                 const propertyName = propertyType.isStringLiteral()
                     ? propertyType.value
-                    : String(propertyType.value);
+                    : // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                        String(propertyType.value);
                 const property = objectType.getProperty(propertyName);
                 const reason = getJsDocDeprecation(property);
                 if (reason == null) {

package/dist/rules/no-unnecessary-type-assertion.js

@@ -163,35 +163,350 @@ exports.default = (0, util_1.createRule)({
                 maybeDeclarationNode.kind === 'const') ||
                 (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition && parent.readonly));
         }
-        function isTypeUnchanged(uncast, cast) {
+        function isTypeUnchanged(node, expression, uncast, cast) {
             if (uncast === cast) {
                 return true;
             }
+            if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType &&
+                containsTypeVariable(cast)) {
+                return false;
+            }
             if ((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.Undefined) &&
                 (0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
                 tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
-                const uncastParts = tsutils
-                    .unionConstituents(uncast)
-                    .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
-                const castParts = tsutils
-                    .unionConstituents(cast)
-                    .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
-                if (uncastParts.length !== castParts.length) {
-                    return false;
+                return areUnionPartsEquivalentIgnoringUndefined(uncast, cast);
+            }
+            if (((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.NonPrimitive) &&
+                !(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.NonPrimitive)) ||
+                (hasIndexSignature(uncast) && !hasIndexSignature(cast)) ||
+                containsAny(uncast) ||
+                containsAny(cast) ||
+                (containsTypeVariable(cast) && !containsTypeVariable(uncast))) {
+                return false;
+            }
+            if (isConceptuallyLiteral(expression) &&
+                (expression.type !== utils_1.AST_NODE_TYPES.ObjectExpression ||
+                    expression.properties.length === 0 ||
+                    cast
+                        .getProperties()
+                        .some(p => isTypeLiteral(checker.getTypeOfSymbol(p))))) {
+                return false;
+            }
+            if (cast.isIntersection() && !uncast.isIntersection()) {
+                const castParts = cast.types;
+                const otherPart = castParts.find(part => part !== uncast);
+                if (tsutils.isTypeParameter(uncast) &&
+                    castParts.length === 2 &&
+                    castParts.some(part => part === uncast) &&
+                    otherPart != null &&
+                    isEmptyObjectType(otherPart) &&
+                    !containsTypeVariable(otherPart)) {
+                    const constraint = checker.getBaseConstraintOfType(uncast);
+                    if (constraint && !(0, util_1.isNullableType)(constraint)) {
+                        return true;
+                    }
                 }
-                const uncastPartsSet = new Set(uncastParts);
-                return castParts.every(part => uncastPartsSet.has(part));
+                return false;
             }
-            return false;
+            if (!hasSameProperties(uncast, cast) ||
+                !haveSameTypeArguments(uncast, cast)) {
+                return false;
+            }
+            return areMutuallyAssignable(uncast, cast);
         }
         function isTypeLiteral(type) {
             return type.isLiteral() || tsutils.isBooleanLiteralType(type);
         }
+        function hasIndexSignature(type) {
+            return checker.getIndexInfosOfType(type).length > 0;
+        }
+        function typeContains(type, predicate, seen = new Set()) {
+            if (seen.has(type)) {
+                return false;
+            }
+            seen.add(type);
+            if (predicate(type)) {
+                return true;
+            }
+            if (type.isUnionOrIntersection()) {
+                return type.types.some(t => typeContains(t, predicate, seen));
+            }
+            const nestedTypes = [
+                ...checker.getTypeArguments(type),
+                ...type
+                    .getCallSignatures()
+                    .flatMap(sig => [
+                    sig.getReturnType(),
+                    ...sig.getParameters().map(p => checker.getTypeOfSymbol(p)),
+                ]),
+            ];
+            return nestedTypes.some(t => typeContains(t, predicate, seen));
+        }
+        function containsAny(type) {
+            return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Any));
+        }
+        function containsTypeVariable(type) {
+            return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.TypeVariable | ts.TypeFlags.Index));
+        }
+        function hasTypeParams(sig) {
+            return (sig.getTypeParameters()?.length ?? 0) > 0;
+        }
+        function genericsMismatch(uncast, contextual) {
+            return contextual.getProperties().some(prop => {
+                const contextualSigs = checker.getSignaturesOfType(checker.getTypeOfSymbol(prop), ts.SignatureKind.Call);
+                if (!contextualSigs.some(hasTypeParams)) {
+                    return false;
+                }
+                const uncastProp = uncast.getProperty(prop.getEscapedName());
+                if (!uncastProp) {
+                    return true;
+                }
+                return !checker
+                    .getSignaturesOfType(checker.getTypeOfSymbol(uncastProp), ts.SignatureKind.Call)
+                    .some(hasTypeParams);
+            });
+        }
+        function hasSameProperties(uncast, cast) {
+            const uncastProps = uncast.getProperties();
+            const castProps = cast.getProperties();
+            if (uncastProps.length !== castProps.length) {
+                return false;
+            }
+            const castPropNames = new Set(castProps.map(p => p.getEscapedName()));
+            return uncastProps.every(prop => {
+                const name = prop.getEscapedName();
+                return (castPropNames.has(name) &&
+                    tsutils.isPropertyReadonlyInType(uncast, name, checker) ===
+                        tsutils.isPropertyReadonlyInType(cast, name, checker));
+            });
+        }
+        function haveSameTypeArguments(uncast, cast) {
+            const uncastArgs = checker.getTypeArguments(uncast);
+            const castArgs = checker.getTypeArguments(cast);
+            return (uncastArgs.length === castArgs.length &&
+                uncastArgs.every((arg, i) => arg === castArgs[i]));
+        }
+        function areMutuallyAssignable(a, b) {
+            return (checker.isTypeAssignableTo(a, b) && checker.isTypeAssignableTo(b, a));
+        }
+        function areUnionPartsEquivalentIgnoringUndefined(uncast, cast) {
+            const filterUndefined = (part) => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined);
+            const uncastParts = tsutils
+                .unionConstituents(uncast)
+                .filter(filterUndefined);
+            const castParts = tsutils.unionConstituents(cast).filter(filterUndefined);
+            if (uncastParts.length !== castParts.length) {
+                return false;
+            }
+            const uncastPartsSet = new Set(uncastParts);
+            return castParts.every(part => uncastPartsSet.has(part));
+        }
+        function getOriginalExpression(node) {
+            let current = node.expression;
+            while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                current = current.expression;
+            }
+            return current;
+        }
+        function isDoubleAssertionUnnecessary(node, contextualType) {
+            const innerExpression = node.expression;
+            if (innerExpression.type !== utils_1.AST_NODE_TYPES.TSAsExpression &&
+                innerExpression.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                return false;
+            }
+            const originalExpr = getOriginalExpression(node);
+            const originalType = services.getTypeAtLocation(originalExpr);
+            const castType = services.getTypeAtLocation(node);
+            if (isTypeUnchanged(node, innerExpression, originalType, castType) &&
+                !(0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any)) {
+                return 'unnecessaryAssertion';
+            }
+            if (contextualType) {
+                const intermediateType = services.getTypeAtLocation(innerExpression);
+                if (((0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Any) ||
+                    (0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Unknown)) &&
+                    checker.isTypeAssignableTo(originalType, contextualType)) {
+                    return 'contextuallyUnnecessary';
+                }
+            }
+            return false;
+        }
+        const CONCEPTUALLY_LITERAL_TYPES = new Set([
+            utils_1.AST_NODE_TYPES.Literal,
+            utils_1.AST_NODE_TYPES.ArrayExpression,
+            utils_1.AST_NODE_TYPES.ObjectExpression,
+            utils_1.AST_NODE_TYPES.TemplateLiteral,
+            utils_1.AST_NODE_TYPES.ClassExpression,
+            utils_1.AST_NODE_TYPES.FunctionExpression,
+            utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+            utils_1.AST_NODE_TYPES.JSXElement,
+            utils_1.AST_NODE_TYPES.JSXFragment,
+        ]);
+        function isConceptuallyLiteral(node) {
+            return CONCEPTUALLY_LITERAL_TYPES.has(node.type);
+        }
         function isIIFE(expression) {
             return (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
                 (expression.callee.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                     expression.callee.type === utils_1.AST_NODE_TYPES.FunctionExpression));
         }
+        function isEmptyObjectType(type) {
+            return ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.NonPrimitive) ||
+                (type.getProperties().length === 0 &&
+                    !type.getCallSignatures().length &&
+                    !type.getConstructSignatures().length &&
+                    !type.getStringIndexType() &&
+                    !type.getNumberIndexType()));
+        }
+        function hasGenericCallSignature(type) {
+            return type.getCallSignatures().some(hasTypeParams);
+        }
+        function isArgumentToOverloadedFunction(node) {
+            const { parent } = node;
+            if ((parent.type !== utils_1.AST_NODE_TYPES.CallExpression &&
+                parent.type !== utils_1.AST_NODE_TYPES.NewExpression) ||
+                !parent.arguments.includes(node)) {
+                return false;
+            }
+            const calleeType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(parent.callee));
+            const signatures = calleeType.getCallSignatures();
+            if (signatures.length <= 1) {
+                return false;
+            }
+            const argIndex = parent.arguments.indexOf(node);
+            const paramTypes = signatures.map(sig => {
+                const params = sig.getParameters();
+                if (argIndex >= params.length) {
+                    return undefined;
+                }
+                const param = params[argIndex];
+                let paramType = checker.getTypeOfSymbol(param);
+                if (param.valueDeclaration &&
+                    ts.isParameter(param.valueDeclaration) &&
+                    param.valueDeclaration.dotDotDotToken) {
+                    const typeArgs = checker.getTypeArguments(paramType);
+                    if (typeArgs.length > 0) {
+                        paramType = typeArgs[0];
+                    }
+                }
+                return paramType;
+            });
+            if (paramTypes.some(type => type == null)) {
+                return true;
+            }
+            const definedParamTypes = paramTypes;
+            const firstParamType = definedParamTypes[0];
+            if (definedParamTypes.every(type => type === firstParamType)) {
+                return false;
+            }
+            const uncastType = services.getTypeAtLocation(node.expression);
+            return !definedParamTypes.every(type => checker.isTypeAssignableTo(uncastType, type));
+        }
+        function isInDestructuringDeclaration(node) {
+            const { parent } = node;
+            return (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.init === node &&
+                (parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern));
+        }
+        function isPropertyInProblematicContext(node) {
+            const { parent } = node;
+            if (parent.type !== utils_1.AST_NODE_TYPES.Property || parent.value !== node) {
+                return false;
+            }
+            const objectExpr = parent.parent;
+            if (objectExpr.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return false;
+            }
+            const objectTsNode = services.esTreeNodeToTSNodeMap.get(objectExpr);
+            if (checker.getContextualType(objectTsNode)?.isUnion()) {
+                const nodeTsNode = services.esTreeNodeToTSNodeMap.get(node);
+                const propContextualType = checker.getContextualType(nodeTsNode);
+                if (propContextualType == null) {
+                    return true;
+                }
+                const nonNullableContextualType = checker.getNonNullableType(propContextualType);
+                if (nonNullableContextualType.isUnion()) {
+                    return true;
+                }
+                const uncastType = services.getTypeAtLocation(node.expression);
+                return !checker.isTypeAssignableTo(uncastType, nonNullableContextualType);
+            }
+            const objectParent = objectExpr.parent;
+            return (objectParent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+                (objectParent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    objectParent.parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression));
+        }
+        function isAssignmentInNonStatementContext(node) {
+            const { parent } = node;
+            if (parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                parent.right !== node) {
+                return false;
+            }
+            const assignmentParent = parent.parent;
+            return assignmentParent.type !== utils_1.AST_NODE_TYPES.ExpressionStatement;
+        }
+        function isInGenericContext(node) {
+            let seenFunction = false;
+            for (let current = node.parent; current; current = current.parent) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                    return false;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    if (current.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        return false;
+                    }
+                    if (seenFunction) {
+                        return false;
+                    }
+                    seenFunction = true;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                    if (current.typeArguments != null) {
+                        continue;
+                    }
+                    if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        current.arguments.includes(node)) {
+                        continue;
+                    }
+                    const calleeType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(current.callee));
+                    if (hasGenericCallSignature(calleeType)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        const SKIP_PARENT_TYPES = new Set([
+            utils_1.AST_NODE_TYPES.TSAsExpression,
+            utils_1.AST_NODE_TYPES.TSTypeAssertion,
+            utils_1.AST_NODE_TYPES.SpreadElement,
+            utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+        ]);
+        function shouldSkipContextualTypeFallback(node, castIsAny) {
+            if (castIsAny) {
+                return (node.parent.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                    isInGenericContext(node));
+            }
+            if (SKIP_PARENT_TYPES.has(node.parent.type) ||
+                node.expression.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                isInDestructuringDeclaration(node) ||
+                isPropertyInProblematicContext(node) ||
+                isAssignmentInNonStatementContext(node) ||
+                isArgumentToOverloadedFunction(node)) {
+                return true;
+            }
+            if (isInGenericContext(node)) {
+                const originalExpr = getOriginalExpression(node);
+                return (!isConceptuallyLiteral(originalExpr) &&
+                    node.parent.type !== utils_1.AST_NODE_TYPES.Property);
+            }
+            return false;
+        }
         function getUncastType(node) {
             // Special handling for IIFE: extract the function's return type
             if (isIIFE(node.expression)) {
@@ -211,6 +526,44 @@ exports.default = (0, util_1.createRule)({
             }
             return services.getTypeAtLocation(node.expression);
         }
+        function createAssertionFixer(node) {
+            return fixer => {
+                if (node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                    const openingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                        token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation'));
+                    const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                        token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
+                    return fixer.removeRange([
+                        openingAngleBracket.range[0],
+                        closingAngleBracket.range[1],
+                    ]);
+                }
+                const asToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'as'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
+                const tokenBeforeAs = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(asToken, {
+                    includeComments: true,
+                }), util_1.NullThrowsReasons.MissingToken('comment', 'as'));
+                return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
+            };
+        }
+        function reportDoubleAssertionIfUnnecessary(node, contextualType) {
+            const doubleAssertionResult = isDoubleAssertionUnnecessary(node, contextualType);
+            if (doubleAssertionResult) {
+                context.report({
+                    node,
+                    messageId: doubleAssertionResult,
+                    fix(fixer) {
+                        const originalExpr = getOriginalExpression(node);
+                        let text = context.sourceCode.getText(originalExpr);
+                        if (originalExpr.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                            node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                            node.parent.body === node) {
+                            text = `(${text})`;
+                        }
+                        return fixer.replaceText(node, text);
+                    },
+                });
+            }
+        }
         return {
             'TSAsExpression, TSTypeAssertion'(node) {
                 if (options.typesToIgnore?.includes(context.sourceCode.getText(node.typeAnnotation))) {
@@ -225,7 +578,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const uncastType = getUncastType(node);
-                const typeIsUnchanged = isTypeUnchanged(uncastType, castType);
+                const typeIsUnchanged = isTypeUnchanged(node, node.expression, uncastType, castType);
                 const wouldSameTypeBeInferred = castTypeIsLiteral
                     ? isImplicitlyNarrowedLiteralDeclaration(node)
                     : !typeAnnotationIsConstAssertion;
@@ -233,32 +586,46 @@ exports.default = (0, util_1.createRule)({
                     context.report({
                         node,
                         messageId: 'unnecessaryAssertion',
-                        fix(fixer) {
-                            if (node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                                const openingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
-                                    token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation'));
-                                const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
-                                    token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
-                                // < ( number ) > ( 3 + 5 )
-                                // ^---remove---^
-                                return fixer.removeRange([
-                                    openingAngleBracket.range[0],
-                                    closingAngleBracket.range[1],
-                                ]);
-                            }
-                            // `as` is always present in TSAsExpression
-                            const asToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier &&
-                                token.value === 'as'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
-                            const tokenBeforeAs = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(asToken, {
-                                includeComments: true,
-                            }), util_1.NullThrowsReasons.MissingToken('comment', 'as'));
-                            // ( 3 + 5 )  as  number
-                            //          ^--remove--^
-                            return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
-                        },
+                        fix: createAssertionFixer(node),
                     });
+                    return;
+                }
+                const originalNode = services.esTreeNodeToTSNodeMap.get(node);
+                const castIsAny = (0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any) &&
+                    !SKIP_PARENT_TYPES.has(node.parent.type);
+                const contextualType = shouldSkipContextualTypeFallback(node, castIsAny)
+                    ? undefined
+                    : checker.getContextualType(originalNode);
+                if (contextualType) {
+                    const contextualTypeIsAny = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Any);
+                    const isCallArgument = (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.NewExpression) &&
+                        node.parent.arguments.includes(node);
+                    const anyInvolvedInContextualCheck = contextualTypeIsAny
+                        ? isCallArgument && !containsAny(castType)
+                        : !containsAny(contextualType);
+                    const isNullishLiteralToUnion = castType.isUnion() &&
+                        ((node.expression.type === utils_1.AST_NODE_TYPES.Literal &&
+                            node.expression.value == null) ||
+                            (node.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                node.expression.name === 'undefined'));
+                    const isContextuallyUnnecessary = !typeAnnotationIsConstAssertion &&
+                        !containsAny(uncastType) &&
+                        anyInvolvedInContextualCheck &&
+                        (castIsAny || !genericsMismatch(uncastType, contextualType)) &&
+                        (contextualTypeIsAny ||
+                            checker.isTypeAssignableTo(uncastType, contextualType)) &&
+                        !isNullishLiteralToUnion;
+                    if (isContextuallyUnnecessary) {
+                        context.report({
+                            node,
+                            messageId: 'contextuallyUnnecessary',
+                            fix: createAssertionFixer(node),
+                        });
+                        return;
+                    }
                 }
-                // TODO - add contextually unnecessary check for this
+                reportDoubleAssertionIfUnnecessary(node, contextualType);
             },
             TSNonNullExpression(node) {
                 const removeExclamationFix = fixer => {

package/dist/rules/unified-signatures.js

@@ -234,13 +234,13 @@ exports.default = (0, util_1.createRule)({
         /** Given type parameters, returns a function to test whether a type is one of those parameters. */
         function getIsTypeParameter(typeParameters) {
             if (typeParameters == null) {
-                return (() => false);
+                return () => false;
             }
             const set = new Set();
             for (const t of typeParameters.params) {
                 set.add(t.name.name);
             }
-            return (typeName => set.has(typeName));
+            return typeName => set.has(typeName);
         }
         /** True if any of the outer type parameters are used in a signature. */
         function signatureUsesTypeParameter(sig, isTypeParameter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.58.3-alpha.4",
+  "version": "8.58.3-alpha.5",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -52,10 +52,10 @@
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0",
-    "@typescript-eslint/scope-manager": "8.58.3-alpha.4",
-    "@typescript-eslint/type-utils": "8.58.3-alpha.4",
-    "@typescript-eslint/utils": "8.58.3-alpha.4",
-    "@typescript-eslint/visitor-keys": "8.58.3-alpha.4"
+    "@typescript-eslint/scope-manager": "8.58.3-alpha.5",
+    "@typescript-eslint/type-utils": "8.58.3-alpha.5",
+    "@typescript-eslint/utils": "8.58.3-alpha.5",
+    "@typescript-eslint/visitor-keys": "8.58.3-alpha.5"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
@@ -78,13 +78,13 @@
     "typescript": ">=4.8.4 <6.1.0",
     "unist-util-visit": "^5.0.0",
     "vitest": "^4.0.18",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.58.3-alpha.4",
-    "@typescript-eslint/rule-tester": "8.58.3-alpha.4"
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.58.3-alpha.5",
+    "@typescript-eslint/rule-tester": "8.58.3-alpha.5"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0",
-    "@typescript-eslint/parser": "^8.58.3-alpha.4"
+    "@typescript-eslint/parser": "^8.58.3-alpha.5"
   },
   "funding": {
     "type": "opencollective",