This PR improves type inference for multiple object literals occurring in the same context. When multiple object literal types contribute to a union type, we nownormalize the object literal types such that all properties are present in each constituent of the union type. For example:

constobj=test ?{text:"hello"} :{};// { text: string } | { text?: undefined }consts=obj.text;// string | undefined

Previously we inferred type{} forobj and the second line subsequently caused an error becauseobj would appear to have no properties. That obviously wasn't ideal.

The key insight behind this PR is that forobject literal types we know that unspecified properties always have the valueundefined. This is unlike regular object types where unspecified properties might have any value. Based on this fact we implement the following new rules:

• When checking a type relationship between a source type S and a target type T, if T is an object literal type, any excess properties in S are required to have typeundefined (normally such excess properties are permitted to have any type).
• When widening a union type, we normalize all constituent types originating in object literals by adding optional properties of typeundefined to each constituent as appropriate such that all constituents have the same set of property names.
• When inferring multiple object literal types for a type parameter, the object literal types are normalized into a single inferred union type.

An example of object literal normalization:

// let obj: { a: number, b: number } |//     { a: string, b?: undefined } |//     { a?: undefined, b?: undefined }letobj=[{a:1,b:2},{a:"abc"},{}][0];obj.a;// string | number | undefinedobj.b;// number | undefined

Nested object literals are likewise normalized:

// let obj: { kind: string, pos: { x: number, y: number, a?: undefined, b?: undefined }} |//     { kind: string, pos: { a: string, x?: undefined, y?: undefined, b?: undefined } | { b: number, x?: undefined, y?: undefined, a?: undefined }}letobj=[{kind:'a',pos:{x:0,y:0}},{kind:'b',pos:test ?{a:"x"} :{b:0}}][0];obj.kind;// stringobj.pos;// { x: number, y: number, a?: undefined, b?: undefined } | { a: string, x?: undefined, y?: undefined, b?: undefined } | { b: number, x?: undefined, y?: undefined, a?: undefined }obj.pos.x;// number | undefinedobj.pos.y;// number | undefinedobj.pos.a;// string | undefinedobj.pos.b;// number | undefined

Multiple object literal type inferences for the same type parameter are collapsed into a single normalized union type:

declarefunctionf<T>(...items:T[]):T;// let obj: { a: number, b: number } |//     { a: string, b?: undefined } |//     { a?: undefined, b?: undefined }letobj=f({a:1,b:2},{a:"abc"},{});obj.a;// string | number | undefinedobj.b;// number | undefined

Fixes#19236.