@depup/typescript-eslint__eslint-plugin 8.70.0-depup.0 → 8.70.1-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Field | Value |
 |-------|-------|
-| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.70.0 |
-| Processed | 2026-09-08 |
+| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.70.1 |
+| Processed | 2026-09-22 |
 | Smoke test | passed |
 | Deps updated | 1 |
 
@@ -22,7 +22,7 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Dependency | From | To |
 |------------|------|-----|
-| ignore | ^7.0.5 | ^7.0.8 |
+| ignore | ^7.0.5 | ^7.0.9 |
 
 ---
 

package/changes.json

@@ -2,9 +2,9 @@
   "bumped": {
     "ignore": {
       "from": "^7.0.5",
-      "to": "^7.0.8"
+      "to": "^7.0.9"
     }
   },
-  "timestamp": "2026-09-08T00:33:07.330Z",
+  "timestamp": "2026-09-22T00:32:40.856Z",
   "totalUpdated": 1
 }

package/dist/index.d.ts

@@ -994,7 +994,7 @@ declare const _default: {
         'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
             allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;

package/dist/raw-plugin.d.ts

@@ -1017,7 +1017,7 @@ declare const _default: {
             'no-useless-constructor': TSESLint.RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'no-useless-default-assignment': TSESLint.RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+            'no-useless-default-assignment': TSESLint.RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
                 allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;

package/dist/rules/await-thenable.js

@@ -77,7 +77,18 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'removeAwait',
                                 fix(fixer) {
                                     const awaitKeyword = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await expression'));
-                                    return fixer.remove(awaitKeyword);
+                                    const awaitTokenRemovalRange = (0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitKeyword);
+                                    const awaitRemovalFix = fixer.removeRange(awaitTokenRemovalRange);
+                                    const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitKeyword), util_1.NullThrowsReasons.MissingToken('operand', 'await expression'));
+                                    if ((0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode) ||
+                                        (0, util_1.isStartOfExpressionStatementNeedingParentheses)(node, firstOperandToken)) {
+                                        return [
+                                            awaitRemovalFix,
+                                            fixer.insertTextBefore(awaitArgumentEsNode, '('),
+                                            fixer.insertTextAfter(awaitArgumentEsNode, ')'),
+                                        ];
+                                    }
+                                    return awaitRemovalFix;
                                 },
                             },
                         ],
@@ -135,7 +146,7 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'convertToOrdinaryFor',
                                 fix(fixer) {
                                     const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'for await loop'));
-                                    return fixer.remove(awaitToken);
+                                    return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken));
                                 },
                             },
                         ],
@@ -168,7 +179,7 @@ exports.default = (0, util_1.createRule)({
                                     messageId: 'removeAwait',
                                     fix(fixer) {
                                         const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await using'));
-                                        return fixer.remove(awaitToken);
+                                        return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken));
                                     },
                                 },
                             }),

package/dist/rules/index.d.ts

