@flint.fyi/ts 0.14.3 → 0.14.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @flint/ts
 
+## 0.14.5
+
+### Patch Changes
+
+- 7e21021: fix(ts): [chainedAssignments] allow non-assignment right-side operators
+
+## 0.14.4
+
+### Patch Changes
+
+- 158b542: expose \`program\` in TS rules context
+- Updated dependencies [3d19082]
+- Updated dependencies [a3f9043]
+  - @flint.fyi/core@0.15.1
+  - @flint.fyi/rule-tester@0.14.2
+
 ## 0.14.3
 
 ### Patch Changes

package/lib/createTypeScriptFileFromProgram.js

@@ -33,9 +33,13 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
         async runRule(rule, options) {
             const reports = [];
             const context = {
+                program,
                 report: (report) => {
                     reports.push({
                         ...report,
+                        fix: report.fix && !Array.isArray(report.fix)
+                            ? [report.fix]
+                            : report.fix,
                         message: rule.messages[report.message],
                         range: normalizeRange(report.range, sourceFile),
                     });
@@ -52,7 +56,7 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
                 visitors[NodeSyntaxKinds[node.kind]]?.(node);
                 node.forEachChild(visit);
             };
-            sourceFile.forEachChild(visit);
+            visit(sourceFile);
             return reports;
         },
     };

package/lib/index.d.ts

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/lib/index.js

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/lib/language.d.ts

@@ -1,6 +1,7 @@
 import * as ts from "typescript";
 import { TSNodesByName } from "./nodes.js";
 export interface TypeScriptServices {
+    program: ts.Program;
     sourceFile: ts.SourceFile;
     typeChecker: ts.TypeChecker;
 }

package/lib/plugin.d.ts

@@ -1,4 +1,8 @@
-export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
+export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, "all", [import("@flint.fyi/core").Rule<{
+    readonly description: "Reports returning a value with type `any` from a function.";
+    readonly id: "anyReturns";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using async functions as Promise executor functions.";
     readonly id: "asyncPromiseExecutors";
     readonly preset: "logical";
@@ -7,6 +11,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "caseDeclarations";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch statements with duplicate case clause test expressions.";
+    readonly id: "caseDuplicates";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateCase", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
     readonly id: "chainedAssignments";
     readonly preset: "stylistic";
@@ -39,6 +47,14 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "duplicateArguments";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateParam", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
+    readonly id: "elseIfDuplicates";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateCondition", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using empty destructuring patterns that destructure no values.";
     readonly id: "emptyDestructures";
     readonly preset: "logical";
@@ -51,6 +67,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "exceptionAssignments";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noExAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports for loops with counter variables that move in the wrong direction.";
+    readonly id: "forDirections";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "wrongDirection", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports iterating over an array with a for-in loop.";
     readonly id: "forInArrays";
     readonly preset: "logical";
@@ -59,6 +79,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "functionAssignments";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noFunctionAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the Function constructor to create functions from strings.";
+    readonly id: "functionNewCalls";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noFunctionConstructor", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports generator functions that do not yield values.";
     readonly id: "generatorFunctionYields";
     readonly preset: "logical";
@@ -90,6 +114,14 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "newNativeNonConstructors";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noNewNonConstructor", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
+    readonly id: "nonOctalDecimalEscapes";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedEscape", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
+    readonly id: "numericLiteralParsing";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
     readonly id: "objectProto";
     readonly preset: "untyped";
@@ -106,6 +138,22 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "returnAssignments";
     readonly preset: "stylistic";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noReturnAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports self-assignments which have no effect and are likely errors.";
+    readonly id: "selfAssignments";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "selfAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparing a value to itself.";
+    readonly id: "selfComparisons";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSelfComparison", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the comma operator in expressions.";
+    readonly id: "sequences";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSequences", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "shadowedRestrictedName", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
     readonly preset: "logical";
@@ -114,6 +162,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "symbolDescriptions";
     readonly preset: "stylistic";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingDescription", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports typeof expressions that compare impossible string literals.";
+    readonly id: "typeofComparisons";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "invalidValue", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports variables that are declared but never assigned a value.";
     readonly id: "unassignedVariables";
     readonly preset: "untyped";
@@ -126,10 +178,18 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "unicodeBOMs";
     readonly preset: "stylistic";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone block statements that don't create a meaningful scope.";
+    readonly id: "unnecessaryBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
     readonly id: "unnecessaryCatches";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryCatch", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
+    readonly id: "unnecessaryConcatenation";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryConcatenation", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
     readonly id: "unsafeNegations";
     readonly preset: "untyped";

package/lib/plugin.js

@@ -1,6 +1,8 @@
 import { createPlugin } from "@flint.fyi/core";
+import anyReturns from "./rules/anyReturns.js";
 import asyncPromiseExecutors from "./rules/asyncPromiseExecutors.js";
 import caseDeclarations from "./rules/caseDeclarations.js";
+import caseDuplicates from "./rules/caseDuplicates.js";
 import chainedAssignments from "./rules/chainedAssignments.js";
 import classAssignments from "./rules/classAssignments.js";
 import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
@@ -9,11 +11,15 @@ import constructorReturns from "./rules/constructorReturns.js";
 import debuggerStatements from "./rules/debuggerStatements.js";
 import defaultCaseLast from "./rules/defaultCaseLast.js";
 import duplicateArguments from "./rules/duplicateArguments.js";
+import elseIfDuplicates from "./rules/elseIfDuplicates.js";
+import emptyBlocks from "./rules/emptyBlocks.js";
 import emptyDestructures from "./rules/emptyDestructures.js";
 import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
 import exceptionAssignments from "./rules/exceptionAssignments.js";
+import forDirections from "./rules/forDirections.js";
 import forInArrays from "./rules/forInArrays.js";
 import functionAssignments from "./rules/functionAssignments.js";
+import functionNewCalls from "./rules/functionNewCalls.js";
 import generatorFunctionYields from "./rules/generatorFunctionYields.js";
 import globalAssignments from "./rules/globalAssignments.js";
 import globalObjectCalls from "./rules/globalObjectCalls.js";
@@ -21,16 +27,25 @@ import namespaceDeclarations from "./rules/namespaceDeclarations.js";
 import negativeZeroComparisons from "./rules/negativeZeroComparisons.js";
 import newExpressions from "./rules/newExpressions.js";
 import newNativeNonConstructors from "./rules/newNativeNonConstructors.js";
+import nonOctalDecimalEscapes from "./rules/nonOctalDecimalEscapes.js";
+import numericLiteralParsing from "./rules/numericLiteralParsing.js";
 import objectProto from "./rules/objectProto.js";
 import octalEscapes from "./rules/octalEscapes.js";
 import octalNumbers from "./rules/octalNumbers.js";
 import returnAssignments from "./rules/returnAssignments.js";
+import selfAssignments from "./rules/selfAssignments.js";
+import selfComparisons from "./rules/selfComparisons.js";
+import sequences from "./rules/sequences.js";
+import shadowedRestrictedNames from "./rules/shadowedRestrictedNames.js";
 import sparseArrays from "./rules/sparseArrays.js";
 import symbolDescriptions from "./rules/symbolDescriptions.js";
+import typeofComparisons from "./rules/typeofComparisons.js";
 import unassignedVariables from "./rules/unassignedVariables.js";
 import undefinedVariables from "./rules/undefinedVariables.js";
 import unicodeBOMs from "./rules/unicodeBOMs.js";
+import unnecessaryBlocks from "./rules/unnecessaryBlocks.js";
 import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
 import unsafeNegations from "./rules/unsafeNegations.js";
 import variableDeletions from "./rules/variableDeletions.js";
 import voidOperator from "./rules/voidOperator.js";
@@ -40,8 +55,10 @@ export const ts = createPlugin({
     },
     name: "ts",
     rules: [
+        anyReturns,
         asyncPromiseExecutors,
         caseDeclarations,
+        caseDuplicates,
         chainedAssignments,
         classAssignments,
         consecutiveNonNullAssertions,
@@ -50,11 +67,15 @@ export const ts = createPlugin({
         debuggerStatements,
         defaultCaseLast,
         duplicateArguments,
+        elseIfDuplicates,
+        emptyBlocks,
         emptyDestructures,
         emptyStaticBlocks,
         exceptionAssignments,
+        forDirections,
         forInArrays,
         functionAssignments,
+        functionNewCalls,
         generatorFunctionYields,
         globalAssignments,
         globalObjectCalls,
@@ -62,16 +83,25 @@ export const ts = createPlugin({
         negativeZeroComparisons,
         newExpressions,
         newNativeNonConstructors,
+        nonOctalDecimalEscapes,
+        numericLiteralParsing,
         objectProto,
         octalEscapes,
         octalNumbers,
         returnAssignments,
+        selfAssignments,
+        selfComparisons,
+        sequences,
+        shadowedRestrictedNames,
         sparseArrays,
         symbolDescriptions,
+        typeofComparisons,
         unassignedVariables,
         undefinedVariables,
         unicodeBOMs,
+        unnecessaryBlocks,
         unnecessaryCatches,
+        unnecessaryConcatenation,
         unsafeNegations,
         variableDeletions,
         voidOperator,

package/lib/rules/anyReturns.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports returning a value with type `any` from a function.";
+    readonly id: "anyReturns";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>;
+export default _default;

package/lib/rules/anyReturns.js

@@ -0,0 +1,187 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { AnyType, discriminateAnyType } from "./utils/discriminateAnyType.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getThisExpression } from "./utils/getThisExpression.js";
+import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports returning a value with type `any` from a function.",
+        id: "anyReturns",
+        preset: "logical",
+    },
+    messages: {
+        unsafeReturn: {
+            primary: "Unsafe return of a value of type {{ type }}.",
+            secondary: [
+                "Returning a value of type `any` or a similar unsafe type defeats TypeScript's type safety guarantees.",
+                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
+            ],
+            suggestions: [
+                "Ensure the returned value has a well-defined, specific type.",
+            ],
+        },
+        unsafeReturnAssignment: {
+            primary: "Unsafe return of type `{{ sender }}` from function with return type `{{ receiver }}`.",
+            secondary: [
+                "The function's declared return type does not safely accept the value being returned.",
+                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
+            ],
+            suggestions: [
+                "Adjust the return type of the function to match the returned value, if appropriate.",
+                "Otherwise, refine the returned value to ensure it matches the expected return type.",
+            ],
+        },
+        unsafeReturnThis: {
+            primary: "Unsafe return of a value of type `{{ type }}`. `this` is typed as `any`.",
+            secondary: [
+                "Returning `this` when it is implicitly typed as `any` introduces type-unsafe behavior.",
+                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
+            ],
+            suggestions: [
+                "Enable the `noImplicitThis` compiler option to enforce explicit `this` types.",
+                "Add an explicit `this` parameter to the function to clarify its type.",
+            ],
+        },
+    },
+    setup(context) {
+        const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(context.program.getCompilerOptions(), "noImplicitThis");
+        function checkReturn(returnNode, reportingNode) {
+            const type = context.typeChecker.getTypeAtLocation(returnNode);
+            const anyType = discriminateAnyType(type, context.typeChecker, context.program, returnNode);
+            const functionNode = ts.findAncestor(returnNode, 
+            // TODO: I believe isFunctionLikeDeclaration was incorrectly marked
+            // as deprecated in https://github.com/JoshuaKGoldberg/ts-api-utils/pull/124
+            // It says "With TypeScript v5, in favor of typescript's `isFunctionLike`."
+            // However, isFunctionLike also checks for signature-like nodes,
+            // whereas isFunctionLikeDeclaration checks only for function-like nodes.
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            tsutils.isFunctionLikeDeclaration);
+            if (!functionNode) {
+                return;
+            }
+            // function has an explicit return type, so ensure it's a safe return
+            const returnNodeType = getConstrainedTypeAtLocation(returnNode, context.typeChecker);
+            // function expressions will not have their return type modified based on receiver typing
+            // so we have to use the contextual typing in these cases, i.e.
+            // const foo1: () => Set<string> = () => new Set<any>();
+            // the return type of the arrow function is Set<any> even though the variable is typed as Set<string>
+            let functionType = ts.isFunctionExpression(functionNode) ||
+                ts.isArrowFunction(functionNode)
+                ? context.typeChecker.getContextualType(functionNode)
+                : context.typeChecker.getTypeAtLocation(functionNode);
+            functionType ??= context.typeChecker.getTypeAtLocation(functionNode);
+            const callSignatures = tsutils.getCallSignaturesOfType(functionType);
+            // If there is an explicit type annotation *and* that type matches the actual
+            // function return type, we shouldn't complain (it's intentional, even if unsafe)
+            if (functionNode.type) {
+                for (const signature of callSignatures) {
+                    const signatureReturnType = signature.getReturnType();
+                    if (returnNodeType === signatureReturnType ||
+                        tsutils.isTypeFlagSet(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+                        return;
+                    }
+                    if (tsutils.includesModifier(functionNode.modifiers, ts.SyntaxKind.AsyncKeyword)) {
+                        const awaitedSignatureReturnType = context.typeChecker.getAwaitedType(signatureReturnType);
+                        const awaitedReturnNodeType = context.typeChecker.getAwaitedType(returnNodeType);
+                        if (awaitedReturnNodeType === awaitedSignatureReturnType ||
+                            (awaitedSignatureReturnType &&
+                                tsutils.isTypeFlagSet(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
+                            return;
+                        }
+                    }
+                }
+            }
+            if (anyType !== AnyType.Safe) {
+                // Allow cases when the declared return type of the function is either unknown or unknown[]
+                // and the function is returning any or any[].
+                for (const signature of callSignatures) {
+                    const functionReturnType = signature.getReturnType();
+                    if (anyType === AnyType.Any &&
+                        tsutils.isTypeFlagSet(functionReturnType, ts.TypeFlags.Unknown)) {
+                        return;
+                    }
+                    if (anyType === AnyType.AnyArray &&
+                        context.typeChecker.isArrayType(functionReturnType) &&
+                        tsutils.isTypeFlagSet(context.typeChecker.getTypeArguments(functionReturnType)[0], ts.TypeFlags.Unknown)) {
+                        return;
+                    }
+                    const awaitedType = context.typeChecker.getAwaitedType(functionReturnType);
+                    if (awaitedType &&
+                        anyType === AnyType.PromiseAny &&
+                        tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)) {
+                        return;
+                    }
+                }
+                if (anyType === AnyType.PromiseAny &&
+                    !tsutils.includesModifier(functionNode.modifiers, ts.SyntaxKind.AsyncKeyword)) {
+                    return;
+                }
+                let message = "unsafeReturn";
+                const isErrorType = tsutils.isIntrinsicErrorType(returnNodeType);
+                if (!isNoImplicitThis) {
+                    // `return this`
+                    const thisExpression = getThisExpression(returnNode);
+                    if (thisExpression &&
+                        tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, context.typeChecker), ts.TypeFlags.Any)) {
+                        message = "unsafeReturnThis";
+                    }
+                }
+                // If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
+                context.report({
+                    data: {
+                        type: isErrorType
+                            ? "error"
+                            : anyType === AnyType.Any
+                                ? "`any`"
+                                : anyType === AnyType.PromiseAny
+                                    ? "`Promise<any>`"
+                                    : "`any[]`",
+                    },
+                    message,
+                    range: {
+                        begin: reportingNode.getStart(),
+                        end: reportingNode.getEnd(),
+                    },
+                });
+                return;
+            }
+            const signature = functionType.getCallSignatures().at(0);
+            if (signature) {
+                const functionReturnType = signature.getReturnType();
+                const result = isUnsafeAssignment(returnNodeType, functionReturnType, context.typeChecker, returnNode);
+                if (!result) {
+                    return;
+                }
+                const { receiver, sender } = result;
+                context.report({
+                    data: {
+                        receiver: context.typeChecker.typeToString(receiver),
+                        sender: context.typeChecker.typeToString(sender),
+                    },
+                    message: "unsafeReturnAssignment",
+                    range: {
+                        begin: reportingNode.getStart(),
+                        end: reportingNode.getEnd(),
+                    },
+                });
+                return;
+            }
+        }
+        return {
+            visitors: {
+                ArrowFunction: (node) => {
+                    if (!ts.isBlock(node.body)) {
+                        checkReturn(node.body, node.body);
+                    }
+                },
+                ReturnStatement: (node) => {
+                    if (node.expression != null) {
+                        checkReturn(node.expression, node);
+                    }
+                },
+            },
+        };
+    },
+});

package/lib/rules/anyReturns.test.d.ts

@@ -0,0 +1 @@
+export {};