Constraints should be inference sites for other type parameters

[vsiao]

TypeScript Version:

1.8.0

Code

interface Class<T> {
    new(): T;
}
declare function create1<T>(ctor: Class<T>): T;
declare function create2<T, C extends Class<T>>(ctor: C): T;

class A {}
let a1 = create1(A); // a: A --> OK
let a2 = create2(A); // a: {} --> Should be A

Context

The example above is simplified to illustrate the difference between create1 and create2. I need both type parameters for the use case I have in mind (React) because it returns a type which is parameterized by both T and C:

declare function createElement<T, C extends Class<T>>(type: C): Element<T, C>;
var e = createElement(A); // e: Element<{}, typeof A> --> Should be Element<A, typeof A>

declare function render<T>(e: Element<T, any>): T;
var a = render(e); // a: {} --> Should be A

Again, this is simplified, but the motivation is to improve the return type inference of ReactDOM.render.

[vsiao]

#6783 may be related, but I'm not sure.

[vsiao]

@RyanCavanaugh any thoughts? Do you think this is a bug?

[vsiao]

I should note that the very same issue is preventing me from removing React.Props<T> entirely. Currently, React developers explicitly declare the instance type T, and react.d.ts infers the props type P. It doesn't seem like I can infer both P and T simultaneously:

declare function createElement<P, T extends Component<P, {}>>(
    type: ComponentClass<P>,
    props?: P & { key?: Key, ref?: Ref<T> },
    ...children: ReactNode[]): ReactElement<P>;

interface FooProps {
    foo: string;
}
class Foo extends Component<FooProps, {}> {
    bar() { }
}

// <P, T> inferred as <{}, Foo> --> Should be <FooProps, Foo>
createElement(Foo, {
    ref: foo => foo.bar(), // OK
}); // OK -> Should be ERROR (missing property foo)

cc @jbrantly

[jbrantly]

Not sure how much I can add atm except to say this is related.

[RyanCavanaugh]

I need someone more informed on generic type inference to weigh in here.

My speculation is that the root cause is because constraints aren't considered inference sites, but they'd be straightforward to add.

[vsiao]

Thanks, that makes sense. I changed the name of this issue to better reflect the problem.

[JHawkley]

I was able to fool the type-system to behave properly, at least when working with constructor functions, by using a union type. Modifying @vsiao's example:

interface Class<T> { new(): T; }
// Note the new type for 'ctor': C & (new(...args) => T)
declare function create2<T, C extends Class<T>>(ctor: C & (new() => T)): T;
class A {}
let a2 = create2(A); // a2: A, which is as it should be.

This work-around has a bad smell to it, but its the only thing I've found to work with the 1.8 compiler.

If you end up using it with constructors that require parameters, make sure you use a type that takes them into account, like new(...args) => T, instead.

[vsiao]

Wow, great find @JHawkley. That works for my use case.