typescript-eslint · JoshuaKGoldberg · Mar 10, 2025 · Feb 25, 2025 · Mar 4, 2025 · Mar 4, 2025
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
@@ -160,6 +160,17 @@ function foo(): Set<number> {
       }
     `,
     'const foo: (() => void) | undefined = () => 1;',
+    `
+      class Foo {
+        public foo(): this {
+          return this;
+        }
+
+        protected then(resolve: () => void): void {
+          resolve();
+        }
+      }
+    `,
   ],
   invalid: [
     {

diff --git a/packages/type-utils/src/discriminateAnyType.ts b/packages/type-utils/src/discriminateAnyType.ts
@@ -0,0 +1,62 @@
+import type * as ts from 'typescript';
+
+import * as tsutils from 'ts-api-utils';
+
+import { isTypeAnyType, isTypeAnyArrayType } from './predicates';
+
+export enum AnyType {
+  Any,
+  PromiseAny,
+  AnyArray,
+  Safe,
+}
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
+ *          otherwise it returns `AnyType.Safe`.
+ */
+export function discriminateAnyType(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  program: ts.Program,
+  tsNode: ts.Node,
+): AnyType {
+  return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+}
+
+function discriminateAnyTypeWorker(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  program: ts.Program,
+  tsNode: ts.Node,
+  visited: Set<ts.Type>,
+) {
+  if (visited.has(type)) {
+    return AnyType.Safe;
+  }
+  visited.add(type);
+  if (isTypeAnyType(type)) {
+    return AnyType.Any;
+  }
+  if (isTypeAnyArrayType(type, checker)) {
+    return AnyType.AnyArray;
+  }
+  for (const part of tsutils.typeParts(type)) {
+    if (tsutils.isThenableType(checker, tsNode, part)) {
+      const awaitedType = checker.getAwaitedType(part);
+      if (awaitedType) {
+        const awaitedAnyType = discriminateAnyTypeWorker(
+          awaitedType,
+          checker,
+          program,
+          tsNode,
+          visited,
+        );
+        if (awaitedAnyType === AnyType.Any) {
+          return AnyType.PromiseAny;
+        }
+      }
+    }
+  }
+
+  return AnyType.Safe;
+}
diff --git a/packages/type-utils/src/index.ts b/packages/type-utils/src/index.ts
@@ -13,6 +13,7 @@ export * from './propertyTypes';
 export * from './requiresQuoting';
 export * from './typeFlagUtils';
 export * from './TypeOrValueSpecifier';
+export * from './discriminateAnyType';
 export {
   getDecorators,
   getModifiers,

diff --git a/packages/type-utils/src/predicates.ts b/packages/type-utils/src/predicates.ts
@@ -108,48 +108,6 @@ export function isTypeUnknownArrayType(
   );
 }
 
-export enum AnyType {
-  Any,
-  PromiseAny,
-  AnyArray,
-  Safe,
-}
-/**
- * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
- *          otherwise it returns `AnyType.Safe`.
- */
-export function discriminateAnyType(
-  type: ts.Type,
-  checker: ts.TypeChecker,
-  program: ts.Program,
-  tsNode: ts.Node,
-): AnyType {
-  if (isTypeAnyType(type)) {
-    return AnyType.Any;
-  }
-  if (isTypeAnyArrayType(type, checker)) {
-    return AnyType.AnyArray;
-  }
-  for (const part of tsutils.typeParts(type)) {
-    if (tsutils.isThenableType(checker, tsNode, part)) {
-      const awaitedType = checker.getAwaitedType(part);
-      if (awaitedType) {
-        const awaitedAnyType = discriminateAnyType(
-          awaitedType,
-          checker,
-          program,
-          tsNode,
-        );
-        if (awaitedAnyType === AnyType.Any) {
-          return AnyType.PromiseAny;
-        }
-      }
-    }
-  }
-
-  return AnyType.Safe;
-}
-
 /**
  * @returns Whether a type is an instance of the parent type, including for the parent's base types.
  */

diff --git a/packages/type-utils/tests/discriminateAnyType.test.ts b/packages/type-utils/tests/discriminateAnyType.test.ts
@@ -0,0 +1,101 @@
+import type { TSESTree } from '@typescript-eslint/typescript-estree';
+
+import { parseForESLint } from '@typescript-eslint/parser';
+import path from 'node:path';
+
+import { AnyType, discriminateAnyType } from '../src';
+import { expectToHaveParserServices } from './test-utils/expectToHaveParserServices';
+
+type GetNode = (ast: TSESTree.Program) => TSESTree.Node;
+
+describe('discriminateAnyType', () => {
+  const rootDir = path.join(__dirname, 'fixtures');
+
+  function getDeclarationId(ast: TSESTree.Program): TSESTree.Node {
+    const declaration = ast.body.at(-1) as TSESTree.VariableDeclaration;
+    const id = declaration.declarations[0].id;
+    return id;
+  }
+
+  function getTypes(code: string, getNode: GetNode) {
+    const { ast, services } = parseForESLint(code, {
+      disallowAutomaticSingleRunInference: true,
+      filePath: path.join(rootDir, 'file.ts'),
+      project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
+    });
+    expectToHaveParserServices(services);
+    const node = getNode(ast);
+    const type = services.getTypeAtLocation(getNode(ast));
+    return {
+      checker: services.program.getTypeChecker(),
+      program: services.program,
+      tsNode: services.esTreeNodeToTSNodeMap.get(node),
+      type,
+    };
+  }
+
+  function runTest(
+    code: string,
+    expected: AnyType,
+    getNode: GetNode = getDeclarationId,
+  ): void {
+    const { checker, program, tsNode, type } = getTypes(code, getNode);
+    const result = discriminateAnyType(type, checker, program, tsNode);
+    expect(result).toBe(expected);
+  }
+
+  describe('returns Safe', () => {
+    it.each([
+      ['const foo = "foo";', AnyType.Safe],
+      ['const foo = 1;', AnyType.Safe],
+      ['const foo = [1, 2];', AnyType.Safe],
+    ])('when code is %s, returns %s', runTest);
+
+    it('should returns Safe for a recursive thenable.', () => {
+      const code = `
+class Foo {
+  foo() {
+    return this;
+  }
+  protected then(resolve: () => void): void {
+    resolve();
+  }
+};
+        `;
+      runTest(code, AnyType.Safe, ast => {
+        const classDeclration = ast.body[0] as TSESTree.ClassDeclaration;
+        const method = classDeclration.body
+          .body[0] as TSESTree.MethodDefinition;
+        const returnStatement = method.value.body?.body.at(
+          -1,
+        ) as TSESTree.ReturnStatement;
+        return returnStatement.argument!;
+      });
+    });
+  });
+
+  describe('returns Any', () => {
+    it.each([
+      ['const foo = 1 as any;', AnyType.Any],
+      ['let foo;', AnyType.Any],
+    ])('when code is %s, returns %s', runTest);
+  });
+
+  describe('returns PromiseAny', () => {
+    it.each([
+      ['const foo = Promise.resolve({} as any);', AnyType.PromiseAny],
+      [
+        'const foo = Promise.resolve(Promise.resolve({} as any));',
+        AnyType.PromiseAny,
+      ],
+    ])('when code is %s, returns %s', runTest);
+  });
+
+  describe('returns AnyArray', () => {
+    it.each([
+      ['const foo = [{} as any];', AnyType.AnyArray],
+      ['const foo = [{} as any, 2];', AnyType.AnyArray],
+    ])('when code is %s, returns %s', runTest);
+  });
+});