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 @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.

[waynebloss]

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.