Nsryjdtyk

There is a problem with object literal type.

interface OptionalFoo {

  foo?: number;

}



interface Bar {}



function foobarFn(foobar: OptionalFoo & Bar) {}



foobarFn({ bar: 1 }); // error



foobarFn({ bar: 1 } as { bar: number }); // ok



foobarFn({ bar: 1 } as { bar: 1 }); // ok!

Object literal with inferred type causes type error:

Argument of type '{ bar: number; }' is not assignable to parameter of type 'OptionalFoo & Bar'

But the problem is not the inference itself:

const bar = { bar: 1 }; // inferred { bar: number; }

foobarFn(bar); // ok!?

The same problem with spread syntax vs Object.assign:

foobarFn({...{ bar: 1 }}); // error



foobarFn(Object.assign({}, { bar: 1 })); // ok!?

Is there a way to achieve the behaviour with inferred object literal type (excess property check) without in-place object literal, e.g. with bar variable or function call like Object.assign({ bar: 1 })?

Just to make things clear this is not just about excess property checks. Excess property checks come into play when we assign an object literal directly to a location. In your case all the more surprising behavior occurs when assigning an object indirectly, which would normally be allowed under excess property checks.

function foo(o: { bar: number }) { }

foo({ bar: 0, foo: "" }) // error direct assignment

foo({ bar:0, foo: ""} as { bar:0, foo: "" }) // ok indirect

The surprising part, at least to me is thst another check (the weak type check) does not catch this error. Under weak type checks (as described here) if a type has only optional properties, and we try to assign a type that has no properties in common with it we should get an error:

function foo(o: { bar?: number }) { }

foo({ foo: "" }) // error under excess properties:  Object literal may only specify known properties, and 'foo' does not exist in type

foo({ foo: ""} as { foo: "" }) // error under weak types: Type '{ foo: ""; }' has no properties in common with type '{ bar?: number; }'.

I think this is a hole (I hesitate to say bug not sure if it is by design or not) in weak type checks. A weak type is (according to this PR):

1. Object types with at least one property


2. Where all properties are optional


3. And that do not have a string index signature, number index signature, call signature or construct signature.

However in the implementation of the weak type check for intersections all types of the intersection have to be weak types for the intersection to be a weak type. From compiler code (comments added):

function isWeakType(type: Type): boolean {

    if (type.flags & TypeFlags.Object) {

       // ....

    }

    if (type.flags & TypeFlags.Intersection) {

        /// All intersection members have to be weak

        return every((<IntersectionType>type).types, isWeakType); 

    }

    return false;

}

Since interface Bar {} is not a weak type (as per the first rule, it has no properties) any intersection with it will not be a weak type and will not throw any weak type checking errors. Removing Bar from the intersection will throw errors everywhere you assign an object that has nothing in common with the target .