Incorrect generic inference inside a discriminated union

[hednowley]

Bug Report

🔎 Search Terms

discrimated union generic extra property

🕗 Version & Regression Information

• This changed between versions 4.1.5 and 4.2.3

⏯ Playground Link

Playground link with relevant code

💻 Code

type Loadable<TValue> =
    | {
          state: "loading"
      }
    | {
          state: "complete"
          value: TValue
      }


function mapLoadable<TValue>(loadable: Loadable<TValue>, map: (value: TValue) => void): void {
}

type AugmentedLoadable =
    | {
          state: "loading"
          value: number
      }
    | {
          state: "complete"
          value: string
      }

function mapAugmented(augmented: AugmentedLoadable) {
    mapLoadable(augmented, () => {}) // ❌ Errors with "Argument of type 'AugmentedLoadable' is not assignable to parameter of type 'Loadable<number>'"
    mapLoadable<string>(augmented, () => {}) // ✅ Works now that type is generic is specified
}

🙁 Actual behavior

TypeScript incorrectly infers that augmented should be assignable to Loadable<number> rather than a Loadable<string>, because we've added an unrelated value: number property to it. It can be nudged into working by writing out the generic type.

🙂 Expected behavior

TypeScript to infer the correct generic of string.

[andrewbranch]

The inference depends on the union order of AugmentedLoadable 😞

[awerlogus]

The simplest repro:

declare const a: <E, T>(either: [false, E] | [true, T]) => void

declare const b: [false, string] | [true, number]

// now:      const a: <string, string>(either: [false, string] | [true, string]) => void
// expected: const a: <string, number>(either: [false, string] | [true, number]) => void
a(b)

[CraigMacomber]

I think I hit the same or a similar issue. My repro for it boiled down to:

Playground

type A<T> = {
    c: unknown;
} & (new () => T);

interface B<T> {
    a: T;
}

type Union1<T> = A<T> | B<T>;
type Union2<T> = B<T> | A<T>;

function X<T>(objectClass: Union1<T>): void {}
function X2<T>(objectClass: Union2<T>): void {}

class Inferable {
    public b!: unknown;
    public static a: number;
}

X(Inferable); // Errors
X2(Inferable); // Builds

My case fails (union is order dependent) all the way back to TS 3.3 (as far as the playground goes) through latest nightly.