@typescript-eslint/eslint-plugin 8.56.2-alpha.0 → 8.56.2-alpha.10

package/dist/rules/no-base-to-string.js

@@ -269,17 +269,15 @@ exports.default = (0, util_1.createRule)({
                     continue;
                 }
                 const declarations = candidate.getDeclarations();
-                // If there are multiple declarations, at least one of them must not be
-                // the default object toString.
-                //
-                // This may only matter for older versions of TS
-                // see https://github.com/typescript-eslint/typescript-eslint/issues/8585
-                if (declarations?.length !== 1) {
+                if (!declarations?.length) {
                     continue;
                 }
-                // Not being the Object interface means this is user-defined.
-                if (!ts.isInterfaceDeclaration(declarations[0].parent) ||
-                    declarations[0].parent.name.text !== 'Object') {
+                // If any declaration is not from the Object interface, this is
+                // user-defined (e.g. overloaded toString on a class or module).
+                // see https://github.com/typescript-eslint/typescript-eslint/issues/8585
+                // see https://github.com/typescript-eslint/typescript-eslint/issues/11945
+                if (declarations.some(declaration => !(ts.isInterfaceDeclaration(declaration.parent) &&
+                    declaration.parent.name.text === 'Object'))) {
                     return false;
                 }
                 foundFallbackOnObject = true;

package/dist/rules/no-duplicate-enum-values.js

@@ -46,7 +46,7 @@ exports.default = (0, util_1.createRule)({
                     return initializer.operator === '-' ? -inner : inner;
                 }
                 case isStaticTemplateLiteral(initializer):
-                    return initializer.quasis[0].value.cooked;
+                    return initializer.quasis[0].value.cooked ?? undefined;
                 default:
                     return undefined;
             }

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

@@ -396,14 +396,6 @@ exports.default = (0, util_1.createRule)({
             // The right side will be checked if the LogicalExpression is used in a conditional context
             checkNode(node.left);
         }
-        function checkIfWhileLoopIsNecessaryConditional(node) {
-            if (allowConstantLoopConditionsOption === 'only-allowed-literals' &&
-                node.test.type === utils_1.AST_NODE_TYPES.Literal &&
-                constantLoopConditionsAllowedLiterals.has(node.test.value)) {
-                return;
-            }
-            checkIfLoopIsNecessaryConditional(node);
-        }
         /**
          * Checks that a testable expression of a loop is necessarily conditional, reports otherwise.
          */
@@ -412,6 +404,11 @@ exports.default = (0, util_1.createRule)({
                 // e.g. `for(;;)`
                 return;
             }
+            if (allowConstantLoopConditionsOption === 'only-allowed-literals' &&
+                node.test.type === utils_1.AST_NODE_TYPES.Literal &&
+                constantLoopConditionsAllowedLiterals.has(node.test.value)) {
+                return;
+            }
             if (allowConstantLoopConditionsOption === 'always' &&
                 tsutils.isTrueLiteralType((0, util_1.getConstrainedTypeAtLocation)(services, node.test))) {
                 return;
@@ -663,7 +660,7 @@ exports.default = (0, util_1.createRule)({
                     checkIfBoolExpressionIsNecessaryConditional(test, parent.discriminant, test, '===');
                 }
             },
-            WhileStatement: checkIfWhileLoopIsNecessaryConditional,
+            WhileStatement: checkIfLoopIsNecessaryConditional,
         };
     },
 });

package/dist/rules/no-unsafe-assignment.js

@@ -169,7 +169,8 @@ exports.default = (0, util_1.createRule)({
                 }
                 else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
                     receiverProperty.key.quasis.length === 1) {
-                    key = receiverProperty.key.quasis[0].value.cooked;
+                    const cooked = (0, util_1.nullThrows)(receiverProperty.key.quasis[0].value.cooked, 'cooked can only be null inside a TaggedTemplateExpression, which is not possible here');
+                    key = cooked;
                 }
                 else {
                     // can't figure out the name, so skip it

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

@@ -236,6 +236,9 @@ exports.default = (0, util_1.createRule)({
                 if (signature.thisParameter) {
                     paramIndex--;
                 }
+                if (paramIndex < 0 || paramIndex >= params.length) {
+                    return null;
+                }
                 return checker.getTypeOfSymbol(params[paramIndex]);
             }
             if (parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {

package/dist/rules/prefer-promise-reject-errors.d.ts

@@ -1,6 +1,8 @@
+import type { TypeOrValueSpecifier } from '../util';
 export type MessageIds = 'rejectAnError';
 export type Options = [
     {
+        allow?: TypeOrValueSpecifier[];
         allowEmptyReject?: boolean;
         allowThrowingAny?: boolean;
         allowThrowingUnknown?: boolean;

package/dist/rules/prefer-promise-reject-errors.js

@@ -20,6 +20,10 @@ exports.default = (0, util_1.createRule)({
                 type: 'object',
                 additionalProperties: false,
                 properties: {
+                    allow: {
+                        ...util_1.typeOrValueSpecifiersSchema,
+                        description: 'Type specifiers that can be used as Promise rejection reasons.',
+                    },
                     allowEmptyReject: {
                         type: 'boolean',
                         description: 'Whether to allow calls to `Promise.reject()` with no arguments.',
@@ -38,6 +42,7 @@ exports.default = (0, util_1.createRule)({
     },
     defaultOptions: [
         {
+            allow: [],
             allowEmptyReject: false,
             allowThrowingAny: false,
             allowThrowingUnknown: false,
@@ -49,6 +54,9 @@ exports.default = (0, util_1.createRule)({
             const argument = callExpression.arguments.at(0);
             if (argument) {
                 const type = services.getTypeAtLocation(argument);
+                if ((0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program)) {
+                    return;
+                }
                 if (options.allowThrowingAny && (0, util_1.isTypeAnyType)(type)) {
                     return;
                 }

package/dist/rules/prefer-readonly.js

@@ -222,7 +222,11 @@ exports.default = (0, util_1.createRule)({
                             name: context.sourceCode.getText(nameNode),
                         },
                         *fix(fixer) {
-                            yield fixer.insertTextBefore(nameNode, 'readonly ');
+                            const readonlyInsertionTarget = esNode.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                                esNode.computed
+                                ? (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(nameNode), 'Expected to find a token before computed property name')
+                                : nameNode;
+                            yield fixer.insertTextBefore(readonlyInsertionTarget, 'readonly ');
                             if (typeAnnotation) {
                                 yield fixer.insertTextAfter(nameNode, `: ${typeAnnotation}`);
                             }
@@ -239,9 +243,25 @@ exports.default = (0, util_1.createRule)({
                 }
             },
             MemberExpression(node) {
-                if (classScopeStack.length !== 0 && !node.computed) {
+                if (classScopeStack.length === 0) {
+                    return;
+                }
+                const classScope = classScopeStack[classScopeStack.length - 1];
+                if (!node.computed) {
                     const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-                    handlePropertyAccessExpression(tsNode, tsNode.parent, classScopeStack[classScopeStack.length - 1]);
+                    handlePropertyAccessExpression(tsNode, tsNode.parent, classScope);
+                }
+                else {
+                    const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+                    if (ts.isElementAccessExpression(tsNode) &&
+                        ts.isBinaryExpression(tsNode.parent) &&
+                        tsNode.parent.left === tsNode &&
+                        tsutils.isAssignmentKind(tsNode.parent.operatorToken.kind)) {
+                        const memberName = (0, util_1.getStaticMemberAccessValue)(node, context);
+                        if (typeof memberName === 'string') {
+                            classScope.addVariableModificationByName(tsNode.expression, memberName);
+                        }
+                    }
                 }
             },
         };
@@ -285,8 +305,7 @@ class ClassScope {
     addDeclaredVariable(node) {
         if (!(tsutils.isModifierFlagSet(node, ts.ModifierFlags.Private) ||
             node.name.kind === ts.SyntaxKind.PrivateIdentifier) ||
-            tsutils.isModifierFlagSet(node, ts.ModifierFlags.Accessor | ts.ModifierFlags.Readonly) ||
-            ts.isComputedPropertyName(node.name)) {
+            tsutils.isModifierFlagSet(node, ts.ModifierFlags.Accessor | ts.ModifierFlags.Readonly)) {
             return;
         }
         if (this.onlyInlineLambdas &&
@@ -294,25 +313,32 @@ class ClassScope {
             !ts.isArrowFunction(node.initializer)) {
             return;
         }
+        const memberName = getMemberName(node.name);
+        if (memberName == null) {
+            return;
+        }
         (tsutils.isModifierFlagSet(node, ts.ModifierFlags.Static)
             ? this.privateModifiableStatics
-            : this.privateModifiableMembers).set(node.name.getText(), node);
+            : this.privateModifiableMembers).set(memberName, node);
     }
     addVariableModification(node) {
-        const modifierType = this.checker.getTypeAtLocation(node.expression);
+        this.addVariableModificationByName(node.expression, node.name.text);
+    }
+    addVariableModificationByName(expression, memberName) {
+        const modifierType = this.checker.getTypeAtLocation(expression);
         const relationOfModifierTypeToClass = this.getTypeToClassRelation(modifierType);
         if (relationOfModifierTypeToClass === TypeToClassRelation.Instance &&
             this.constructorScopeDepth === DIRECTLY_INSIDE_CONSTRUCTOR) {
-            this.memberVariableWithConstructorModifications.add(node.name.text);
+            this.memberVariableWithConstructorModifications.add(memberName);
             return;
         }
         if (relationOfModifierTypeToClass === TypeToClassRelation.Instance ||
             relationOfModifierTypeToClass === TypeToClassRelation.ClassAndInstance) {
-            this.memberVariableModifications.add(node.name.text);
+            this.memberVariableModifications.add(memberName);
         }
         if (relationOfModifierTypeToClass === TypeToClassRelation.Class ||
             relationOfModifierTypeToClass === TypeToClassRelation.ClassAndInstance) {
-            this.staticVariableModifications.add(node.name.text);
+            this.staticVariableModifications.add(memberName);
         }
     }
     enterConstructor(node) {
@@ -390,3 +416,24 @@ class ClassScope {
         return this.memberVariableWithConstructorModifications.has(name);
     }
 }
+function getMemberName(name) {
+    if (ts.isIdentifier(name) ||
+        ts.isPrivateIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNoSubstitutionTemplateLiteral(name) ||
+        ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    if (ts.isComputedPropertyName(name)) {
+        const expression = name.expression;
+        if (ts.isNumericLiteral(expression)) {
+            return expression.text;
+        }
+        if (ts.isPropertyAccessExpression(expression) &&
+            ts.isIdentifier(expression.expression) &&
+            expression.expression.text === 'Symbol') {
+            return expression.getText();
+        }
+    }
+    return undefined;
+}

package/dist/rules/strict-void-return.js

@@ -164,11 +164,7 @@ exports.default = util.createRule({
                 if (argNode.type === utils_1.AST_NODE_TYPES.SpreadElement) {
                     continue;
                 }
-                // Check against the contextual type first
-                if (checkExpressionNode(argNode)) {
-                    continue;
-                }
-                // Check against the types from all of the call signatures
+                // Collect the types from all of the call signatures
                 const argExpectedReturnTypes = funcSignatures
                     .map(s => s.parameters[argIdx])
                     .filter(Boolean)
@@ -176,20 +172,44 @@ exports.default = util.createRule({
                     .flatMap(paramType => tsutils.unionConstituents(paramType))
                     .flatMap(paramType => paramType.getCallSignatures())
                     .map(paramSignature => paramSignature.getReturnType());
+                const hasSingleSignature = funcSignatures.length === 1;
+                const allSignaturesReturnVoid = argExpectedReturnTypes.every(type => isVoid(type) ||
+                    // Treat as void even though it might be technically any.
+                    isNullishOrAny(type) ||
+                    // `getTypeOfSymbolAtLocation` returns unresolved type parameters
+                    // (e.g. `T`), even for overloads that match the call.
+                    //
+                    // Since we can't tell whether a generic overload currently matches,
+                    // we treat TypeParameters similar to void.
+                    tsutils.isTypeParameter(type));
+                // Check against the contextual type first, but only when there is a
+                // single signature or when all signatures return void, because
+                // `getContextualType` resolves to the first overload's return type even
+                // though there may be another one that matches the call.
+                if ((hasSingleSignature || allSignaturesReturnVoid) &&
+                    checkExpressionNode(argNode)) {
+                    continue;
+                }
                 if (
                 // At least one return type is void
-                argExpectedReturnTypes.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)) &&
+                argExpectedReturnTypes.some(isVoid) &&
                     // The rest are nullish or any
-                    argExpectedReturnTypes.every(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike |
-                        ts.TypeFlags.Undefined |
-                        ts.TypeFlags.Null |
-                        ts.TypeFlags.Any |
-                        ts.TypeFlags.Never))) {
+                    argExpectedReturnTypes.every(isNullishOrAny)) {
                     // We treat this argument as void even though it might be technically any.
                     reportIfNonVoidFunction(argNode);
                 }
             }
         }
+        function isNullishOrAny(type) {
+            return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike |
+                ts.TypeFlags.Undefined |
+                ts.TypeFlags.Null |
+                ts.TypeFlags.Any |
+                ts.TypeFlags.Never);
+        }
+        function isVoid(type) {
+            return tsutils.isTypeFlagSet(type, ts.TypeFlags.Void);
+        }
         /**
          * Finds errors in an object property.
          *