@typescript-eslint/eslint-plugin 8.67.1-alpha.28 → 8.67.1-alpha.29

package/dist/index.d.ts

@@ -1096,7 +1096,7 @@ declare const _default: {
         'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/strict-boolean-expressions").MessageId, import("./rules/strict-boolean-expressions").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+        'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{
             allowReturnAny?: boolean;
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;

package/dist/raw-plugin.d.ts

@@ -1119,7 +1119,7 @@ declare const _default: {
             'strict-boolean-expressions': TSESLint.RuleModule<import("./rules/strict-boolean-expressions").MessageId, import("./rules/strict-boolean-expressions").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'strict-void-return': TSESLint.RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+            'strict-void-return': TSESLint.RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{
                 allowReturnAny?: boolean;
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;

package/dist/rules/index.d.ts

@@ -421,7 +421,7 @@ declare const rules: {
     'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./strict-boolean-expressions").MessageId, import("./strict-boolean-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+    'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{
         allowReturnAny?: boolean;
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;

package/dist/rules/no-confusing-void-expression.js

@@ -139,15 +139,13 @@ exports.default = (0, util_1.createRule)({
                             if (!canFix(arrowFunction)) {
                                 return null;
                             }
-                            const arrowBody = arrowFunction.body;
-                            const arrowBodyText = context.sourceCode.getText(arrowBody);
-                            const newArrowBodyText = `{ ${arrowBodyText}; }`;
-                            if ((0, util_1.isParenthesized)(arrowBody, context.sourceCode)) {
-                                const bodyOpeningParen = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(arrowBody, util_1.isOpeningParenToken), util_1.NullThrowsReasons.MissingToken('opening parenthesis', 'arrow body'));
-                                const bodyClosingParen = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(arrowBody, util_1.isClosingParenToken), util_1.NullThrowsReasons.MissingToken('closing parenthesis', 'arrow body'));
-                                return fixer.replaceTextRange([bodyOpeningParen.range[0], bodyClosingParen.range[1]], newArrowBodyText);
-                            }
-                            return fixer.replaceText(arrowBody, newArrowBodyText);
+                            const arrowToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(arrowFunction.body, {
+                                filter: token => token.value === '=>',
+                            }), util_1.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body'));
+                            return [
+                                fixer.replaceTextRange([arrowToken.range[1], arrowFunction.body.range[0]], ' { '),
+                                fixer.replaceTextRange([arrowFunction.body.range[1], arrowFunction.range[1]], '; }'),
+                            ];
                         },
                     });
                 }

package/dist/rules/strict-void-return.d.ts

@@ -1,10 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowReturnAny?: boolean;
     }
 ];
-type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn`;
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn` | `suggestAddVoidOp` | `suggestWrapInAsyncIIFE`;
+declare const _default: TSESLint.RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

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

