@typescript-eslint/eslint-plugin 8.52.1-alpha.8 → 8.53.0

package/dist/configs/eslintrc/all.d.ts

@@ -148,6 +148,7 @@ declare const _default: {
         'no-return-await': "off";
         '@typescript-eslint/return-await': "error";
         '@typescript-eslint/strict-boolean-expressions': "error";
+        '@typescript-eslint/strict-void-return': "error";
         '@typescript-eslint/switch-exhaustiveness-check': "error";
         '@typescript-eslint/triple-slash-reference': "error";
         '@typescript-eslint/unbound-method': "error";

package/dist/configs/eslintrc/all.js

@@ -155,6 +155,7 @@ module.exports = {
         'no-return-await': 'off',
         '@typescript-eslint/return-await': 'error',
         '@typescript-eslint/strict-boolean-expressions': 'error',
+        '@typescript-eslint/strict-void-return': 'error',
         '@typescript-eslint/switch-exhaustiveness-check': 'error',
         '@typescript-eslint/triple-slash-reference': 'error',
         '@typescript-eslint/unbound-method': 'error',

package/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -62,6 +62,7 @@ declare const _default: {
         '@typescript-eslint/restrict-template-expressions': "off";
         '@typescript-eslint/return-await': "off";
         '@typescript-eslint/strict-boolean-expressions': "off";
+        '@typescript-eslint/strict-void-return': "off";
         '@typescript-eslint/switch-exhaustiveness-check': "off";
         '@typescript-eslint/unbound-method': "off";
         '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";

package/dist/configs/eslintrc/disable-type-checked.js

@@ -65,6 +65,7 @@ module.exports = {
         '@typescript-eslint/restrict-template-expressions': 'off',
         '@typescript-eslint/return-await': 'off',
         '@typescript-eslint/strict-boolean-expressions': 'off',
+        '@typescript-eslint/strict-void-return': 'off',
         '@typescript-eslint/switch-exhaustiveness-check': 'off',
         '@typescript-eslint/unbound-method': 'off',
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',

package/dist/configs/flat/all.js

@@ -168,6 +168,7 @@ exports.default = (plugin, parser) => [
             'no-return-await': 'off',
             '@typescript-eslint/return-await': 'error',
             '@typescript-eslint/strict-boolean-expressions': 'error',
+            '@typescript-eslint/strict-void-return': 'error',
             '@typescript-eslint/switch-exhaustiveness-check': 'error',
             '@typescript-eslint/triple-slash-reference': 'error',
             '@typescript-eslint/unbound-method': 'error',

package/dist/configs/flat/disable-type-checked.js

@@ -70,6 +70,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/restrict-template-expressions': 'off',
         '@typescript-eslint/return-await': 'off',
         '@typescript-eslint/strict-boolean-expressions': 'off',
+        '@typescript-eslint/strict-void-return': 'off',
         '@typescript-eslint/switch-exhaustiveness-check': 'off',
         '@typescript-eslint/unbound-method': 'off',
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',

package/dist/index.d.ts

@@ -150,6 +150,7 @@ declare const _default: {
                 'no-return-await': "off";
                 '@typescript-eslint/return-await': "error";
                 '@typescript-eslint/strict-boolean-expressions': "error";
+                '@typescript-eslint/strict-void-return': "error";
                 '@typescript-eslint/switch-exhaustiveness-check': "error";
                 '@typescript-eslint/triple-slash-reference': "error";
                 '@typescript-eslint/unbound-method': "error";
@@ -228,6 +229,7 @@ declare const _default: {
                 '@typescript-eslint/restrict-template-expressions': "off";
                 '@typescript-eslint/return-await': "off";
                 '@typescript-eslint/strict-boolean-expressions': "off";
+                '@typescript-eslint/strict-void-return': "off";
                 '@typescript-eslint/switch-exhaustiveness-check': "off";
                 '@typescript-eslint/unbound-method': "off";
                 '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";
@@ -1096,6 +1098,11 @@ 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", [{
+            allowReturnAny?: boolean;
+        }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/switch-exhaustiveness-check").MessageIds, import("./rules/switch-exhaustiveness-check").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/dist/raw-plugin.d.ts

@@ -172,6 +172,7 @@ declare const _default: {
                     'no-return-await': "off";
                     '@typescript-eslint/return-await': "error";
                     '@typescript-eslint/strict-boolean-expressions': "error";
+                    '@typescript-eslint/strict-void-return': "error";
                     '@typescript-eslint/switch-exhaustiveness-check': "error";
                     '@typescript-eslint/triple-slash-reference': "error";
                     '@typescript-eslint/unbound-method': "error";
@@ -250,6 +251,7 @@ declare const _default: {
                     '@typescript-eslint/restrict-template-expressions': "off";
                     '@typescript-eslint/return-await': "off";
                     '@typescript-eslint/strict-boolean-expressions': "off";
+                    '@typescript-eslint/strict-void-return': "off";
                     '@typescript-eslint/switch-exhaustiveness-check': "off";
                     '@typescript-eslint/unbound-method': "off";
                     '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";
@@ -1119,6 +1121,11 @@ 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", [{
+                allowReturnAny?: boolean;
+            }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+                name: string;
+            };
             'switch-exhaustiveness-check': TSESLint.RuleModule<import("./rules/switch-exhaustiveness-check").MessageIds, import("./rules/switch-exhaustiveness-check").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };

package/dist/rules/index.d.ts

@@ -419,6 +419,11 @@ 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", [{
+        allowReturnAny?: boolean;
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./switch-exhaustiveness-check").MessageIds, import("./switch-exhaustiveness-check").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };

package/dist/rules/index.js

@@ -129,6 +129,7 @@ const restrict_template_expressions_1 = __importDefault(require("./restrict-temp
 const return_await_1 = __importDefault(require("./return-await"));
 const sort_type_constituents_1 = __importDefault(require("./sort-type-constituents"));
 const strict_boolean_expressions_1 = __importDefault(require("./strict-boolean-expressions"));
+const strict_void_return_1 = __importDefault(require("./strict-void-return"));
 const switch_exhaustiveness_check_1 = __importDefault(require("./switch-exhaustiveness-check"));
 const triple_slash_reference_1 = __importDefault(require("./triple-slash-reference"));
 const typedef_1 = __importDefault(require("./typedef"));
@@ -263,6 +264,7 @@ const rules = {
     'return-await': return_await_1.default,
     'sort-type-constituents': sort_type_constituents_1.default,
     'strict-boolean-expressions': strict_boolean_expressions_1.default,
+    'strict-void-return': strict_void_return_1.default,
     'switch-exhaustiveness-check': switch_exhaustiveness_check_1.default,
     'triple-slash-reference': triple_slash_reference_1.default,
     typedef: typedef_1.default,

package/dist/rules/no-unsafe-call.d.ts

@@ -1,4 +1,4 @@
-export type MessageIds = 'unsafeCall' | 'unsafeCallThis' | 'unsafeNew' | 'unsafeTemplateTag';
+export type MessageIds = 'errorCall' | 'errorCallThis' | 'errorNew' | 'errorTemplateTag' | 'unsafeCall' | 'unsafeCallThis' | 'unsafeNew' | 'unsafeTemplateTag';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

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

@@ -45,13 +45,17 @@ exports.default = (0, util_1.createRule)({
             requiresTypeChecking: true,
         },
         messages: {
-            unsafeCall: 'Unsafe call of a(n) {{type}} typed value.',
+            errorCall: 'Unsafe call of a type that could not be resolved.',
+            errorCallThis: 'Unsafe call of a `this` type that could not be resolved.',
+            errorNew: 'Unsafe construction of a type that could not be resolved.',
+            errorTemplateTag: 'Unsafe use of a template tag whose type could not be resolved.',
+            unsafeCall: 'Unsafe call of {{type}} typed value.',
             unsafeCallThis: [
-                'Unsafe call of a(n) {{type}} typed value. `this` is typed as {{type}}.',
+                'Unsafe call of {{type}} typed value. `this` is typed as {{type}}.',
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
             ].join('\n'),
-            unsafeNew: 'Unsafe construction of a(n) {{type}} typed value.',
-            unsafeTemplateTag: 'Unsafe use of a(n) {{type}} typed template tag.',
+            unsafeNew: 'Unsafe construction of {{type}} typed value.',
+            unsafeTemplateTag: 'Unsafe use of {{type}} typed template tag.',
         },
         schema: [],
     },
@@ -60,7 +64,7 @@ exports.default = (0, util_1.createRule)({
         const services = (0, util_1.getParserServices)(context);
         const compilerOptions = services.program.getCompilerOptions();
         const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
-        function checkCall(node, reportingNode, messageId) {
+        function checkCall(node, reportingNode, unsafeMessageId, errorMessageId) {
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             if ((0, util_1.isTypeAnyType)(type)) {
                 if (!isNoImplicitThis) {
@@ -68,15 +72,16 @@ exports.default = (0, util_1.createRule)({
                     const thisExpression = (0, util_1.getThisExpression)(node);
                     if (thisExpression &&
                         (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-                        messageId = 'unsafeCallThis';
+                        unsafeMessageId = 'unsafeCallThis';
+                        errorMessageId = 'errorCallThis';
                     }
                 }
                 const isErrorType = tsutils.isIntrinsicErrorType(type);
                 context.report({
                     node: reportingNode,
-                    messageId,
+                    messageId: isErrorType ? errorMessageId : unsafeMessageId,
                     data: {
-                        type: isErrorType ? '`error` type' : '`any`',
+                        type: 'an `any`',
                     },
                 });
                 return;
@@ -98,7 +103,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const callSignatures = type.getCallSignatures();
-                if (messageId === 'unsafeNew') {
+                if (unsafeMessageId === 'unsafeNew') {
                     if (callSignatures.some(signature => !tsutils.isIntrinsicVoidType(signature.getReturnType()))) {
                         return;
                     }
@@ -108,9 +113,9 @@ exports.default = (0, util_1.createRule)({
                 }
                 context.report({
                     node: reportingNode,
-                    messageId,
+                    messageId: unsafeMessageId,
                     data: {
-                        type: '`Function`',
+                        type: 'a `Function`',
                     },
                 });
                 return;
@@ -118,13 +123,13 @@ exports.default = (0, util_1.createRule)({
         }
         return {
             'CallExpression > *.callee'(node) {
-                checkCall(node, node, 'unsafeCall');
+                checkCall(node, node, 'unsafeCall', 'errorCall');
             },
             NewExpression(node) {
-                checkCall(node.callee, node, 'unsafeNew');
+                checkCall(node.callee, node, 'unsafeNew', 'errorNew');
             },
             'TaggedTemplateExpression > *.tag'(node) {
-                checkCall(node, node, 'unsafeTemplateTag');
+                checkCall(node, node, 'unsafeTemplateTag', 'errorTemplateTag');
             },
         };
     },

package/dist/rules/no-unsafe-member-access.d.ts

@@ -3,7 +3,7 @@ export type Options = [
         allowOptionalChaining?: boolean;
     }
 ];
-export type MessageIds = 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
+export type MessageIds = 'errorComputedMemberAccess' | 'errorMemberExpression' | 'errorThisMemberExpression' | 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-unsafe-member-access.js

@@ -42,10 +42,6 @@ var State;
     State[State["Safe"] = 2] = "Safe";
     State[State["Chained"] = 3] = "Chained";
 })(State || (State = {}));
-function createDataType(type) {
-    const isErrorType = tsutils.isIntrinsicErrorType(type);
-    return isErrorType ? '`error` typed' : '`any`';
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-member-access',
     meta: {
@@ -56,8 +52,14 @@ exports.default = (0, util_1.createRule)({
             requiresTypeChecking: true,
         },
         messages: {
-            unsafeComputedMemberAccess: 'Computed name {{property}} resolves to an {{type}} value.',
-            unsafeMemberExpression: 'Unsafe member access {{property}} on an {{type}} value.',
+            errorComputedMemberAccess: 'The type of computed name {{property}} cannot be resolved.',
+            errorMemberExpression: 'Unsafe member access {{property}} on a type that cannot be resolved.',
+            errorThisMemberExpression: [
+                'Unsafe member access {{property}}. The type of `this` cannot be resolved.',
+                'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+            ].join('\n'),
+            unsafeComputedMemberAccess: 'Computed name {{property}} resolves to an `any` value.',
+            unsafeMemberExpression: 'Unsafe member access {{property}} on an `any` value.',
             unsafeThisMemberExpression: [
                 'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
@@ -116,20 +118,28 @@ exports.default = (0, util_1.createRule)({
             stateCache.set(node, state);
             if (state === State.Unsafe) {
                 const propertyName = context.sourceCode.getText(node.property);
-                let messageId = 'unsafeMemberExpression';
+                let messageId;
                 if (!isNoImplicitThis) {
                     // `this.foo` or `this.foo[bar]`
                     const thisExpression = (0, util_1.getThisExpression)(node);
-                    if (thisExpression &&
-                        (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-                        messageId = 'unsafeThisMemberExpression';
+                    if (thisExpression) {
+                        const thisType = (0, util_1.getConstrainedTypeAtLocation)(services, thisExpression);
+                        if ((0, util_1.isTypeAnyType)(thisType)) {
+                            messageId = tsutils.isIntrinsicErrorType(thisType)
+                                ? 'errorThisMemberExpression'
+                                : 'unsafeThisMemberExpression';
+                        }
                     }
                 }
+                if (!messageId) {
+                    messageId = tsutils.isIntrinsicErrorType(type)
+                        ? 'errorMemberExpression'
+                        : 'unsafeMemberExpression';
+                }
                 context.report({
                     node: node.property,
                     messageId,
                     data: {
-                        type: createDataType(type),
                         property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
                     },
                 });
@@ -159,9 +169,10 @@ exports.default = (0, util_1.createRule)({
                     const propertyName = context.sourceCode.getText(node);
                     context.report({
                         node,
-                        messageId: 'unsafeComputedMemberAccess',
+                        messageId: tsutils.isIntrinsicErrorType(type)
+                            ? 'errorComputedMemberAccess'
+                            : 'unsafeComputedMemberAccess',
                         data: {
-                            type: createDataType(type),
                             property: `[${propertyName}]`,
                         },
                     });

package/dist/rules/no-unused-vars.d.ts

@@ -1,5 +1,5 @@
 import { TSESLint } from '@typescript-eslint/utils';
-export type MessageIds = 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType';
+export type MessageIds = 'removeUnusedImportDeclaration' | 'removeUnusedVar' | 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType';
 export type Options = [
     'all' | 'local' | {
         args?: 'after-used' | 'all' | 'none';
@@ -7,6 +7,9 @@ export type Options = [
         caughtErrors?: 'all' | 'none';
         caughtErrorsIgnorePattern?: string;
         destructuredArrayIgnorePattern?: string;
+        enableAutofixRemoval?: {
+            imports?: boolean;
+        };
         ignoreClassWithStaticInitBlock?: boolean;
         ignoreRestSiblings?: boolean;
         ignoreUsingDeclarations?: boolean;