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 =(

从 issue 中的 TypeScript Playground 复现开始，并与相关 issue 32540、29133 和 14829 进行比较。跟踪泛型返回类型和约束的推断；当推断出的调用在所示情况下拒绝 string|number 和 1，同时仍接受有效的 string 推断时，即可完成。