@@ -45,10 +45,13 @@ exports.default = util.createRule({
             description: 'Disallow passing a value-returning function in a position accepting a void function',
             requiresTypeChecking: true,
         },
+        hasSuggestions: true,
         messages: {
             asyncFunc: 'Async function used in a context where a void function is expected.',
             nonVoidFunc: 'Value-returning function used in a context where a void function is expected.',
             nonVoidReturn: 'Value returned in a context where a void return is expected.',
+            suggestAddVoidOp: 'Add a void operator to discard the return value.',
+            suggestWrapInAsyncIIFE: 'Wrap the function body in an async IIFE.',
         },
         schema: [
             {
@@ -324,20 +327,55 @@ exports.default = util.createRule({
             }
             if (funcNode.async) {
                 // The provided function is an async function.
-                // Async functions aren't allowed.
+                if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // This async function is an arrow function shorthand without braces.
+                    return context.report({
+                        loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                        messageId: 'asyncFunc',
+                        suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                            ? // This function has side effects, e.g. `async () => doSomething()`.
+                                // Suggest removing the async keyword and adding a void operator.
+                                [
+                                    {
+                                        messageId: 'suggestAddVoidOp',
+                                        fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                    },
+                                ]
+                            : [],
+                    });
+                }
+                // This async function has a block body.
+                // Suggest wrapping its body in an async IIFE.
                 return context.report({
                     loc: util.getFunctionHeadLoc(funcNode, sourceCode),
-                    messageId: `asyncFunc`,
+                    messageId: 'asyncFunc',
+                    suggest: [
+                        {
+                            messageId: 'suggestWrapInAsyncIIFE',
+                            fix: fixer => wrapInAsyncIIFEFix(fixer, funcNode),
+                        },
+                    ],
                 });
             }
+            // This function is a regular or arrow sync function.
             if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                // The provided function is an arrow function shorthand without braces.
+                // This function is an arrow function shorthand without braces.
                 return context.report({
                     node: funcNode.body,
-                    messageId: `nonVoidReturn`,
+                    messageId: 'nonVoidReturn',
+                    suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                        ? // This function has side effects, e.g. `() => doSomething()`.
+                            // Suggest adding a void operator.
+                            [
+                                {
+                                    messageId: 'suggestAddVoidOp',
+                                    fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                },
+                            ]
+                        : [],
                 });
             }
-            // The function is a regular or arrow function with a block body.
+            // This function is a regular or arrow sync function with a block body.
             // Check return type annotation.
             if (funcNode.returnType != null) {
                 // The provided function has an explicit return type annotation.
@@ -373,6 +411,59 @@ exports.default = util.createRule({
             }
             // No invalid returns found. The function is allowed.
         }
+        /**
+         * Removes the async keyword and replaces the return type with void.
+         */
+        function* makeSyncFuncFix(fixer, funcNode) {
+            if (funcNode.async) {
+                // Remove async keyword
+                const funcHeadNode = funcNode.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                    funcNode.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition
+                    ? funcNode.parent
+                    : funcNode;
+                const asyncToken = util.nullThrows(sourceCode.getFirstToken(funcHeadNode, {
+                    filter: token => token.value === 'async',
+                }), util.NullThrowsReasons.MissingToken('async keyword', funcNode.type));
+                yield fixer.remove(asyncToken);
+            }
+            // Replace return type with void
+            if (funcNode.returnType != null) {
+                yield fixer.replaceText(funcNode.returnType.typeAnnotation, 'void');
+            }
+        }
+        /**
+         * Makes the function sync and adds a void operator to the arrow shorthand body.
+         */
+        function* addVoidToArrowFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Add void operator
+            yield util.getWrappingFixer({
+                node: funcNode.body,
+                sourceCode,
+                wrap: code => `void ${code}`,
+            })(fixer);
+        }
+        /**
+         * Makes the function sync and wraps the body in an inner async IIFE.
+         */
+        function* wrapInAsyncIIFEFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Wrap body in async IIFE.
+            // This preserves the node kind (normal/arrow) for the _outer_ function
+            // and uses an arrow function for the _inner_ function,
+            // so that `this` will always refer to the same value as before.
+            if (funcNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                const arrowToken = util.nullThrows(sourceCode.getTokenBefore(funcNode.body, {
+                    filter: token => token.value === '=>',
+                }), util.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body'));
+                yield fixer.insertTextAfter(arrowToken, ' void (async () =>');
+                yield fixer.insertTextAfter(funcNode, ')()');
+            }
+            else {
+                yield fixer.insertTextBefore(funcNode.body, '{ (async () => ');
+                yield fixer.insertTextAfter(funcNode.body, ')(); }');
+            }
+        }
     },
 });
 //# sourceMappingURL=strict-void-return.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.67.1-alpha.28",
+  "version": "8.67.1-alpha.29",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -47,10 +47,10 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.67.1-alpha.28",
-    "@typescript-eslint/type-utils": "8.67.1-alpha.28",
-    "@typescript-eslint/utils": "8.67.1-alpha.28",
-    "@typescript-eslint/visitor-keys": "8.67.1-alpha.28",
+    "@typescript-eslint/scope-manager": "8.67.1-alpha.29",
+    "@typescript-eslint/type-utils": "8.67.1-alpha.29",
+    "@typescript-eslint/utils": "8.67.1-alpha.29",
+    "@typescript-eslint/visitor-keys": "8.67.1-alpha.29",
     "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.67.1-alpha.28",
-    "@typescript-eslint/rule-tester": "8.67.1-alpha.28",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.67.1-alpha.29",
+    "@typescript-eslint/rule-tester": "8.67.1-alpha.29",
     "@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.67.1-alpha.28",
+    "@typescript-eslint/parser": "^8.67.1-alpha.29",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },