Inconsistent extends check when comparing a directly written generic (Template<'a'>) to a type-aliased version of the same generic (TA = Template<'a'>)

[Gguigre]

🔎 Search Terms

"Alias equality", "extends broken by alias template", "generic type extension", "extends transitivity typescript"

🕗 Version & Regression Information

• This changed between versions 4.1.5 and 4.2.3

4.1.5	4.2.3

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/C4TwDgpgBAgg8gJwEJQLxQOQEMNQD6YBGGAUCaJLIkgAoID2YAzmlAN4lRQUQBcmOTlCaQAxvwwiIoqIIC++dkJ78ARIVVCp4zNqjEScsjygAVCAFswAGyzAIAHlNQIAD3sA7ACYt4yVti4BBjEAHys7FAA9FHcABYAliyiWACuTBAswHHQhKkA5srgfGZaYvwAou4IWKLADn60DMwANOwqZnKhANqq2qoAuobGxWYwrOZWtvYOgaEjlABKmQCME5Y2do5zLu4Q3iyTm-ZQAPzcCKnQ-ABmWNYZ0bFMcfSp1l760HcP0FjeUCSUB+j34gFByEgxLhQAB6pwW0GWTAATBNxm5PD4zBtptBzsBLtdgfdHlCXm8Pl9ib9ZACgQSrlB+IAZckhsVh8LIZKwFlyBUBNygAEkoOloDx6IKALQy2Vy+VykiiegeJjAKBgVgcLgdQItMrSCR6eSyZIqtUIqBIgDMrAlgs1GP2WKOuLOF0ZtxJ0DJr3en0I329tM+9MJTKgrKhXDhQA

💻 Code

type AOrB = 'a' | 'b'

type AOrBProps = {
  type: 'a'
  spec: 'spec a'
} | {
  type: "b"
  spec: 'spec b'
}

type Template<T extends AOrB = 'a' | 'b'> =  { // this causes the bug
  type: T
  spec: Extract<AOrBProps, {type: T}>["spec"]
}

type TA = Template<'a'>

type Res1 = Template<'a'> extends Template ? true : false // should be false and is false : ✅
//   ^?

type Res2 = TA extends Template ? true : false // should be false and is true : ❌
//  ^?


// same bug if I use typeof -------------------
const p = {
  type: 'a',
  spec: 'spec a'
} as const

type Res3 = typeof p extends Template ? true : false // should be false and is true : ❌
//   ^?

🙁 Actual behavior

Types declared as equals (TA and Template<'a'>) does not behave the same when compared to a third type (Template)

🙂 Expected behavior

As TA = Template<'a'> I would expect Res1 and Res2 to be the same (false)

Additional information about the issue

Working on this issue with @GuillaumeEgret

[MartinJohns]

Sounds like a duplicate of #60503.

[GuillaumeEgret]

Yes, seems likea duplicate but the other issue was automatically closed because there was no update. Should we investigate what broke the type aliasing ?

[MartinJohns]

the other issue was automatically closed because there was no update

It was closed because it was marked as a "Design Limitation", which means there's nothing they can do about it in the foreseeable future.

Should we investigate what broke the type aliasing ?

🤷‍♂ I'm not a team member. But if you have a fix that doesn't have horrendous performance costs and doesn't break anything else I'm sure the team would be happy to accept it.

[RyanCavanaugh]

FWIW your "which of these are correct" is backwards; the correct result in all cases is true, not false.

The problem here is that TS measures Template to be invariant on T, which it theoretically is, but by construction it's covariant on T because the contravariant use site (second arg to Exclude) ends up not really mattering in terms of the output type. In other words this is only covariant on T for some definitions of AOrBProps, which isn't something variance measurement can take into account.

[GuillaumeEgret]

I simplified the minimal repro:

type F<T> = {a: Extract<'a' | 'b', T>}
type F_<T> = Extract<'a' | 'b', T>

type FAB = F<'a' | 'b'>
type FA = F<'a'>
type FB = F<'b'>

type Test1 = F<'a'> extends F<'a' | 'b'> ? true : false // ❌
//   type Test1 = false
type Test1_ = F_<'a'> extends F_<'a' | 'b'> ? true : false // ✅
//   ^? type Test1_ = true

type Test2 = F<'a'> extends FAB ? true : false // ✅
//   type Test2 = true
type Test3 = FA extends F<'a' | 'b'>  ? true : false // ✅
//   type Test3 = true
//   
type Test4 = {a: 'a'} extends F<'a' | 'b'> ? true : false // ✅
//   type Test4 = true
//   
type Test5 = F<'a'> extends F<'a'> | F<'b'>  ? true : false // ✅
//   type Test5 = true
//   


type Truth = {a: 'a'} extends {a: 'a' | 'b'} ? true : false // ✅
//   type Truth = true

The weird thing is that it's the extract inside the object that causes the bug.

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.