Type Guards do not reflect on related types

[lingz]

TypeScript Version: 2.8

Code

type Identity<T> = T;

function test(
  x: 'a' | 'b',
  y: Identity<typeof x>,
) {
  if (x === 'a') {
    const z = y;
  }
}

Expected behavior:
x has type a
z has type a

Actual behavior:
x has type a
z has type a | b

[MartinJohns]

typeof x is 'a' | 'b', so y can either be 'a' or 'b', independently of the value of x. Calling test('a', 'b') is perfectly valid.

[j-oliveras]

You can use function overloads (if you want that the two parameters has the same type):

type Identity<T> = T;

function test(x: 'a', y: Identity<typeof x>);
function test(x: 'b', y: Identity<typeof x>);
function test(
  x: 'a' | 'b',
  y: Identity<typeof x>,
) {
  if (x === 'a') {
    const z = y;
  }
}

See at playground.

[MartinJohns]

@j-oliveras But that won't fix his issue that z is still 'a' | 'b', and not the actual type of y. Tho this sounds like a very constructed case. Perhaps he can shed some light on his actual use-case.

[lingz]

I'm trying to understand if there is a way to constrain a function arguments with some relation, i.e. having the same type. For example, what if I want a function that takes two arguments of the same type:

f<T>(a: T, b: T)

Within the implementation, narrowing does not work with generics at all #25039. So we need to write it without generics, but it seems that there is no way to express this relation without using generics?

[jcready]

This would require dependent types which is not something that TypeScript offers.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.