diff --git a/‎packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts‎
Lines changed: 10 additions & 2 deletions b/‎packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts‎
Lines changed: 91 additions & 0 deletions b/‎packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts‎
Lines changed: 91 additions & 0 deletions
@@ -4,7 +4,12 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
-import { createRule, getParserServices, isStrongPrecedenceNode } from '../util';
+import {
+  createRule,
+  getConstrainedTypeAtLocation,
+  getParserServices,
+  isStrongPrecedenceNode,
+} from '../util';
 
 type MessageIds =
   | 'comparingNullableToFalse'
@@ -89,7 +94,10 @@ export default createRule<Options, MessageIds>({
         return undefined;
       }
 
-      const expressionType = services.getTypeAtLocation(comparison.expression);
+      const expressionType = getConstrainedTypeAtLocation(
+        services,
+        comparison.expression,
+      );
 
       if (isBooleanType(expressionType)) {
         return {
 
@@ -55,6 +55,18 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
       declare const varTrueOrStringOrUndefined: true | string | undefined;
       varTrueOrStringOrUndefined == true;
     `,
+    `
+      const test: <T>(someCondition: T) => void = someCondition => {
+        if (someCondition === true) {
+        }
+      };
+    `,
+    `
+      const test: <T>(someCondition: boolean | string) => void = someCondition => {
+        if (someCondition === true) {
+        }
+      };
+    `,
     `
       declare const varBooleanOrUndefined: boolean | undefined;
       varBooleanOrUndefined === true;
@@ -73,6 +85,28 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
       `,
       options: [{ allowComparingNullableBooleansToTrue: false }],
     },
+    {
+      code: `
+        const test: <T extends boolean | undefined>(
+          someCondition: T,
+        ) => void = someCondition => {
+          if (someCondition === true) {
+          }
+        };
+      `,
+      options: [{ allowComparingNullableBooleansToFalse: false }],
+    },
+    {
+      code: `
+        const test: <T extends boolean | undefined>(
+          someCondition: T,
+        ) => void = someCondition => {
+          if (someCondition === false) {
+          }
+        };
+      `,
+      options: [{ allowComparingNullableBooleansToTrue: false }],
+    },
     "'false' === true;",
     "'true' === false;",
   ],
@@ -481,5 +515,62 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         }
       `,
     },
+    {
+      code: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (someCondition === true) {
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: 'direct',
+        },
+      ],
+      output: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (someCondition) {
+          }
+        };
+      `,
+    },
+    {
+      code: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (!(someCondition !== false)) {
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: 'negated',
+        },
+      ],
+      output: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (!someCondition) {
+          }
+        };
+      `,
+    },
+    {
+      code: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (!((someCondition ?? true) !== false)) {
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: 'negated',
+        },
+      ],
+      output: `
+        const test: <T extends boolean>(someCondition: T) => void = someCondition => {
+          if (!(someCondition ?? true)) {
+          }
+        };
+      `,
+    },
   ],
 });