some types in 4.5.0 aren't correctly resolving to same types in 4.4.4

[suneettipirneni]

Bug Report

I recently ran into the this strange error when I updated to typescript 4.5.0-beta, generic types that were resolving properly in 4.4.4, are not correctly resolving in 4.5.0-beta. Instead 4.5.0 returns a unions of all of the possible values while the same code in 4.4.4 returns a narrowed generic type.

🔎 Search Terms

4.5.0-beta, unions, generics

🕗 Version & Regression Information

typescript@beta, 4.5.0-beta, typescript@next

• This changed between versions 4.4.4 and 4.5.0-beta

⏯ Playground Link

Same code for both versions:

Playground link with relevant code

💻 Code

export type kind = "one" | "two" | "three";

export interface Options<T> {
  item?: T;
  type?: kind;
}

type One = {};
type Two = {};
type Three = {};

type OneOptions = Options<One>;
type TwoOptions = Options<Two>;
type ThreeOption = Options<Three>;

interface MappedInterfaceOptions {
    "one": OneOptions;
    "two": TwoOptions;
    "three": ThreeOption;
}

export type InterfaceExtractor<
  T extends kind,
> = T extends kind
  ? MappedInterfaceOptions[T] extends Options<infer Item>
    ? Item
    : never
  : Options<One>;

export type Params<T extends kind> = { type?: T; } & Options<InterfaceExtractor<T>>;

declare function getInterfaceFromString<
  T extends kind,
>(options?: Params<T>): InterfaceExtractor<T>;

// Typescript 4.4.4 states the type is `Two`, 4.5.0 states the type is `One` | `Two` | `Three`
const result = getInterfaceFromString({ type: 'two' });

🙁 Actual behavior

In typescript 4.4.4 the type is correctly resolved to Two, whereas in typescript 4.5.0 the type is resolved to One | Two | Three which is incorrect.
4.4.4:

4.5.0-beta:

🙂 Expected behavior

The correct type for result in the playground and the codesample is Two, not One | Two | Three, typescript 4.5.0 should resolve to this type.

[suneettipirneni]

it seems that this line causes the discrepancy:

export type Params<T extends kind> = { type?: T } & Options<T>;

Changing this to:

export type Params<T extends kind> = { type?: T };

Resolves both versions to the same type: One | Two | Three, however I'm not sure why the original typedef causes issues on 4.5.0

[andrewbranch]

The issue is we're seeing

const result = getInterfaceFromString({ type: 'two' });
//                                    { type?: kind }

instead of

const result = getInterfaceFromString({ type: 'two' });
//                                    { type?: "two" }

Using getInterfaceFromString({ type: 'two' } as const) gets the result you expect. Looks like a contextual typing regression.

[andrewbranch]

Unclear if fixing this in 4.5 will be possible without other breaking changes, but worth looking into.

[sandersn]

Note that both 4.5 and 4.4 say that the type is Two from tsc.

[sandersn]

Broken by #46052

[andrewbranch]

The surprising thing is that exactOptionalPropertyTypes isn't even enabled in this repro. @ahejlsberg any ideas?

[ahejlsberg]

Ooo, this is a nasty little issue. During union type construction we repurpose certain TypeFlags to gather data about what kinds of types are in the union. But we then have a test for whether a union should be marked primitive-types-only, and that test erroneously assumes the original meanings of the TypeFlags. It broke because we moved some of the repurposed flags around. I have a fix for it, will put up a PR shortly. If possible, we should take this for 4.5.1.

[ahejlsberg]

Here's a simplified repro:

export type Kind = "one" | "two" | "three";

declare function getInterfaceFromString<T extends Kind>(options?: { type?: T } & { type?: Kind }): T;

const result = getInterfaceFromString({ type: 'two' });  // Should be "two", not Kind