Include missing optional properties in contextually typed object literals

[ahejlsberg]

Fixes #1723.

In #919 we tightened the subtyping rules to require optional properties to be present in subtypes. That's still the right thing to do, but it can have unintended consequences for overload resolution (which relies on subtyping) in combination with object literals.

With this PR, when an object literal is contextually typed by a type T, any optional properties in T that are omitted in the object literal are included in the resulting type, thus ensuring the resulting type is a subtype of T when all that was omitted was optional properties (whew!). For example

interface Item {
    name: string;
    description?: string;
}

declare function foo(item: Item): string;
declare function foo(item: any): number;

var x = foo({ name: "Sprocket" });  // x of type string
var y = foo({ name: "Sprocket", description: "Bumpy wheel" });  // y of type string
var z = foo({ a: 10 });  // z of type number

In the first call to foo above, contextual typing of the object literal adds the missing optional property. Thus, the argument expression becomes a subtype of Item, and the first overload is chosen (as one would expect).

This change does at times affect error reporting. For example

var f: Item = { naem: "Hello" };

Here we'll now report

t.ts(11,5): error TS2322: Type '{ naem: string; description?: string; }' is not assignable to type 'Item'.
  Property 'name' is missing in type '{ naem: string; description?: string; }'.

Depending on your point of view it may be surprising that the reported type includes an optional property that you didn't actually write (but which is there because of your context).

[JsonFreeman]

This breaks the following:

declare function foo<T>(param: { [s: string]: T; x?: T }): T;
var f = foo({ y: "" }); // returns type string | T
var g = foo({ }); // returns type T

By copying the type of x from the parameter type to the argument, it gets to participate in the union type for the indexer. So the type parameter leaks.

[JsonFreeman]

Simpler example, with no indexer:

declare function foo<T>(param: { x?: T }): T;
var f = foo({ }); returns T

[ahejlsberg]

@JsonFreeman Good catch on the leaky type parameter. Fixed now.

[ahejlsberg]

@JsonFreeman That should do it.

[JsonFreeman]

👍