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

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

@@ -0,0 +1,356 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'strict-void-return',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow passing a value-returning function in a position accepting a void function',
+            requiresTypeChecking: 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.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowReturnAny: {
+                        type: 'boolean',
+                        description: 'Whether to allow functions returning `any` to be used in place expecting a `void` function.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowReturnAny: false,
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.sourceCode;
+        const parserServices = util.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            ArrayExpression: (node) => {
+                for (const elemNode of node.elements) {
+                    if (elemNode != null &&
+                        elemNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                        checkExpressionNode(elemNode);
+                    }
+                }
+            },
+            ArrowFunctionExpression: (node) => {
+                if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    checkExpressionNode(node.body);
+                }
+            },
+            AssignmentExpression: (node) => {
+                checkExpressionNode(node.right); // should ignore operators like `+=` or `-=` automatically
+            },
+            'CallExpression, NewExpression': checkFunctionCallNode,
+            JSXAttribute: (node) => {
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type !== utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
+                    checkExpressionNode(node.value.expression);
+                }
+            },
+            MethodDefinition: checkClassMethodNode,
+            ObjectExpression: (node) => {
+                for (const propNode of node.properties) {
+                    if (propNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                        checkObjectPropertyNode(propNode);
+                    }
+                }
+            },
+            PropertyDefinition: checkClassPropertyNode,
+            ReturnStatement: (node) => {
+                if (node.argument != null) {
+                    checkExpressionNode(node.argument);
+                }
+            },
+            VariableDeclarator: (node) => {
+                if (node.init != null) {
+                    checkExpressionNode(node.init);
+                }
+            },
+        };
+        function isVoidReturningFunctionType(type) {
+            const returnTypes = tsutils
+                .getCallSignaturesOfType(type)
+                .flatMap(signature => tsutils.unionConstituents(signature.getReturnType()));
+            return (returnTypes.length > 0 &&
+                returnTypes.every(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)));
+        }
+        /**
+         * Finds errors in any expression node.
+         *
+         * Compares the type of the node against the contextual (expected) type.
+         *
+         * @returns `true` if the expected type was void function.
+         */
+        function checkExpressionNode(node) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const expectedType = checker.getContextualType(tsNode);
+            if (expectedType != null && isVoidReturningFunctionType(expectedType)) {
+                reportIfNonVoidFunction(node);
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Finds errors in function calls.
+         *
+         * When checking arguments, we also manually figure out the argument types
+         * by iterating over all the function signatures.
+         * Thanks to this, we can find arguments like `(() => void) | (() => any)`
+         * and treat them as void too.
+         * This is done to also support checking functions like `addEventListener`
+         * which have overloads where one callback returns any.
+         *
+         * Implementation mostly based on no-misused-promises,
+         * which does this to find `(() => void) | (() => NotThenable)`
+         * and report them too.
+         */
+        function checkFunctionCallNode(callNode) {
+            const callTsNode = parserServices.esTreeNodeToTSNodeMap.get(callNode);
+            const funcType = checker.getTypeAtLocation(callTsNode.expression);
+            const funcSignatures = tsutils
+                .unionConstituents(funcType)
+                .flatMap(type => ts.isCallExpression(callTsNode)
+                ? type.getCallSignatures()
+                : type.getConstructSignatures());
+            for (const [argIdx, argNode] of callNode.arguments.entries()) {
+                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
+                const argExpectedReturnTypes = funcSignatures
+                    .map(s => s.parameters[argIdx])
+                    .filter(Boolean)
+                    .map(param => checker.getTypeOfSymbolAtLocation(param, callTsNode.expression))
+                    .flatMap(paramType => tsutils.unionConstituents(paramType))
+                    .flatMap(paramType => paramType.getCallSignatures())
+                    .map(paramSignature => paramSignature.getReturnType());
+                if (
+                // At least one return type is void
+                argExpectedReturnTypes.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)) &&
+                    // 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))) {
+                    // We treat this argument as void even though it might be technically any.
+                    reportIfNonVoidFunction(argNode);
+                }
+            }
+        }
+        /**
+         * Finds errors in an object property.
+         *
+         * Object properties require different logic
+         * when the property is a method shorthand.
+         */
+        function checkObjectPropertyNode(propNode) {
+            const valueNode = propNode.value;
+            const propTsNode = parserServices.esTreeNodeToTSNodeMap.get(propNode);
+            if (propTsNode.kind === ts.SyntaxKind.MethodDeclaration) {
+                // Object property is a method shorthand.
+                if (propTsNode.name.kind === ts.SyntaxKind.ComputedPropertyName) {
+                    // Don't check object methods with computed name.
+                    return;
+                }
+                const objTsNode = propTsNode.parent;
+                const objType = checker.getContextualType(objTsNode);
+                if (objType == null) {
+                    // Expected object type is unknown.
+                    return;
+                }
+                const propSymbol = checker.getPropertyOfType(objType, propTsNode.name.text);
+                if (propSymbol == null) {
+                    // Expected object type is known, but it doesn't have this method.
+                    return;
+                }
+                const propExpectedType = checker.getTypeOfSymbolAtLocation(propSymbol, propTsNode);
+                if (isVoidReturningFunctionType(propExpectedType)) {
+                    reportIfNonVoidFunction(valueNode);
+                }
+                return;
+            }
+            // Object property is a regular property.
+            checkExpressionNode(valueNode);
+        }
+        /**
+         * Finds errors in a class property.
+         *
+         * In addition to the regular check against the contextual type,
+         * we also check against the base class property (when the class extends another class)
+         * and the implemented interfaces (when the class implements an interface).
+         */
+        function checkClassPropertyNode(propNode) {
+            if (propNode.value == null) {
+                return;
+            }
+            // Check in comparison to the base types.
+            for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, propNode)) {
+                if (isVoidReturningFunctionType(baseMemberType)) {
+                    reportIfNonVoidFunction(propNode.value);
+                    return; // Report at most one error.
+                }
+            }
+            // Check in comparison to the contextual type.
+            checkExpressionNode(propNode.value);
+        }
+        /**
+         * Finds errors in a class method.
+         *
+         * We check against the base class method (when the class extends another class)
+         * and the implemented interfaces (when the class implements an interface).
+         */
+        function checkClassMethodNode(methodNode) {
+            if (methodNode.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+                return;
+            }
+            // Check in comparison to the base types.
+            for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, methodNode)) {
+                if (isVoidReturningFunctionType(baseMemberType)) {
+                    reportIfNonVoidFunction(methodNode.value);
+                    return; // Report at most one error.
+                }
+            }
+        }
+        /**
+         * Reports an error if the provided node is not allowed in a void function context.
+         */
+        function reportIfNonVoidFunction(funcNode) {
+            const allowedReturnType = ts.TypeFlags.Void |
+                ts.TypeFlags.Never |
+                ts.TypeFlags.Undefined |
+                (options.allowReturnAny ? ts.TypeFlags.Any : 0);
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(funcNode);
+            const actualType = checker.getApparentType(checker.getTypeAtLocation(tsNode));
+            if (tsutils
+                .getCallSignaturesOfType(actualType)
+                .map(signature => signature.getReturnType())
+                .flatMap(returnType => tsutils.unionConstituents(returnType))
+                .every(type => tsutils.isTypeFlagSet(type, allowedReturnType))) {
+                // The function is already void.
+                return;
+            }
+            if (funcNode.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                funcNode.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                // The provided function is not a function literal.
+                // Report a generic error.
+                return context.report({
+                    node: funcNode,
+                    messageId: `nonVoidFunc`,
+                });
+            }
+            // The provided function is a function literal.
+            if (funcNode.generator) {
+                // The provided function is a generator function.
+                // Generator functions are not allowed.
+                return context.report({
+                    loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                    messageId: `nonVoidFunc`,
+                });
+            }
+            if (funcNode.async) {
+                // The provided function is an async function.
+                // Async functions aren't allowed.
+                return context.report({
+                    loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                    messageId: `asyncFunc`,
+                });
+            }
+            if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                // The provided function is an arrow function shorthand without braces.
+                return context.report({
+                    node: funcNode.body,
+                    messageId: `nonVoidReturn`,
+                });
+            }
+            // The function is a regular or arrow function with a block body.
+            // Check return type annotation.
+            if (funcNode.returnType != null) {
+                // The provided function has an explicit return type annotation.
+                const typeAnnotationNode = funcNode.returnType.typeAnnotation;
+                if (typeAnnotationNode.type !== utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+                    // The explicit return type is not `void`.
+                    return context.report({
+                        node: typeAnnotationNode,
+                        messageId: `nonVoidFunc`,
+                    });
+                }
+            }
+            // Iterate over all function's return statements.
+            for (const statement of util.walkStatements(funcNode.body.body)) {
+                if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement ||
+                    statement.argument == null) {
+                    // We only care about return statements with a value.
+                    continue;
+                }
+                const returnType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(statement.argument));
+                if (tsutils.isTypeFlagSet(returnType, allowedReturnType)) {
+                    // Only visit return statements with invalid type.
+                    continue;
+                }
+                // This return statement causes the non-void return type.
+                const returnKeyword = util.nullThrows(sourceCode.getFirstToken(statement, {
+                    filter: token => token.value === 'return',
+                }), util.NullThrowsReasons.MissingToken('return keyword', statement.type));
+                context.report({
+                    node: returnKeyword,
+                    messageId: `nonVoidReturn`,
+                });
+            }
+            // No invalid returns found. The function is allowed.
+        }
+    },
+});

