@flint.fyi/ts 0.14.2 → 0.14.4

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @flint/ts
 
+## 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
+
+- 9b6b884: added browser plugin with alerts rule
+- c8bad31: feat: add JSX plugin with accessKeys rule
+
 ## 0.14.2
 
 ### Patch Changes

package/lib/createTypeScriptFileFromProgram.js

@@ -33,6 +33,7 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
         async runRule(rule, options) {
             const reports = [];
             const context = {
+                program,
                 report: (report) => {
                     reports.push({
                         ...report,

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,3 +1,4 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.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/nodes.d.ts

@@ -22,6 +22,7 @@ export interface TSNodesByName {
     ComputedPropertyName: ts.ComputedPropertyName;
     ConditionalExpression: ts.ConditionalExpression;
     ConditionalType: ts.ConditionalType;
+    Constructor: ts.ConstructorDeclaration;
     ContinueStatement: ts.ContinueStatement;
     DebuggerStatement: ts.DebuggerStatement;
     Decorator: ts.Decorator;

package/lib/plugin.d.ts

@@ -1,16 +1,96 @@
 export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [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";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "asyncPromiseExecutor", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
+    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";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noChainedAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning class declarations.";
+    readonly id: "classAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noClassAssign", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary extra non-null assertions.";
     readonly id: "consecutiveNonNullAssertions";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to reassign variables declared with const.";
+    readonly id: "constantAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noConstAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports returning values from constructor functions.";
+    readonly id: "constructorReturns";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noConstructorReturn", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using debugger statements.";
     readonly id: "debuggerStatements";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDebugger", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch statements where the default clause is not last.";
+    readonly id: "defaultCaseLast";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "defaultCaseShouldBeLast", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports functions with duplicate parameter names in their signatures.";
+    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 using empty destructuring patterns that destructure no values.";
+    readonly id: "emptyDestructures";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyPattern", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty static initialization blocks within class declarations.";
+    readonly id: "emptyStaticBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyStaticBlock", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning exception parameters in catch clauses.";
+    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";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning variables declared with function declarations.";
+    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";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingYield", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
+    readonly id: "globalAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
+    readonly id: "globalObjectCalls";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalObjectCall", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
     readonly preset: "logical";
@@ -18,7 +98,91 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly allowDeclarations: import("zod").ZodDefault<import("zod").ZodBoolean>;
     readonly allowDefinitionFiles: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparisons with -0 that may not behave as expected.";
+    readonly id: "negativeZeroComparisons";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone new expressions that don't use the constructed object.";
+    readonly id: "newExpressions";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noStandaloneNew", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
+    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";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noProto", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using octal escape sequences in string literals.";
     readonly id: "octalEscapes";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalEscape", undefined>]>;
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalEscape", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using legacy octal numeric literals.";
+    readonly id: "octalNumbers";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalNumber", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using assignment expressions in return statements.";
+    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 array literals with holes (sparse arrays).";
+    readonly id: "sparseArrays";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSparseArray", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports Symbol() calls without description arguments.";
+    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";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noUnassigned", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using variables that are not defined.";
+    readonly id: "undefinedVariables";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "undefinedVariable", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
+    readonly id: "unicodeBOMs";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", 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 negating the left operand of `in` or `instanceof` relations.";
+    readonly id: "unsafeNegations";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferNegatingRelation", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to delete variables with the delete operator.";
+    readonly id: "variableDeletions";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDeleteVar", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the void operator.";
+    readonly id: "voidOperator";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noVoid", undefined>]>;

package/lib/plugin.js

@@ -1,19 +1,101 @@
 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";
+import constantAssignments from "./rules/constantAssignments.js";
+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 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";
 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 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 unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unsafeNegations from "./rules/unsafeNegations.js";
+import variableDeletions from "./rules/variableDeletions.js";
+import voidOperator from "./rules/voidOperator.js";
 export const ts = createPlugin({
     files: {
         all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
     },
     name: "ts",
     rules: [
+        anyReturns,
+        asyncPromiseExecutors,
+        caseDeclarations,
+        caseDuplicates,
+        chainedAssignments,
+        classAssignments,
         consecutiveNonNullAssertions,
+        constantAssignments,
+        constructorReturns,
         debuggerStatements,
+        defaultCaseLast,
+        duplicateArguments,
+        elseIfDuplicates,
+        emptyDestructures,
+        emptyStaticBlocks,
+        exceptionAssignments,
+        forDirections,
         forInArrays,
+        functionAssignments,
+        functionNewCalls,
+        generatorFunctionYields,
+        globalAssignments,
+        globalObjectCalls,
         namespaceDeclarations,
+        negativeZeroComparisons,
+        newExpressions,
+        newNativeNonConstructors,
+        nonOctalDecimalEscapes,
+        numericLiteralParsing,
+        objectProto,
         octalEscapes,
+        octalNumbers,
+        returnAssignments,
+        selfAssignments,
+        selfComparisons,
+        sequences,
+        sparseArrays,
+        symbolDescriptions,
+        typeofComparisons,
+        unassignedVariables,
+        undefinedVariables,
+        unicodeBOMs,
+        unnecessaryCatches,
+        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 {};