Conditional type inside function resolves differently than at top-level

Bug Report

🔎 Search Terms

regression conditional type inside function behaves difference

🕗 Version & Regression Information

• This changed between versions 4.2.3 and 4.3.5

⏯ Playground Link

Playground link

💻 Code

{
  type A = Record<string, number> 
  type B = Record<'a' | 'b', number> 
  const x: A extends B ? true : false = false; // ok
}

function test() {
  type A = Record<string, number> 
  type B = Record<'a' | 'b', number> 
  const x: A extends B ? true : false = false; // error
}

🙁 Actual behavior

The conditional type resolves differently in global vs local scope.

🙂 Expected behavior

Both should resolve the same way, preferably false in both cases.

Additional Details

This seems to have something to do with the way typescript compares aliases, wrapping one of the Record types in Omit<Record<...>, never> causes the comparison to behave normally

Playground Link

function test() {
  type A = Record<string, number> 
  type B = Record<'a' | 'b', number> 
  const x: A extends B ? true : false = false; // error
}

function test2() {
  type A = Omit<Record<string, number>, never>
  type B = Record<'a' | 'b', number> 
  const x: A extends B ? true : false = false; // ok
}

function test3() {
  type A = Record<string, number>;
  type B = Omit<Record<'a' | 'b', number>, never>
  const x: A extends B ? true : false = false; // ok
}

function test4() {
  type A = Omit<Record<string, number>, never>;
  type B = Omit<Record<'a' | 'b', number>, never>
  const x: A extends B ? true : false = false; // error
}

[fatcerberus]

Wow… it feels so wrong that an undocumented internal implementation detail like that should affect assignability. Not that that doesn’t happen elsewhere (variance measurement being what it is), but this one is particularly hard to come up with theoretical justification for without popping the hood of the compiler.

[fatcerberus]

No worries, I understand it’s a design limitation; it’s not really the unsoundness that bothers me but moreso that I’m trying to figure out the rationale for the discrepency below so I can try to invent a theoretical explanation for it that doesn’t involve popping the hood 😉

the global scope A and B types have new alias symbols associated with them and therefore appear not to be instantiations of the same generic type. Thus we relate them structurally. However, the local A and B types aren’t given new alias symbols (for unrelated reasons) and therefore appear to both be instantiations of Record<K, T>. Thus we relate them according to variance.

edit: I just realized this probably only affects the case where you’re creating type aliases for generic instantiations, and things directly typed as Records (or whatever else) will relate more consistently (i.e. always variance-based). That’s not so bad, in that case.