@typescript-eslint/eslint-plugin 8.70.1-alpha.9 → 8.70.2-alpha.0

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-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-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

@@ -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-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: [
             {
@@ -286,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) {
@@ -294,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;
@@ -308,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/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": "@typescript-eslint/eslint-plugin",
-  "version": "8.70.1-alpha.9",
+  "version": "8.70.2-alpha.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -47,10 +47,10 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.70.1-alpha.9",
-    "@typescript-eslint/type-utils": "8.70.1-alpha.9",
-    "@typescript-eslint/utils": "8.70.1-alpha.9",
-    "@typescript-eslint/visitor-keys": "8.70.1-alpha.9",
+    "@typescript-eslint/scope-manager": "8.70.2-alpha.0",
+    "@typescript-eslint/type-utils": "8.70.2-alpha.0",
+    "@typescript-eslint/utils": "8.70.2-alpha.0",
+    "@typescript-eslint/visitor-keys": "8.70.2-alpha.0",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
@@ -60,8 +60,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.1-alpha.9",
-    "@typescript-eslint/rule-tester": "8.70.1-alpha.9",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.2-alpha.0",
+    "@typescript-eslint/rule-tester": "8.70.2-alpha.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -81,7 +81,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.70.1-alpha.9",
+    "@typescript-eslint/parser": "^8.70.2-alpha.0",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },

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;