package/dist/util/getBaseTypesOfClassMember.d.ts

@@ -0,0 +1,11 @@
+import type { TSESTree, ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+/**
+ * Given a member of a class which extends another class or implements an interface,
+ * yields the corresponding member type for each of the base class/interfaces.
+ */
+export declare function getBaseTypesOfClassMember(services: ParserServicesWithTypeInformation, memberNode: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): Generator<{
+    baseType: ts.Type;
+    baseMemberType: ts.Type;
+    heritageToken: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword;
+}>;

package/dist/util/getBaseTypesOfClassMember.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseTypesOfClassMember = getBaseTypesOfClassMember;
+/**
+ * Given a member of a class which extends another class or implements an interface,
+ * yields the corresponding member type for each of the base class/interfaces.
+ */
+function* getBaseTypesOfClassMember(services, memberNode) {
+    const memberTsNode = services.esTreeNodeToTSNodeMap.get(memberNode);
+    if (memberTsNode.name == null) {
+        return;
+    }
+    const checker = services.program.getTypeChecker();
+    const memberSymbol = checker.getSymbolAtLocation(memberTsNode.name);
+    if (memberSymbol == null) {
+        return;
+    }
+    const classNode = memberTsNode.parent;
+    for (const clauseNode of classNode.heritageClauses ?? []) {
+        for (const baseTypeNode of clauseNode.types) {
+            const baseType = checker.getTypeAtLocation(baseTypeNode);
+            const baseMemberSymbol = checker.getPropertyOfType(baseType, memberSymbol.name);
+            if (baseMemberSymbol == null) {
+                continue;
+            }
+            const baseMemberType = checker.getTypeOfSymbolAtLocation(baseMemberSymbol, memberTsNode);
+            const heritageToken = clauseNode.token;
+            yield { baseMemberType, baseType, heritageToken };
+        }
+    }
+}

package/dist/util/index.d.ts

@@ -3,6 +3,7 @@ export * from './astUtils';
 export * from './baseTypeUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
+export * from './getBaseTypesOfClassMember';
 export * from './getFixOrSuggest';
 export * from './getFunctionHeadLoc';
 export * from './getOperatorPrecedence';
@@ -29,6 +30,7 @@ export * from './getValueOfLiteralType';
 export * from './isHigherPrecedenceThanAwait';
 export * from './skipChainExpression';
 export * from './truthinessUtils';
+export * from './walkStatements';
 export * from '@typescript-eslint/type-utils';
 export declare const applyDefault: typeof ESLintUtils.applyDefault, deepMerge: typeof ESLintUtils.deepMerge, getParserServices: typeof ESLintUtils.getParserServices, isObjectNotArray: typeof ESLintUtils.isObjectNotArray, nullThrows: typeof ESLintUtils.nullThrows, NullThrowsReasons: {
     readonly MissingParent: "Expected node to have a parent.";

package/dist/util/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./astUtils"), exports);
 __exportStar(require("./baseTypeUtils"), exports);
 __exportStar(require("./collectUnusedVariables"), exports);
 __exportStar(require("./createRule"), exports);
+__exportStar(require("./getBaseTypesOfClassMember"), exports);
 __exportStar(require("./getFixOrSuggest"), exports);
 __exportStar(require("./getFunctionHeadLoc"), exports);
 __exportStar(require("./getOperatorPrecedence"), exports);
@@ -46,6 +47,7 @@ __exportStar(require("./getValueOfLiteralType"), exports);
 __exportStar(require("./isHigherPrecedenceThanAwait"), exports);
 __exportStar(require("./skipChainExpression"), exports);
 __exportStar(require("./truthinessUtils"), exports);
+__exportStar(require("./walkStatements"), exports);
 // this is done for convenience - saves migrating all of the old rules
 __exportStar(require("@typescript-eslint/type-utils"), exports);
 exports.applyDefault = utils_1.ESLintUtils.applyDefault, exports.deepMerge = utils_1.ESLintUtils.deepMerge, exports.getParserServices = utils_1.ESLintUtils.getParserServices, exports.isObjectNotArray = utils_1.ESLintUtils.isObjectNotArray, exports.nullThrows = utils_1.ESLintUtils.nullThrows, exports.NullThrowsReasons = utils_1.ESLintUtils.NullThrowsReasons;

package/dist/util/walkStatements.d.ts

@@ -0,0 +1,7 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Yields all statement nodes in a block, including nested blocks.
+ *
+ * You can use it to find all return statements in a function body.
+ */
+export declare function walkStatements(body: readonly TSESTree.Statement[]): Generator<TSESTree.Statement>;

package/dist/util/walkStatements.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkStatements = walkStatements;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Yields all statement nodes in a block, including nested blocks.
+ *
+ * You can use it to find all return statements in a function body.
+ */
+function* walkStatements(body) {
+    for (const statement of body) {
+        switch (statement.type) {
+            case utils_1.AST_NODE_TYPES.BlockStatement: {
+                yield* walkStatements(statement.body);
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.SwitchStatement: {
+                for (const switchCase of statement.cases) {
+                    yield* walkStatements(switchCase.consequent);
+                }
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.IfStatement: {
+                yield* walkStatements([statement.consequent]);
+                if (statement.alternate) {
+                    yield* walkStatements([statement.alternate]);
+                }
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.WhileStatement:
+            case utils_1.AST_NODE_TYPES.DoWhileStatement:
+            case utils_1.AST_NODE_TYPES.ForStatement:
+            case utils_1.AST_NODE_TYPES.ForInStatement:
+            case utils_1.AST_NODE_TYPES.ForOfStatement:
+            case utils_1.AST_NODE_TYPES.WithStatement:
+            case utils_1.AST_NODE_TYPES.LabeledStatement: {
+                yield* walkStatements([statement.body]);
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.TryStatement: {
+                yield* walkStatements([statement.block]);
+                if (statement.handler) {
+                    yield* walkStatements([statement.handler.body]);
+                }
+                if (statement.finalizer) {
+                    yield* walkStatements([statement.finalizer]);
+                }
+                continue;
+            }
+            default: {
+                yield statement;
+                continue;
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.52.1-alpha.8",
+  "version": "8.53.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.52.1-alpha.8",
-    "@typescript-eslint/type-utils": "8.52.1-alpha.8",
-    "@typescript-eslint/utils": "8.52.1-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.52.1-alpha.8",
+    "@typescript-eslint/scope-manager": "8.53.0",
+    "@typescript-eslint/type-utils": "8.53.0",
+    "@typescript-eslint/utils": "8.53.0",
+    "@typescript-eslint/visitor-keys": "8.53.0",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.4.0"
@@ -70,8 +70,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.52.1-alpha.8",
-    "@typescript-eslint/rule-tester": "8.52.1-alpha.8",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.53.0",
+    "@typescript-eslint/rule-tester": "8.53.0",
     "@vitest/coverage-v8": "^3.2.4",
     "ajv": "^6.12.6",
     "eslint": "*",
@@ -90,7 +90,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.52.1-alpha.8",
+    "@typescript-eslint/parser": "^8.53.0",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },