Conditional type eagerly calculated to be invariant breaks referential transparency

[devanshj]

🔎 Search Terms

Conditional types, Invariance, Referential transparency

🕗 Version & Regression Information

Tried with v5.9.3

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.3#code/C4TwDgpgBAYgPAFQHxQLxQN5QG4EMA2ArhAFxQJQQAewEAdgCYDOUA9gEYBWEAxsFAH4oAawghWAM3JQyFAL4AoBaEhQASgEY0sOBjkpqtRi3hZcZJsABOASzoBzKPsFQARAAtW+Zq5luGrBAsdKz8nt6uCgD0UVBxAHoCSirQMLjapvrK4KnsGbpQ5lCWtg5OSMk56gBMGemG9MyweUIeXj5+rgFBUCFh7ZExcVCJCkA

💻 Code

type F<T> = { value: T extends object ? keyof T : T }

type R1 = F<{}> extends F<{ a: string }> ? "holds" : "does not hold"
//   ^? "does not hold"

type Fa = F<{}>
type Fb = F<{ a: string }>

type R2 = Fa extends Fb ? "holds" : "does not hold"
//   ^? "holds"

🙁 Actual behavior

R1 computes to "does not hold"

🙂 Expected behavior

R1 computes to "holds"

Additional information about the issue

I'm assuming typescript eagerly calculates F to be invariant and then instead of checking the subtype relation on resolved types it calculates subtype relation of the parameters to F. (This would perhaps have made sense if F was explicitly annotated with in out T.)

[MartinJohns]

This sounds like a duplicate of #48070.

[RyanCavanaugh]

#55161 (comment) is also closely related, the variance we should have measured on F is "unreliable" but instead it looks like we're getting invariant (I haven't confirmed this).

This is a longstanding problem and straightforward attempts to fix it have generally made a lot of things worse and very few things better. Open to a PR but this might be effectively a duplicate of "We need a way to disable variance measurement on a type".

[Andarist]

I can only confirm that F is measured to be invariant here and that the other example ends up comparing different type aliases so it goes straight~ to the structural comparison.

[juhort]

@RyanCavanaugh Consider this example from #55161 (comment):

// Measured as invariant (wrong)
type IsSupertypeOfString<T> = string extends T ? true : false;

// Covariant use of invariant type is still invariant
type BoxOfIsSupertypeOfString<T> = {readonly value: IsSupertypeOfString<T>};

declare let direct_number: IsSupertypeOfString<number>;
declare let direct_boolean: IsSupertypeOfString<boolean>;
// OK (non-variance-based relation)
direct_number = direct_boolean;

declare let box_number: BoxOfIsSupertypeOfString<number>;
declare let box_boolean: BoxOfIsSupertypeOfString<boolean>;
// Error (variance-based relation)
box_boolean = box_number;
// Type 'BoxOfIsSupertypeOfString<number>' is not assignable to type 'BoxOfIsSupertypeOfString<boolean>'.
//   Type 'number' is not assignable to type 'boolean'.

// Added this
box_number = box_boolean;
// Type 'BoxOfIsSupertypeOfString<boolean>' is not assignable to type 'BoxOfIsSupertypeOfString<number>'.
//   Type 'boolean' is not assignable to type 'number'.

In this case the "variance-based" check happens both ways, i.e., box_boolean = box_number and box_number = box_boolean.

But, if I try to replicate the same with this issue's example, looks like the "variance-based" check only happens in one direction.

type F<T> = {value: T extends object ? keyof T : T};

type R1 = F<{}> extends F<{a: string}> ? "holds" : "does not hold"; //=> "does not hold"

declare let fa: F<{}>; //=> F<{}>
declare let fb: F<{a: string}>; //=> F<{ a: string; }>

fb = fa;
// Type 'F<{}>' is not assignable to type 'F<{ a: string; }>'.
//   Property 'a' is missing in type '{}' but required in type '{ a: string; }'.

So far this makes sense, to compare if F<{}> is assignable to F<{ a: string }>, the compiler is checking if {} is assignable to { a: string }.
But, if I do:

fa = fb;
// Type 'F<{ a: string; }>' is not assignable to type 'F<{}>'.
//   Types of property 'value' are incompatible.
//     Type '"a"' is not assignable to type 'never'.

I thought this assignment would pass because { a: string } is assignable to {}, but instead it fails and looks like this time it's not doing a "variance-based" check, instead it's doing a "structural" check.

Noticed this while playing around with this, thought I should share.