3.7.2+ Union Type Merged to Single Type in Wrapper

[RyanLamanskyInsite]

TypeScript Version:
3.8.0-dev.20191119
3.7.2

Search Terms:
Redux
Connect
Union

Code

const mapStateToProps = (state?: {}) => !state ? {} : { foo: 1 };

type Props = ReturnType<typeof mapStateToProps>;

const MyComponent = (props: Props) => null;

// Simplified from react
type FunctionComponent<P> = (props: P & { children: {} }) => null;

// Simplified from react-redux
type Matching<InjectedProps, DecorationTargetProps> = {
    [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
        ? InjectedProps[P] extends DecorationTargetProps[P]
            ? DecorationTargetProps[P]
            : InjectedProps[P]
        : DecorationTargetProps[P];
};

// Simplified from react-redux
type InferableComponentEnhancerWithProps =
    <C extends FunctionComponent<Matching<Props, Props>>>(
        component: C
    ) => never;

(window as any as InferableComponentEnhancerWithProps)(MyComponent);

Expected behavior:
Code should compile without error. This works on 3.6.3 and below.

Actual behavior:

demo.ts:25:56 - error TS2345: Argument of type '(props: { foo?: undefined; } | { foo: number; }) => null' is not assignable to parameter of type 'FunctionComponent<Matching<{ foo?: undefined; } | { foo: number; }, { foo?: undefined; }> | Matching<{ foo?: undefined; } | { foo: number; }, { foo: number; }>>'.
  Types of parameters 'props' and 'props' are incompatible.
    Type '(Matching<{ foo?: undefined; } | { foo: number; }, { foo?: undefined; }> & { children: {}; }) | (Matching<{ foo?: undefined; } | { foo: number; }, { foo: number; }> & { children: {}; })' is not assignable to type '{ foo?: undefined; } | { foo: number; }'.
      Type 'Matching<{ foo?: undefined; } | { foo: number; }, { foo?: undefined; }> & { children: {}; }' is not assignable to type '{ foo?: undefined; } | { foo: number; }'.
        Type 'Matching<{ foo?: undefined; } | { foo: number; }, { foo?: undefined; }> & { children: {}; }' is not assignable to type '{ foo: number; }'.
          Types of property 'foo' are incompatible.
            Type 'number | undefined' is not assignable to type 'number'.
              Type 'undefined' is not assignable to type 'number'.

We encountered this in a very large React/Redux project after attempting to update to 3.7.2.
I simplified the repro case as best I could.
Apologies for the title, I don't know the best terminology for this situation.

Playground Link:
Link
Note that the playground doesn't show a behavior change from 3.7.2 to 3.6.3, but VS Code and the command-line tsc do.

Related Issues:
#33872 - Seems similar and broke at the same time

[RyanLamanskyInsite]

Although the original issue description focused on stable releases of TypeScript, 3.7.1-rc is the most recent unstable release that's compatible with our code. We wanted access to 3.7's new features, so that's what we're running, but we're not very comfortable using this version in a production environment.

[weswigham]

In

type Q = { foo: number | undefined } extends ({ foo?: undefined } | { foo: number })
  ? true
  : false;

Q is true.

In

type Q = { foo?: number | undefined } extends ({ foo?: undefined } | { foo: number })
  ? true
  : false;

Q is false.

The second result seems questionable, as our union coverage rule should know that if foo is present, it's always assignable to both branches of the union (like in the first case), and if it's not present, it's assignable to the first branch of the union. I haven't tracked it down, but the regression was probably caused by us picking up the optionality of the mapped type member, where we had neglected to pick it up before.

cc @rbuckton - was the union-discriminant assignability coverage code geared to handling an optional undefined discriminant member yet?

[RyanLamanskyInsite]

We're a month away from releasing an extensible platform that's (still) built on 3.7.1-rc due to this issue. Post-launch, upgrading TypeScript is a breaking change. We can engineer around it to get on a newer version, but it would be great if we don't have to!