TypeScript中为何`T extends "A"`与`S extends "A"`无类型重叠？编译错误ts(2367)解析与解决方法

Let's break down why this confusing error happens and how to fix it.

The Root Cause #

At first glance, this seems totally counterintuitive—both T and S are constrained to "A", so they should always be equal, right? But TypeScript's type system treats independent generic parameters differently, even when their constraints are identical.

When you define T extends "A" and S extends "A", TypeScript doesn't automatically assume T and S refer to the same type. Even though "A" is a singleton type (only one possible value exists for it), TypeScript sees T and S as separate, unconnected type variables. From the checker's perspective, there's no guarantee these two variables resolve to the same subtype of "A" (even though there are no other subtypes to speak of), so it incorrectly concludes their types have no overlap. Hence the error claiming the condition will always return false.

Fixes You Can Apply #

Here are a few clean, practical ways to resolve this:

1. Use a single generic parameter for both arguments #

If both parameters should always be the same subtype of "A", combine them into one generic variable. This makes the type relationship explicit:

function f<T extends "A">(x: T, y: T) {
  if (x === y) {
    // No error now—x and y are explicitly the same type
  }
}

2. Constrain one generic to the other #

If you need to keep two distinct generics but want to enforce type overlap, make S extend T (or vice versa). This tells TypeScript that S is guaranteed to be a subtype of T, so their types must overlap:

function f<T extends "A", S extends T>(x: T, y: S) {
  if (x === y) {
    // S inherits from T, so the types definitely overlap
  }
}

3. Drop generics entirely (if you don't need them) #

If you don't plan to extend the constraint beyond "A" later, just use the concrete type directly. This removes any ambiguity for the type checker:

function f(x: "A", y: "A") {
  if (x === y) {
    // No generics, no confusion
  }
}

4. Use a type assertion (last resort) #

If you absolutely need to keep the original generic setup and trust your logic, you can use a type assertion to bypass the checker. Note that this disables type safety for this check, so only use it if you're sure:

function f<T extends "A", S extends "A">(x: T, y: S) {
  if (x === y as T) {
    // Assert y matches T to satisfy the type checker
  }
}

内容的提问来源于stack exchange，提问作者tamuhey