Correlated type constraint breaks under return type inference

TypeScript Version: 3.5.1

Search Terms:

return type, generic, constraint, assignable, correlated type

Code

type XStr = {x:string};
type XNum = {x:number};
type U = XStr|XNum;
type Args = { str : XStr, num : XNum };

declare function foo<
    ReturnT extends U,
    ValueT extends ReturnT["x"]
> (
    f : (args : Args) => ReturnT,
    value : ValueT
) : void;

/*
    Error as expected.

    Type 'string | number' does not satisfy the constraint 'string'.
    Type 'number' is not assignable to type 'string'.
*/
foo<XStr, string|number>(
    (args:Args) => args.str,
    ""
);
//Inferred type, foo<XStr, string | number>
foo(
    args => args.str,
    //Expected: Error
    //Actual: OK
    "" as string|number
);
//Inferred type, foo<XStr, string>
foo(
    //Added explicit type annotation to function params
    (args:Args) => args.str,
    /*
        Error as expected.

        Type 'string | number' does not satisfy the constraint 'string'.
        Type 'number' is not assignable to type 'string'.
    */
    "" as string|number
);

/////

/*
    Error as expected.

    Type '1' does not satisfy the constraint 'string'.
*/
foo<XStr, 1>(
    (args:Args) => args.str,
    1
);
//Inferred type, foo<XStr, 1>
foo(
    args => args.str,
    //Expected: Error
    //Actual: OK
    1
);
//Inferred type, foo<XStr, string>
foo(
    //Added explicit type annotation to function params
    (args:Args) => args.str,
    /*
        Error as expected.

        Type '1' does not satisfy the constraint 'string'.
    */
    1
);

Expected behavior:

I'm just calling it a correlated type because it reminds me of correlated subqueries from SQL.

1. The constraint type of ValueT is dependent on the type of ReturnT.
2. When f does not have parameters, or all parameters are explicitly annotated,
   ValueT is inferred correctly.
3. When f has parameters that are not explicitly annotated,
   ValueT is inferred incorrectly.
4. Attempting to explicitly set invalid type paramters will error as expected.

• foo<XStr, string|number> should not be allowed
• foo<XStr, 1> should not be allowed

Actual behavior:

• foo<XStr, string|number> is allowed under inference
• foo<XStr, 1> is allowed under inference

Playground Link:

Playground

Related Issues:

https://github.com/microsoft/TypeScript/issues/32540#issuecomment-520193240

https://github.com/microsoft/TypeScript/issues/29133

A different, more complex example,
https://github.com/microsoft/TypeScript/issues/14829#issuecomment-520191642

---

[Edit]

Can someone come up with a better name for this?

---

I'm working on rewriting my type-safe SQL builder library and it relies on the return type of generic functions being inferred correctly. But it seems like return type inference just breaks in so many unexpected ways.

Anonymous callback functions are used a lot for building the WHERE, ORDER BY, GROUP BY, HAVING, JOIN, etc. clauses.

Since return type inference for generic functions is not robust, it's basically a blocker for me =(

Start with the TypeScript playground reproduction in the issue and compare it with related issues 32540, 29133, and 14829. Trace generic return-type and constraint inference; done when inferred calls reject string|number and 1 in the shown cases while valid string inference remains accepted.