typescript-eslint · JoshuaKGoldberg · Dec 30, 2024 · Dec 13, 2024 · Dec 13, 2024 · Dec 13, 2024
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -51,10 +51,17 @@ export default createRule<[], MessageId>({
 
     return {
       AwaitExpression(node): void {
-        const type = services.getTypeAtLocation(node.argument);
-
-        const originalNode = services.esTreeNodeToTSNodeMap.get(node);
-        const certainty = needsToBeAwaited(checker, originalNode, type);
+        const awaitArgumentEsNode = node.argument;
+        const awaitArgumentType =
+          services.getTypeAtLocation(awaitArgumentEsNode);
+        const awaitArgumentTsNode =
+          services.esTreeNodeToTSNodeMap.get(awaitArgumentEsNode);
+
+        const certainty = needsToBeAwaited(
+          checker,
+          awaitArgumentTsNode,
+          awaitArgumentType,
+        );
 
         if (certainty === Awaitable.Never) {
           context.report({

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -6,7 +6,7 @@ import * as ts from 'typescript';
 
 import {
   createRule,
-  getConstrainedTypeAtLocation,
+  getConstraintInfo,
   getParserServices,
   isStrongPrecedenceNode,
 } from '../util';
@@ -85,6 +85,7 @@ export default createRule<Options, MessageIds>({
   ],
   create(context, [options]) {
     const services = getParserServices(context);
+    const checker = services.program.getTypeChecker();
 
     function getBooleanComparison(
       node: TSESTree.BinaryExpression,
@@ -94,19 +95,23 @@ export default createRule<Options, MessageIds>({
         return undefined;
       }
 
-      const expressionType = getConstrainedTypeAtLocation(
-        services,
-        comparison.expression,
+      const { constraintType, isTypeParameter } = getConstraintInfo(
+        checker,
+        services.getTypeAtLocation(comparison.expression),
       );
 
-      if (isBooleanType(expressionType)) {
+      if (isTypeParameter && constraintType == null) {
+        return undefined;
+      }
+
+      if (isBooleanType(constraintType)) {
         return {
           ...comparison,
           expressionIsNullableBoolean: false,
         };
       }
 
-      if (isNullableBoolean(expressionType)) {
+      if (isNullableBoolean(constraintType)) {
         return {
           ...comparison,
           expressionIsNullableBoolean: true,

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -7,6 +7,7 @@ import * as ts from 'typescript';
 import {
   createRule,
   getConstrainedTypeAtLocation,
+  getConstraintInfo,
   getParserServices,
   getTypeName,
   getTypeOfPropertyOfName,
@@ -653,16 +654,7 @@ export default createRule<Options, MessageId>({
           .getCallSignaturesOfType(
             getConstrainedTypeAtLocation(services, callback),
           )
-          .map(sig => sig.getReturnType())
-          .map(t => {
-            // TODO: use `getConstraintTypeInfoAtLocation` once it's merged
-            // https://github.com/typescript-eslint/typescript-eslint/pull/10496
-            if (tsutils.isTypeParameter(t)) {
-              return checker.getBaseConstraintOfType(t);
-            }
-
-            return t;
-          });
+          .map(sig => sig.getReturnType());
 
         if (returnTypes.length === 0) {
           // Not a callable function, e.g. `any`
@@ -673,16 +665,21 @@ export default createRule<Options, MessageId>({
         let hasTruthyReturnTypes = false;
 
         for (const type of returnTypes) {
+          const { constraintType } = getConstraintInfo(checker, type);
           // Predicate is always necessary if it involves `any` or `unknown`
-          if (!type || isTypeAnyType(type) || isTypeUnknownType(type)) {
+          if (
+            !constraintType ||
+            isTypeAnyType(constraintType) ||
+            isTypeUnknownType(constraintType)
+          ) {
             return;
           }
 
-          if (isPossiblyFalsy(type)) {
+          if (isPossiblyFalsy(constraintType)) {
             hasFalsyReturnTypes = true;
           }
 
-          if (isPossiblyTruthy(type)) {
+          if (isPossiblyTruthy(constraintType)) {
             hasTruthyReturnTypes = true;
           }
 

diff --git a/packages/eslint-plugin/src/util/getConstraintInfo.ts b/packages/eslint-plugin/src/util/getConstraintInfo.ts
@@ -0,0 +1,60 @@
+import type * as ts from 'typescript';
+
+import * as tsutils from 'ts-api-utils';
+
+export interface ConstraintTypeInfoUnconstrained {
+  constraintType: undefined;
+  isTypeParameter: true;
+}
+
+export interface ConstraintTypeInfoConstrained {
+  constraintType: ts.Type;
+  isTypeParameter: true;
+}
+
+export interface ConstraintTypeInfoNonGeneric {
+  constraintType: ts.Type;
+  isTypeParameter: false;
+}
+
+export type ConstraintTypeInfo =
+  | ConstraintTypeInfoConstrained
+  | ConstraintTypeInfoNonGeneric
+  | ConstraintTypeInfoUnconstrained;
+
+/**
+ * Returns whether the type is a generic and what its constraint is.
+ *
+ * If the type is not a generic, `isTypeParameter` will be `false`, and
+ * `constraintType` will be the same as the input type.
+ *
+ * If the type is a generic, and it is constrained, `isTypeParameter` will be
+ * `true`, and `constraintType` will be the constraint type.
+ *
+ * If the type is a generic, but it is not constrained, `constraintType` will be
+ * `undefined` (rather than an `unknown` type), due to https://github.com/microsoft/TypeScript/issues/60475
+ *
+ * Successor to {@link getConstrainedTypeAtLocation} due to https://github.com/typescript-eslint/typescript-eslint/issues/10438
+ *
+ * This is considered internal since it is unstable for now and may have breaking changes at any time.
+ * Use at your own risk.
+ *
+ * @internal
+ *
+ */
+export function getConstraintInfo(
+  checker: ts.TypeChecker,
+  type: ts.Type,
+): ConstraintTypeInfo {
+  if (tsutils.isTypeParameter(type)) {
+    const constraintType = checker.getBaseConstraintOfType(type);
+    return {
+      constraintType,
+      isTypeParameter: true,
+    };
+  }
+  return {
+    constraintType: type,
+    isTypeParameter: false,
+  };
+}
diff --git a/packages/eslint-plugin/src/util/index.ts b/packages/eslint-plugin/src/util/index.ts
@@ -23,9 +23,11 @@ export * from './objectIterators';
 export * from './needsToBeAwaited';
 export * from './scopeUtils';
 export * from './types';
+export * from './getConstraintInfo';
 
 // this is done for convenience - saves migrating all of the old rules
 export * from '@typescript-eslint/type-utils';
+
 const {
   applyDefault,
   deepMerge,

diff --git a/packages/eslint-plugin/src/util/needsToBeAwaited.ts b/packages/eslint-plugin/src/util/needsToBeAwaited.ts
@@ -6,6 +6,8 @@ import {
 } from '@typescript-eslint/type-utils';
 import * as tsutils from 'ts-api-utils';
 
+import { getConstraintInfo } from './getConstraintInfo';
+
 export enum Awaitable {
   Always,
   Never,
@@ -17,24 +19,20 @@ export function needsToBeAwaited(
   node: ts.Node,
   type: ts.Type,
 ): Awaitable {
-  // can't use `getConstrainedTypeAtLocation` directly since it's bugged for
-  // unconstrained generics.
-  const constrainedType = !tsutils.isTypeParameter(type)
-    ? type
-    : checker.getBaseConstraintOfType(type);
+  const { constraintType, isTypeParameter } = getConstraintInfo(checker, type);
 
   // unconstrained generic types should be treated as unknown
-  if (constrainedType == null) {
+  if (isTypeParameter && constraintType == null) {
     return Awaitable.May;
   }
 
   // `any` and `unknown` types may need to be awaited
-  if (isTypeAnyType(constrainedType) || isTypeUnknownType(constrainedType)) {
+  if (isTypeAnyType(constraintType) || isTypeUnknownType(constraintType)) {
     return Awaitable.May;
   }
 
   // 'thenable' values should always be be awaited
-  if (tsutils.isThenableType(checker, node, constrainedType)) {
+  if (tsutils.isThenableType(checker, node, constraintType)) {
     return Awaitable.Always;
   }
 

diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts
@@ -109,6 +109,20 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
     },
     "'false' === true;",
     "'true' === false;",
+    `
+const unconstrained: <T>(someCondition: T) => void = someCondition => {
+  if (someCondition === true) {
+  }
+};
+    `,
+    `
+const extendsUnknown: <T extends unknown>(
+  someCondition: T,
+) => void = someCondition => {
+  if (someCondition === true) {
+  }
+};
+    `,
   ],
 
   invalid: [