Function argument with object rest spread generates wrong type error

[zamb3zi]

TypeScript Version: 2.9.1-insiders.20180525

Search Terms: argument rest spread object

Code

const f = (options: { foo?: number }) => { };
let o: {
    foo?: number;
    bar?: string
} = {};
f(o); // ok
f({ ...o }); // error: bar does not exist in type { foo?: number }.
f({ ...o, foo: 5 }); // same error. this is the use case.
let p = { ...o };
f(p); // ok
f(p = { ...o, foo: 5 }); // also ok

Expected behavior:

{...o} has the same type as o and should be interchangeable as function argument.

Actual behavior:

Incorrect error is generated.

Playground Link:

Playground

Related Issues:

[RyanCavanaugh]

@sandersn please apply the appropriate label to this issue 👍

[sandersn]

Duplicate of #19775

Probably won't be fixed until we have exact types, because people who don't want excess property errors currently have two workarounds (a [deprecated] compiler flag and extract-local), but people who do want excess property errors would have no way to cause them if this bug is fixed.

[zamb3zi]

Thanks a lot and sorry I couldn't find the duplicate. For anyone else landing here, some workarounds are:

const f = <O extends { foo?: number }>(options: O) => { };

OR

const f = (options: { foo?: number }) => { };
const ignoreExcess = <T>(arg: T) => arg;
let o: {
    foo?: number;
    bar?: string
} = {};
f(ignoreExcess({ ...o, foo: 5 })); // ok

[sandersn]

You can also do

const f = (options: { foo?: number }) => { };
let o: {
    foo?: number;
    bar?: string
} = {};
const ignoreExcess = { ...o, foo: 5 };
f(ignoreExcess); // ok

Which is probably cheaper at runtime, depending on how much the VM tries to optimise.