Using tagged unions to narrow generics

[icewind1991]

When using a tagged union as type argument to a generic function it would be nice if you can use the discriminant to narrow down the generic type to a single piece of the union.

Example:

interface TypeA {
	type: 'a';
	foo: number;
}

interface TypeB {
	type: 'b';
	bar: number;
}

type BothTypes = TypeA | TypeB;

function make<T extends BothTypes>(type: T['type']): T {
	switch (type) {
		case 'a':
			return {
				type: 'a',
				foo: 1
			};
		case 'b':
			return {
				type: 'b',
				bar: 1
			};
	}
}

const obj = make('a');
console.log(obj.foo);

currently typescript complains that both return statements are not assignable to T, and the returned object is the generic BothTypes instead of TypeA.

[akarzazi]

This has nothing to do with union types, here is simplified version

interface TypeA {
    type: 'a';
    foo: number;
}

function make<T extends TypeA>(): T {
    return {
        type: 'a',
        foo: 1
    }
}

Error: Type '{ type: "a"; foo: number; }' is not assignable to type 'T'.

Because the parameter T may be a subtype of TypeA.

Try using instead this signature

function make<T extends BothTypes>(type: T['type']): BothTypes

[jcalz]

Probably the desired workaround looks more like:

type MapTypes = {
  a: TypeA;
  b: TypeB;
}
function make<T extends BothTypes['type']>(type: T): MapTypes[T] {
  const t: BothTypes['type'] = type; // help control flow analysis
  switch (t) {
    case 'a':
      return {
        type: 'a',
        foo: 1
      };
    case 'b':
      return {
        type: 'b',
        bar: 1
      };
  }
  const never: never = t; // exhaustiveness check
  return never;
}

const obj = make('a');
console.log(obj.foo); // ok

[mhegazy]

seems like another manifestation of #17859.

[mhegazy]

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