Incorrect type inference

[MichaelTamm]

TypeScript Version: 3.1.0-rc.20180911

Search Terms:

TS2459

Code

function test_driver<F extends Object, R extends Object>({ arrange, act, assert }: {
    arrange: () => F
    act: (fixture: F) => R
    assert: (fixture_and_result: F & R) => void
}) {
    const f = arrange();
    const r = act(f);
    assert(Object.assign({}, f, r));
}

function test() {
    test_driver({
        arrange: () => ({ foo: "foo" }),
        act: ({ foo }) => ({bar: foo + "bar"}),
        assert: ({ foo, bar }) => {
            // foo is "foo" and bar is "foobar" here
        }
    });
}

... should be compiled with --target es2017 because of the Object.assign(...) statement

Expected behavior:
Should compile without error

Actual behavior:

...:15:25 - error TS2459: Type '{ foo: string; }' has no property 'bar' and no string index signature.

15         assert: ({ foo, bar }) => {
                           ~~~

Playground Link: Demo on TypeScript Playground

[ahejlsberg]

This is a design limitation. Our type inference algorithm allows inferences to flow left to right between separate arguments, but not between properties in an object literal. Effectively, we can make an inference for F because the arrow function specified for the arrange property doesn't depend on anything, but then when it comes time to assign types to the parameters of the arrow functions specified for act and assert, we have not yet made an inference for R and so we end up with {}. It works if you add a type annotation in the second arrow function because we can then make inferences for both F and R before assigning types to the parameters in the last arrow function:

function test() {
    test_driver({
        arrange: () => ({ foo: "foo" }),
        act: ({ foo }: { foo: string }) => ({bar: foo + "bar"}),
        assert: ({ foo, bar }) => {
            // foo is "foo" and bar is "foobar" here
        }
    });
}

Also, your example works with no type annotations if you convert arrange, act, and assert to distinct parameters and use distinct arguments in the call to test_driver.

Would be nice to do better, but it isn't a simple fix.