Regression for inferred unions in generic parameters

[eps1lon]

TypeScript Version: 3.7.0-dev.20190918

Search Terms: infer generic

Code

// simpler react types
declare class Component<P> {
 props: P;
}

export type ComponentClass<P> = {
 new (props: P): Component<P>;
};

export type FunctionComponent<P> = (props: P) => null;

export type ComponentType<P> = FunctionComponent<P> | ComponentClass<P>;

// simpler react-router.d.ts
export interface RouteComponentProps {
 route: string;
}

declare function withRouter<
 P extends RouteComponentProps,
 C extends ComponentType<P>
>(
 component: C & ComponentType<P>
): ComponentClass<Omit<P, keyof RouteComponentProps>>;

interface Props extends RouteComponentProps {
 username: string;
}

declare const MyComponent: ComponentType<Props>;

// If I define `ComponentType` as `ComponentClass<P> | FunctionComponent<P>`:
// Argument of type 'ComponentType<Props>' is not assignable to parameter of type 'ComponentClass<Props> | (ComponentClass<Props> & FunctionComponent<Props>)'.
// If I define `ComponentType` as `FunctionComponent<P> | ComponentClass<P>`:
// Argument of type 'ComponentType<Props>' is not assignable to parameter of type 'FunctionComponent<Props> | (FunctionComponent<Props> & ComponentClass<Props>)'.
withRouter(MyComponent);

C & ComponentType<P> helps inference. For a more comprehensive test suite check the react-router declarations and tests

A fix getting rid of C & ComponentType<P> (DefinitelyTyped/DefinitelyTyped#38326) caused issues when using strictFunctionTypes

Expected behavior:
No type error

Actual behavior:
Throws with a different error message depending on the order of the union members in ComponentType

Playground Link:
playground for 3.5.3

Related Issues:

• how generic type and type inference works changed #33278
• Originally reported in react-router: withRouter fails with ComponentType starting in 3.6.2 DefinitelyTyped/DefinitelyTyped#38271

/cc Oliver Joseph Ash (@OliverJAsh)

[eps1lon]

Oh and

-component: C & ComponentType<P>
+component: C & (C extends ComponentClass<P> ? ComponentClass<P> : FunctionComponent<P>)

fixes any error and passes the full test suite down until 3.0. 3.1 and above will pass while 3.0 will fail.

I'm just trying to use jsdoc in vscode (v1.38.1) to document types and the following doesn't work. Is this the same bug?

My issue is that Intellisense shows function xxx(yyy: any): any for:

/** @param {string | number | (zzz:string)=>string} yyy */
function xxx(yyy) {
 return yyy;
}

Intellisense shows function xxx(yyy: (zzz: string) => string): (zzz: string) => string for:

/** @param {(zzz:string)=>string} yyy */
function xxx(yyy) {
 return yyy;
}

Intellisense shows function xxx(yyy: string | number): string | number for:

/** @param {string | number} yyy */
function xxx(yyy) {
 return yyy;
}

[j-oliveras]

@waynebloss your first code should be wrote as (see the parenthesis around lambda):

/** @param {string | number | ((zzz:string)=>string)} yyy */
function xxx(yyy) {
 return yyy;
}

[weswigham]

I suspect this regressed because of #32558.

[ahejlsberg]

Simpler repro:

type AB<T> = { a: T } | { b: T };

// T & AB<U> normalizes to T & { a: U } | T & { b: U } below
declare function foo<T, U>(obj: T & AB<U>): [T, U];
declare let ab: AB<string>;

let z = foo(ab); // Expect [AB<string>, string]

Regression was indeed caused by #32558.