@@ -315,7 +315,7 @@ declare const rules: {
     'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;

package/dist/rules/no-explicit-any.js

@@ -155,6 +155,14 @@ exports.default = (0, util_1.createRule)({
                 return fixer.replaceText(node.parent, 'PropertyKey');
             };
         }
+        function createUnknownFixer(node) {
+            return (fixer) => {
+                return fixer.replaceText(node, node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                    isNodeRestElementInFunction(node.parent.parent)
+                    ? 'unknown[]'
+                    : 'unknown');
+            };
+        }
         return {
             TSAnyKeyword(node) {
                 const isKeyofAny = isNodeWithinKeyofAny(node);
@@ -173,7 +181,7 @@ exports.default = (0, util_1.createRule)({
                         : [
                             {
                                 messageId: 'suggestUnknown',
-                                fix: fixer => fixer.replaceText(node, 'unknown'),
+                                fix: createUnknownFixer(node),
                             },
                             {
                                 messageId: 'suggestNever',
@@ -184,7 +192,7 @@ exports.default = (0, util_1.createRule)({
                 if (fixToUnknown) {
                     fixOrSuggest.fix = isKeyofAny
                         ? createPropertyKeyFixer(node)
-                        : fixer => fixer.replaceText(node, 'unknown');
+                        : createUnknownFixer(node);
                 }
                 context.report({
                     node,

package/dist/rules/no-generated-empty-object-type.js

@@ -63,8 +63,12 @@ exports.default = (0, util_1.createRule)({
                 type.getCallSignatures().length === 0 &&
                 type.getConstructSignatures().length === 0 &&
                 // Types still awaiting type arguments, such as `Record<T, unknown>`
-                // inside a generic declaration, also have no members yet.
-                checker.isTypeAssignableTo(checker.getNumberType(), type));
+                // inside a generic declaration, also have no members yet. Every
+                // primitive is assignable to `{}`, so probing with more than one of
+                // them rules those out: a mapped type whose keys are not resolved yet,
+                // such as `{ [K in Keys<T>]: K }`, accepts `number` but not `string`.
+                checker.isTypeAssignableTo(checker.getNumberType(), type) &&
+                checker.isTypeAssignableTo(checker.getStringType(), type));
         }
         function containsEmptyObjectType(type) {
             return (isEmptyObjectType(type) ||

package/dist/rules/no-meaningless-void-operator.js

@@ -84,6 +84,11 @@ exports.default = (0, util_1.createRule)({
                     if (inner.type === utils_1.AST_NODE_TYPES.Literal && inner.value === 0) {
                         return;
                     }
+                    // `void (x = value)` discards the assignment result so the
+                    // expression evaluates to undefined (e.g. `() => void (x = 1)`).
+                    if (inner.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+                        return;
+                    }
                     const tsArgument = services.esTreeNodeToTSNodeMap.get(node.argument);
                     const argType = services.getTypeAtLocation(node.argument);
                     // Allow `void promiseValue` so this rule does not fight no-floating-promises.

package/dist/rules/no-misused-promises.js

@@ -841,19 +841,23 @@ function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
 function hasMatchingPromiseTypeArgument(checker, node) {
     const type = checker.getTypeAtLocation(node);
     const unionConstituents = tsutils.unionConstituents(checker.getApparentType(type));
-    const promiseType = unionConstituents.find(type => tsutils.isThenableType(checker, node, type));
-    if (!promiseType) {
+    const promiseTypes = unionConstituents.filter(type => tsutils.isThenableType(checker, node, type));
+    if (promiseTypes.length === 0) {
         return false;
     }
-    const nonPromiseUnionConstituents = unionConstituents.filter(type => type !== promiseType);
-    const awaitedType = checker.getAwaitedType(promiseType);
-    if (!awaitedType) {
-        return false;
+    const nonPromiseUnionConstituents = unionConstituents.filter(type => !promiseTypes.includes(type));
+    const awaitedTypeConstituents = [];
+    for (const promiseType of promiseTypes) {
+        const awaitedType = checker.getAwaitedType(promiseType);
+        if (!awaitedType) {
+            return false;
+        }
+        awaitedTypeConstituents.push(...tsutils.unionConstituents(awaitedType));
     }
-    const awaitedTypeConstituents = tsutils.unionConstituents(awaitedType);
-    return (nonPromiseUnionConstituents.length === awaitedTypeConstituents.length &&
-        nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => checker.isTypeAssignableTo(type, awaited) &&
-            checker.isTypeAssignableTo(awaited, type))));
+    const typesAreEquivalent = (left, right) => checker.isTypeAssignableTo(left, right) &&
+        checker.isTypeAssignableTo(right, left);
+    return (nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => typesAreEquivalent(type, awaited))) &&
+        awaitedTypeConstituents.every(awaited => nonPromiseUnionConstituents.some(type => typesAreEquivalent(type, awaited))));
 }
 function normalizeFlagUnionsOption(checksConditionals) {
     if (!checksConditionals || checksConditionals === true) {

package/dist/rules/no-misused-spread.js

@@ -98,7 +98,7 @@ exports.default = (0, util_1.createRule)({
         }
         function getMapSpreadSuggestions(node, type) {
             const types = tsutils.unionConstituents(type);
-            if (types.some(t => !isMap(services.program, t))) {
+            if (types.some(t => !isIterableMap(services.program, t))) {
                 return null;
             }
             if (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
@@ -252,6 +252,9 @@ function isClassDeclaration(type) {
 function isMap(program, type) {
     return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap', 'WeakMap']));
 }
+function isIterableMap(program, type) {
+    return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap']));
+}
 function isTypeRecurser(type, predicate) {
     if (type.isUnionOrIntersection()) {
         return type.types.some(t => isTypeRecurser(t, predicate));

package/dist/rules/no-unnecessary-condition.js

@@ -55,6 +55,15 @@ function isPossiblyNullish(type) {
         .unionConstituents(type)
         .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
 }
+/**
+ * Note that this differs from {@link isNullableType} in that it doesn't consider
+ * `any` or `unknown` to be nullable.
+ */
+function isPossiblyNonNullish(type) {
+    return tsutils
+        .unionConstituents(type)
+        .some(t => !isNullishType(t) && !(0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
+}
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
     if (tsutils.isBooleanLiteralType(type)) {
@@ -262,11 +271,48 @@ exports.default = (0, util_1.createRule)({
             const propertyType = objectType
                 .getProperties()
                 .find(prop => prop.name === propertyName);
-            if (propertyType &&
-                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)) {
-                return true;
+            return (propertyType != null &&
+                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional));
+        }
+        /**
+         * Obtains the property types of the computed member expression
+         * @param node The member expression
+         * @returns The property types, unless the node isn't computed.
+         */
+        function getComputedMemberPropertyTypes(node) {
+            if (!node.computed) {
+                return undefined;
+            }
+            const objectType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object);
+            const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property);
+            const propertyTypes = [];
+            for (const keyType of tsutils.unionConstituents(propertyType)) {
+                if (!keyType.isStringLiteral() && !keyType.isNumberLiteral()) {
+                    return undefined;
+                }
+                const selectedType = (0, util_1.getTypeOfPropertyOfName)(checker, objectType, String(keyType.value));
+                if (!selectedType) {
+                    return undefined;
+                }
+                propertyTypes.push(selectedType);
             }
-            return false;
+            return propertyTypes;
+        }
+        /**
+         * Verify if the node may have non-nullish properties
+         * @param node The node to verify
+         * @returns If it may have non-nullish properties, unless the node isn't a
+         * MemberExpression
+         */
+        function hasPossiblyNonNullishComputedMemberProperty(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const propertyTypes = getComputedMemberPropertyTypes(node);
+            if (propertyTypes == null) {
+                return false;
+            }
+            return propertyTypes.some(isPossiblyNonNullish);
         }
         /**
          * Checks if a conditional node is necessary:
@@ -344,7 +390,8 @@ exports.default = (0, util_1.createRule)({
                     messageId = 'neverNullish';
                 }
             }
-            else if (isAlwaysNullish(type)) {
+            else if (isAlwaysNullish(type) &&
+                !hasPossiblyNonNullishComputedMemberProperty(node)) {
                 messageId = 'alwaysNullish';
             }
             if (messageId) {

package/dist/rules/no-unnecessary-parameter-property-assignment.js

@@ -101,10 +101,6 @@ exports.default = (0, util_1.createRule)({
                 });
             },
             "MethodDefinition[kind='constructor'] > FunctionExpression AssignmentExpression"(node) {
-                const leftName = getPropertyName(node.left);
-                if (!leftName) {
-                    return;
-                }
                 let functionNode = findParentFunction(node);
                 if (functionNode && isArrowIIFE(functionNode)) {
                     functionNode = findParentFunction(functionNode.parent);
@@ -113,6 +109,18 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const { assignedBeforeUnnecessary, unnecessaryAssignments } = (0, util_1.nullThrows)(reportInfoStack.at(reportInfoStack.length - 1), 'The top of stack should exist');
+                // A prior write to the parameter binding means a later `this.x = x`
+                // may copy a different value than the parameter property initialized.
+                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (isReferenceFromParameter(node.left)) {
+                        assignedBeforeUnnecessary.add(node.left.name);
+                    }
+                    return;
+                }
+                const leftName = getPropertyName(node.left);
+                if (!leftName) {
+                    return;
+                }
                 if (!UNNECESSARY_OPERATORS.has(node.operator)) {
                     assignedBeforeUnnecessary.add(leftName);
                     return;

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

@@ -178,7 +178,7 @@ exports.default = (0, util_1.createRule)({
             }
             if (((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.NonPrimitive) &&
                 !(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.NonPrimitive)) ||
-                (hasIndexSignature(uncast) && !hasIndexSignature(cast)) ||
+                hasIndexSignature(uncast) !== hasIndexSignature(cast) ||
                 containsAny(uncast) ||
                 containsAny(cast) ||
                 (containsTypeVariable(cast) && !containsTypeVariable(uncast))) {
@@ -587,11 +587,8 @@ exports.default = (0, util_1.createRule)({
                     // is parsed as a block body. In those positions the operand must be
                     // wrapped in parentheses to stay an expression.
                     const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(closingAngleBracket), util_1.NullThrowsReasons.MissingToken('operand', 'type assertion'));
-                    const breaksExpressionStatement = ['{', 'function', 'class'].includes(firstOperandToken.value) &&
-                        (0, util_1.isStartOfExpressionStatement)(node);
-                    const breaksArrowFunctionBody = firstOperandToken.value === '{' &&
-                        (0, util_1.isStartOfArrowFunctionBody)(node, context.sourceCode);
-                    const needsParens = breaksExpressionStatement || breaksArrowFunctionBody;
+                    const needsParens = (0, util_1.isStartOfExpressionStatementNeedingParentheses)(node, firstOperandToken) ||
+                        (0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode);
                     const fixes = [];
                     if (needsParens) {
                         fixes.push(fixer.insertTextBefore(node, '('));

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

@@ -101,27 +101,25 @@ exports.default = (0, util_1.createRule)({
                                 for (const reference of smTypeParameterVariable.references) {
                                     if (reference.isTypeReference) {
                                         const referenceNode = reference.identifier;
-                                        const isComplexType = constraint?.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                                        const isWeakPrecedenceConstraint = constraint?.type === utils_1.AST_NODE_TYPES.TSUnionType ||
                                             constraint?.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
-                                            constraint?.type === utils_1.AST_NODE_TYPES.TSConditionalType;
-                                        const hasMatchingAncestorType = [
-                                            utils_1.AST_NODE_TYPES.TSArrayType,
-                                            utils_1.AST_NODE_TYPES.TSIndexedAccessType,
-                                            utils_1.AST_NODE_TYPES.TSIntersectionType,
-                                            utils_1.AST_NODE_TYPES.TSUnionType,
-                                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                        ].some(type => referenceNode.parent.parent.type === type);
-                                        if (isComplexType && hasMatchingAncestorType) {
-                                            const fixResult = (0, util_1.getWrappingFixer)({
-                                                node: referenceNode,
-                                                innerNode: constraint,
-                                                sourceCode: context.sourceCode,
-                                                wrap: constraintNode => constraintNode,
-                                            })(fixer);
-                                            yield fixResult;
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSConditionalType ||
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSTypeOperator ||
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSFunctionType ||
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSConstructorType;
+                                        const grandparent = (0, util_1.nullThrows)(referenceNode.parent.parent, util_1.NullThrowsReasons.MissingParent);
+                                        const isWeakPrecedenceTypeParent = grandparent.type === utils_1.AST_NODE_TYPES.TSArrayType ||
+                                            grandparent.type === utils_1.AST_NODE_TYPES.TSIndexedAccessType ||
+                                            grandparent.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
+                                            grandparent.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                                            grandparent.type === utils_1.AST_NODE_TYPES.TSConditionalType ||
+                                            grandparent.type === utils_1.AST_NODE_TYPES.TSTypeOperator;
+                                        if (isWeakPrecedenceConstraint &&
+                                            isWeakPrecedenceTypeParent) {
+                                            yield fixer.replaceText(referenceNode.parent, `(${constraintText})`);
                                         }
                                         else {
-                                            yield fixer.replaceText(referenceNode, constraintText);
+                                            yield fixer.replaceText(referenceNode.parent, constraintText);
                                         }
                                     }
                                 }

package/dist/rules/no-useless-default-assignment.d.ts

@@ -1,5 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-type MessageId = 'noStrictNullCheck' | 'preferOptionalSyntax' | 'uselessDefaultAssignment' | 'uselessUndefined';
+type MessageId = 'noStrictNullCheck' | 'preferOptionalSyntax' | 'removeDefaultAssignment' | 'uselessDefaultAssignment' | 'uselessUndefined' | 'useOptionalSyntax';
 type Options = [
     {
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;

package/dist/rules/no-useless-default-assignment.js

@@ -46,12 +46,14 @@ exports.default = (0, util_1.createRule)({
             recommended: 'strict',
             requiresTypeChecking: true,
         },
-        fixable: 'code',
+        hasSuggestions: true,
         messages: {
             noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-            preferOptionalSyntax: 'Using `= undefined` to make a parameter optional adds unnecessary runtime logic. Use the `?` optional syntax instead.',
+            preferOptionalSyntax: 'Using `= undefined` to make a parameter optional adds unnecessary runtime logic.',
+            removeDefaultAssignment: 'Remove the default value.',
             uselessDefaultAssignment: 'Default value is useless because the {{ type }} is not optional.',
             uselessUndefined: 'Default value is useless because it is undefined. Optional {{ type }}s are already undefined by default.',
+            useOptionalSyntax: 'Use the `?` optional syntax instead.',
         },
         schema: [
             {
@@ -183,8 +185,14 @@ exports.default = (0, util_1.createRule)({
                 if (elementIndex < 0 || elementIndex >= tupleArgs.length) {
                     return;
                 }
-                const elementType = tupleArgs[elementIndex];
-                if (!canBeUndefined(elementType)) {
+                const { fixedLength, minLength } = sourceType.target;
+                if (elementIndex >= minLength) {
+                    return;
+                }
+                const elementTypes = elementIndex < fixedLength
+                    ? [tupleArgs[elementIndex]]
+                    : tupleArgs.slice(fixedLength);
+                if (!elementTypes.some(canBeUndefined)) {
                     reportUselessDefaultAssignment(node, 'property');
                 }
             }
@@ -280,7 +288,7 @@ exports.default = (0, util_1.createRule)({
                 node: node.right,
                 messageId: 'uselessDefaultAssignment',
                 data: { type },
-                fix: fixer => removeDefault(fixer, node),
+                suggest: [removeDefaultSuggestion(node)],
             });
         }
         function reportUselessUndefined(node, type) {
@@ -288,13 +296,19 @@ exports.default = (0, util_1.createRule)({
                 node: node.right,
                 messageId: 'uselessUndefined',
                 data: { type },
-                fix: fixer => removeDefault(fixer, node),
+                suggest: [removeDefaultSuggestion(node)],
             });
         }
         function reportPreferOptionalSyntax(node) {
             context.report({
                 node: node.right,
                 messageId: 'preferOptionalSyntax',
+                suggest: [useOptionalSyntaxSuggestion(node)],
+            });
+        }
+        function useOptionalSyntaxSuggestion(node) {
+            return {
+                messageId: 'useOptionalSyntax',
                 *fix(fixer) {
                     yield removeDefault(fixer, node);
                     const { left } = node;
@@ -302,7 +316,13 @@ exports.default = (0, util_1.createRule)({
                         yield fixer.insertTextAfterRange([left.range[0], left.range[0] + left.name.length], '?');
                     }
                 },
-            });
+            };
+        }
+        function removeDefaultSuggestion(node) {
+            return {
+                messageId: 'removeDefaultAssignment',
+                fix: fixer => removeDefault(fixer, node),
+            };
         }
         function removeDefault(fixer, node) {
             const start = node.left.range[1];

package/dist/rules/return-await.js

@@ -211,20 +211,10 @@ exports.default = (0, util_1.createRule)({
             /* istanbul ignore if */ if (!awaitToken) {
                 return null;
             }
-            const startAt = awaitToken.range[0];
-            let endAt = awaitToken.range[1];
-            // Also remove any extraneous whitespace after `await`, if there is any.
-            const nextToken = context.sourceCode.getTokenAfter(awaitToken, {
-                includeComments: true,
-            });
-            if (nextToken) {
-                endAt = nextToken.range[0];
-            }
-            const awaitRemovalFix = fixer.removeRange([startAt, endAt]);
+            const awaitTokenRemovalRange = (0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken);
+            const awaitRemovalFix = fixer.removeRange(awaitTokenRemovalRange);
             const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitToken), util_1.NullThrowsReasons.MissingToken('operand', 'await expression'));
-            const shouldWrapInParentheses = (0, util_1.isOpeningBraceToken)(firstOperandToken) &&
-                (0, util_1.isStartOfArrowFunctionBody)(node, context.sourceCode);
-            if (shouldWrapInParentheses) {
+            if ((0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode)) {
                 return [
                     awaitRemovalFix,
                     fixer.insertTextBefore(node.argument, '('),

package/dist/rules/unbound-method.js

@@ -90,6 +90,19 @@ const SUPPORTED_GLOBAL_TYPES = [
     'Math',
     'JSON',
 ];
+/**
+ * Methods on instances of built-in classes that are defined by the ECMAScript
+ * spec as *bound* to their instance (i.e. they are safe to call without their
+ * receiver), but whose TypeScript declarations don't model that binding - they
+ * are declared as plain methods that would require a `this` value.
+ *
+ * For example, `Intl.Collator.prototype.compare` is defined as a bound getter
+ * function per the ECMA-402 spec:
+ * https://tc39.es/ecma402/#sec-intl.collator.prototype.compare
+ * ...but `lib.es5.d.ts` declares it as a regular method, so this rule would
+ * otherwise incorrectly flag usages such as `array.sort(collator.compare)`.
+ */
+const nativelyBoundInstanceMethods = new Set(['Collator.compare']);
 const isNotImported = (symbol, currentSourceFile) => {
     const { valueDeclaration } = symbol;
     if (!valueDeclaration) {
@@ -99,6 +112,18 @@ const isNotImported = (symbol, currentSourceFile) => {
     return (!!currentSourceFile &&
         currentSourceFile !== valueDeclaration.getSourceFile());
 };
+/**
+ * Returns `true` if `propertyName` is a member of a built-in class instance
+ * that is defined by the spec as bound to that instance (see
+ * `nativelyBoundInstanceMethods` above).
+ */
+function isSpecBoundBuiltinMethod(program, objectType, propertyName) {
+    const symbol = objectType.getSymbol();
+    if (!symbol || !(0, util_1.isSymbolFromDefaultLibrary)(program, symbol)) {
+        return false;
+    }
+    return nativelyBoundInstanceMethods.has(`${symbol.getName()}.${propertyName}`);
+}
 const BASE_MESSAGE = [
     `A method that is not declared with \`this: void\` may cause unintentional scoping of \`this\` when separated from its object.`,
     `Consider using an arrow function or explicitly \`.bind()\`ing the method to avoid calling the method with an unintended \`this\` value. `,
@@ -196,6 +221,12 @@ exports.default = (0, util_1.createRule)({
                     return true;
                 }
             }
+            if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const objectType = services.getTypeAtLocation(object);
+                if (isSpecBoundBuiltinMethod(services.program, objectType, property.name)) {
+                    return true;
+                }
+            }
             // if `${object.name}.${property.name}` doesn't match any of
             // the nativelyBoundMembers, then we fallback to type-level checks
             return ((0, util_1.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(object), SUPPORTED_GLOBAL_TYPES) &&

package/dist/util/getAwaitTokenRemovalRange.d.ts

@@ -0,0 +1,4 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export declare function getAwaitTokenRemovalRange(sourceCode: TSESLint.SourceCode, awaitToken: TSESTree.IdentifierToken & {
+    value: 'await';
+}): TSESTree.Range;

package/dist/util/getAwaitTokenRemovalRange.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAwaitTokenRemovalRange = getAwaitTokenRemovalRange;
+function getAwaitTokenRemovalRange(sourceCode, awaitToken) {
+    const startAt = awaitToken.range[0];
+    let endAt = awaitToken.range[1];
+    const nextToken = sourceCode.getTokenAfter(awaitToken, {
+        includeComments: true,
+    });
+    /* istanbul ignore else */ if (nextToken) {
+        endAt = nextToken.range[0];
+    }
+    return [startAt, endAt];
+}
+//# sourceMappingURL=getAwaitTokenRemovalRange.js.map

package/dist/util/getWrappingFixer.js

@@ -73,7 +73,6 @@ function isStrongPrecedenceNode(innerNode) {
     return (innerNode.type === utils_1.AST_NODE_TYPES.Literal ||
         innerNode.type === utils_1.AST_NODE_TYPES.Identifier ||
         innerNode.type === utils_1.AST_NODE_TYPES.TSTypeReference ||
-        innerNode.type === utils_1.AST_NODE_TYPES.TSTypeOperator ||
         innerNode.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
         innerNode.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
         innerNode.type === utils_1.AST_NODE_TYPES.MemberExpression ||

package/dist/util/index.d.ts

@@ -4,6 +4,7 @@ export * from './baseTypeUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
 export * from './FunctionSignature';
+export * from './getAwaitTokenRemovalRange';
 export * from './getBaseTypesOfClassMember';
 export * from './getFixOrSuggest';
 export * from './getFunctionHeadLoc';
@@ -19,8 +20,9 @@ export * from './isAssignee';
 export * from './isConditionalTest';
 export * from './isNodeEqual';
 export * from './isNullLiteral';
-export * from './isStartOfArrowFunctionBody';
+export * from './isStartOfArrowFunctionBodyNeedingParentheses';
 export * from './isStartOfExpressionStatement';
+export * from './isStartOfExpressionStatementNeedingParentheses';
 export * from './isUndefinedIdentifier';
 export * from './misc';
 export * from './needsPrecedingSemiColon';

package/dist/util/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./baseTypeUtils"), exports);
 __exportStar(require("./collectUnusedVariables"), exports);
 __exportStar(require("./createRule"), exports);
 __exportStar(require("./FunctionSignature"), exports);
+__exportStar(require("./getAwaitTokenRemovalRange"), exports);
 __exportStar(require("./getBaseTypesOfClassMember"), exports);
 __exportStar(require("./getFixOrSuggest"), exports);
 __exportStar(require("./getFunctionHeadLoc"), exports);
@@ -36,8 +37,9 @@ __exportStar(require("./isAssignee"), exports);
 __exportStar(require("./isConditionalTest"), exports);
 __exportStar(require("./isNodeEqual"), exports);
 __exportStar(require("./isNullLiteral"), exports);
-__exportStar(require("./isStartOfArrowFunctionBody"), exports);
+__exportStar(require("./isStartOfArrowFunctionBodyNeedingParentheses"), exports);
 __exportStar(require("./isStartOfExpressionStatement"), exports);
+__exportStar(require("./isStartOfExpressionStatementNeedingParentheses"), exports);
 __exportStar(require("./isUndefinedIdentifier"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./needsPrecedingSemiColon"), exports);

package/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.d.ts

@@ -0,0 +1,2 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export declare function isStartOfArrowFunctionBodyNeedingParentheses(node: TSESTree.Node, firstToken: TSESTree.Token, sourceCode: TSESLint.SourceCode): boolean;

package/dist/util/{isStartOfArrowFunctionBody.js → isStartOfArrowFunctionBodyNeedingParentheses.js}

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStartOfArrowFunctionBody = isStartOfArrowFunctionBody;
+exports.isStartOfArrowFunctionBodyNeedingParentheses = isStartOfArrowFunctionBodyNeedingParentheses;
 const utils_1 = require("@typescript-eslint/utils");
 const astUtils_1 = require("./astUtils");
+function isStartOfArrowFunctionBodyNeedingParentheses(node, firstToken, sourceCode) {
+    return ((0, astUtils_1.isOpeningBraceToken)(firstToken) &&
+        isStartOfArrowFunctionBody(node, sourceCode));
+}
 function isStartOfArrowFunctionBody(node, sourceCode) {
     let current = node;
     while (true) {
@@ -23,4 +27,4 @@ function isStartOfArrowFunctionBody(node, sourceCode) {
         current = parent;
     }
 }
-//# sourceMappingURL=isStartOfArrowFunctionBody.js.map
+//# sourceMappingURL=isStartOfArrowFunctionBodyNeedingParentheses.js.map

package/dist/util/isStartOfExpressionStatementNeedingParentheses.d.ts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isStartOfExpressionStatementNeedingParentheses(node: TSESTree.Node, firstToken: TSESTree.Token): boolean;

package/dist/util/isStartOfExpressionStatementNeedingParentheses.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStartOfExpressionStatementNeedingParentheses = isStartOfExpressionStatementNeedingParentheses;
+const isStartOfExpressionStatement_1 = require("./isStartOfExpressionStatement");
+function isStartOfExpressionStatementNeedingParentheses(node, firstToken) {
+    return (['{', 'class', 'function'].includes(firstToken.value) &&
+        (0, isStartOfExpressionStatement_1.isStartOfExpressionStatement)(node));
+}
+//# sourceMappingURL=isStartOfExpressionStatementNeedingParentheses.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/typescript-eslint__eslint-plugin",
-  "version": "8.70.0-depup.0",
+  "version": "8.70.1-depup.0",
   "description": "TypeScript plugin for ESLint (with updated dependencies)",
   "files": [
     "dist",
@@ -55,11 +55,11 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.70.0",
-    "@typescript-eslint/type-utils": "8.70.0",
-    "@typescript-eslint/utils": "8.70.0",
-    "@typescript-eslint/visitor-keys": "8.70.0",
-    "ignore": "^7.0.8",
+    "@typescript-eslint/scope-manager": "8.70.1",
+    "@typescript-eslint/type-utils": "8.70.1",
+    "@typescript-eslint/utils": "8.70.1",
+    "@typescript-eslint/visitor-keys": "8.70.1",
+    "ignore": "^7.0.9",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
   },
@@ -68,8 +68,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.0",
-    "@typescript-eslint/rule-tester": "8.70.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.1",
+    "@typescript-eslint/rule-tester": "8.70.1",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -89,7 +89,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.70.0",
+    "@typescript-eslint/parser": "^8.70.1",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },
@@ -144,13 +144,13 @@
     "changes": {
       "ignore": {
         "from": "^7.0.5",
-        "to": "^7.0.8"
+        "to": "^7.0.9"
       }
     },
     "depsUpdated": 1,
     "originalPackage": "@typescript-eslint/eslint-plugin",
-    "originalVersion": "8.70.0",
-    "processedAt": "2026-09-08T00:33:17.890Z",
+    "originalVersion": "8.70.1",
+    "processedAt": "2026-09-22T00:32:50.942Z",
     "smokeTest": "passed"
   }
 }

package/dist/util/isStartOfArrowFunctionBody.d.ts

@@ -1,2 +0,0 @@
-import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-export declare function isStartOfArrowFunctionBody(node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean;