=== tests/cases/conformance/types/spread/objectSpreadScenarios.ts ===
interface A1 { a: boolean }
>A1 : A1
>a : boolean

interface B1 { b: number };
>B1 : B1
>b : number

function override<U>(initial: U, override: U): { ...U, ...U } {
>override : <U>(initial: U, override: U) => { ...U }
>U : U
>initial : U
>U : U
>override : U
>U : U
>U : U
>U : U

    return { ...initial, ...override };
>{ ...initial, ...override } : { ...U }
>initial : any
>override : any
}
function update<U>(this: { u: { ...U } }, override: U): void {
>update : <U>(this: { u: { ...U }; }, override: U) => void
>U : U
>this : { u: { ...U }; }
>u : { ...U }
>U : U
>override : U
>U : U

    this.u = { ...this.u, ...override };
>this.u = { ...this.u, ...override } : { ...U }
>this.u : { ...U }
>this : { u: { ...U }; }
>u : { ...U }
>{ ...this.u, ...override } : { ...U }
>this.u : { ...U }
>this : { u: { ...U }; }
>u : { ...U }
>override : any
}
function mixin<T, U>(one: T, two: U): { ...T, ...U } {
>mixin : <T, U>(one: T, two: U) => { ...T; ...U }
>T : T
>U : U
>one : T
>T : T
>two : U
>U : U
>T : T
>U : U

    return { ...one, ...two };
>{ ...one, ...two } : { ...T; ...U }
>one : any
>two : any
}
let a1: A1 = { a: true };
>a1 : A1
>A1 : A1
>{ a: true } : { a: true; }
>a : boolean
>true : true

let b1: B1 = { b: 101 };
>b1 : B1
>B1 : B1
>{ b: 101 } : { b: number; }
>b : number
>101 : 101

a1 = override(a1, { a: false });
>a1 = override(a1, { a: false }) : { a: boolean; }
>a1 : A1
>override(a1, { a: false }) : { a: boolean; }
>override : <U>(initial: U, override: U) => { ...U }
>a1 : A1
>{ a: false } : { a: false; }
>a : boolean
>false : false

let host = { u: a1, update };
>host : { u: A1; update: <U>(this: { u: { ...U }; }, override: U) => void; }
>{ u: a1, update } : { u: A1; update: <U>(this: { u: { ...U }; }, override: U) => void; }
>u : A1
>a1 : A1
>update : <U>(this: { u: { ...U }; }, override: U) => void

host.update({ a: false });
>host.update({ a: false }) : void
>host.update : <U>(this: { u: { ...U }; }, override: U) => void
>host : { u: A1; update: <U>(this: { u: { ...U }; }, override: U) => void; }
>update : <U>(this: { u: { ...U }; }, override: U) => void
>{ a: false } : { a: false; }
>a : boolean
>false : false

let mixed = mixin(a1, b1);
>mixed : { b: number; a: boolean; }
>mixin(a1, b1) : { b: number; a: boolean; }
>mixin : <T, U>(one: T, two: U) => { ...T; ...U }
>a1 : A1
>b1 : B1

