objectSpread.symbols

=== tests/cases/conformance/types/spread/objectSpread.ts ===
let o = { a: 1, b: 'no' }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>a : Symbol(a, Decl(objectSpread.ts, 0, 9))
>b : Symbol(b, Decl(objectSpread.ts, 0, 15))

let o2 = { b: 'yes', c: true }
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))
>b : Symbol(b, Decl(objectSpread.ts, 1, 10))
>c : Symbol(c, Decl(objectSpread.ts, 1, 20))

let swap = { a: 'yes', b: -1 };
>swap : Symbol(swap, Decl(objectSpread.ts, 2, 3))
>a : Symbol(a, Decl(objectSpread.ts, 2, 12))
>b : Symbol(b, Decl(objectSpread.ts, 2, 22))

let addAfter: { a: number, b: string, c: boolean } =
>addAfter : Symbol(addAfter, Decl(objectSpread.ts, 4, 3))
>a : Symbol(a, Decl(objectSpread.ts, 4, 15))
>b : Symbol(b, Decl(objectSpread.ts, 4, 26))
>c : Symbol(c, Decl(objectSpread.ts, 4, 37))

    { ...o, c: false }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>c : Symbol(c, Decl(objectSpread.ts, 5, 11))

let addBefore: { a: number, b: string, c: boolean } =
>addBefore : Symbol(addBefore, Decl(objectSpread.ts, 6, 3))
>a : Symbol(a, Decl(objectSpread.ts, 6, 16))
>b : Symbol(b, Decl(objectSpread.ts, 6, 27))
>c : Symbol(c, Decl(objectSpread.ts, 6, 38))

    { c: false, ...o }
>c : Symbol(c, Decl(objectSpread.ts, 7, 5))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))

// Note: ignore still changes the order that properties are printed
let ignore: { a: number, b: string } =
>ignore : Symbol(ignore, Decl(objectSpread.ts, 9, 3))
>a : Symbol(a, Decl(objectSpread.ts, 9, 13))
>b : Symbol(b, Decl(objectSpread.ts, 9, 24))

    { b: 'ignored', ...o }
>b : Symbol(b, Decl(objectSpread.ts, 10, 5))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))

let override: { a: number, b: string } =
>override : Symbol(override, Decl(objectSpread.ts, 11, 3))
>a : Symbol(a, Decl(objectSpread.ts, 11, 15))
>b : Symbol(b, Decl(objectSpread.ts, 11, 26))

    { ...o, b: 'override' }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>b : Symbol(b, Decl(objectSpread.ts, 12, 11))

let nested: { a: number, b: boolean, c: string } =
>nested : Symbol(nested, Decl(objectSpread.ts, 13, 3))
>a : Symbol(a, Decl(objectSpread.ts, 13, 13))
>b : Symbol(b, Decl(objectSpread.ts, 13, 24))
>c : Symbol(c, Decl(objectSpread.ts, 13, 36))

    { ...{ a: 3, ...{ b: false, c: 'overriden' } }, c: 'whatever' }
>a : Symbol(a, Decl(objectSpread.ts, 14, 10))
>b : Symbol(b, Decl(objectSpread.ts, 14, 21))
>c : Symbol(c, Decl(objectSpread.ts, 14, 31))
>c : Symbol(c, Decl(objectSpread.ts, 14, 51))

let combined: { a: number, b: string, c: boolean } =
>combined : Symbol(combined, Decl(objectSpread.ts, 15, 3))
>a : Symbol(a, Decl(objectSpread.ts, 15, 15))
>b : Symbol(b, Decl(objectSpread.ts, 15, 26))
>c : Symbol(c, Decl(objectSpread.ts, 15, 37))

    { ...o, ...o2 }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))

let combinedBefore: { a: number, b: string, c: boolean } =
>combinedBefore : Symbol(combinedBefore, Decl(objectSpread.ts, 17, 3))
>a : Symbol(a, Decl(objectSpread.ts, 17, 21))
>b : Symbol(b, Decl(objectSpread.ts, 17, 32))
>c : Symbol(c, Decl(objectSpread.ts, 17, 43))

    { b: 'ok', ...o, ...o2 }
>b : Symbol(b, Decl(objectSpread.ts, 18, 5))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))

let combinedMid: { a: number, b: string, c: boolean } =
>combinedMid : Symbol(combinedMid, Decl(objectSpread.ts, 19, 3))
>a : Symbol(a, Decl(objectSpread.ts, 19, 18))
>b : Symbol(b, Decl(objectSpread.ts, 19, 29))
>c : Symbol(c, Decl(objectSpread.ts, 19, 40))

    { ...o, b: 'ok', ...o2 }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>b : Symbol(b, Decl(objectSpread.ts, 20, 11))
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))

let combinedAfter: { a: number, b: string, c: boolean } =
>combinedAfter : Symbol(combinedAfter, Decl(objectSpread.ts, 21, 3))
>a : Symbol(a, Decl(objectSpread.ts, 21, 20))
>b : Symbol(b, Decl(objectSpread.ts, 21, 31))
>c : Symbol(c, Decl(objectSpread.ts, 21, 42))

    { ...o, ...o2, b: 'ok' }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))
>b : Symbol(b, Decl(objectSpread.ts, 22, 18))

let combinedNested: { a: number, b: boolean, c: string, d: string } =
>combinedNested : Symbol(combinedNested, Decl(objectSpread.ts, 23, 3))
>a : Symbol(a, Decl(objectSpread.ts, 23, 21))
>b : Symbol(b, Decl(objectSpread.ts, 23, 32))
>c : Symbol(c, Decl(objectSpread.ts, 23, 44))
>d : Symbol(d, Decl(objectSpread.ts, 23, 55))

    { ...{ a: 4, ...{ b: false, c: 'overriden' } }, d: 'actually new', ...{ a: 5, d: 'maybe new' } }
>a : Symbol(a, Decl(objectSpread.ts, 24, 10))
>b : Symbol(b, Decl(objectSpread.ts, 24, 21))
>c : Symbol(c, Decl(objectSpread.ts, 24, 31))
>d : Symbol(d, Decl(objectSpread.ts, 24, 51))
>a : Symbol(a, Decl(objectSpread.ts, 24, 75))
>d : Symbol(d, Decl(objectSpread.ts, 24, 81))

let combinedNestedChangeType: { a: number, b: boolean, c: number } =
>combinedNestedChangeType : Symbol(combinedNestedChangeType, Decl(objectSpread.ts, 25, 3))
>a : Symbol(a, Decl(objectSpread.ts, 25, 31))
>b : Symbol(b, Decl(objectSpread.ts, 25, 42))
>c : Symbol(c, Decl(objectSpread.ts, 25, 54))

    { ...{ a: 1, ...{ b: false, c: 'overriden' } }, c: -1 }
>a : Symbol(a, Decl(objectSpread.ts, 26, 10))
>b : Symbol(b, Decl(objectSpread.ts, 26, 21))
>c : Symbol(c, Decl(objectSpread.ts, 26, 31))
>c : Symbol(c, Decl(objectSpread.ts, 26, 51))

let propertyNested: { a: { a: number, b: string } } =
>propertyNested : Symbol(propertyNested, Decl(objectSpread.ts, 27, 3))
>a : Symbol(a, Decl(objectSpread.ts, 27, 21))
>a : Symbol(a, Decl(objectSpread.ts, 27, 26))
>b : Symbol(b, Decl(objectSpread.ts, 27, 37))

    { a: { ... o } }
>a : Symbol(a, Decl(objectSpread.ts, 28, 5))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))

// accessors don't copy the descriptor
// (which means that readonly getters become read/write properties)
let op = { get a () { return 6 } };
>op : Symbol(op, Decl(objectSpread.ts, 31, 3))
>a : Symbol(a, Decl(objectSpread.ts, 31, 10))

let getter: { a: number, c: number } =
>getter : Symbol(getter, Decl(objectSpread.ts, 32, 3))
>a : Symbol(a, Decl(objectSpread.ts, 32, 13))
>c : Symbol(c, Decl(objectSpread.ts, 32, 24))

    { ...op, c: 7 }
>op : Symbol(op, Decl(objectSpread.ts, 31, 3))
>c : Symbol(c, Decl(objectSpread.ts, 33, 12))

getter.a = 12;
>getter.a : Symbol(a, Decl(objectSpread.ts, 32, 13))
>getter : Symbol(getter, Decl(objectSpread.ts, 32, 3))
>a : Symbol(a, Decl(objectSpread.ts, 32, 13))

// functions result in { }
let spreadFunc = { ...(function () { }) };
>spreadFunc : Symbol(spreadFunc, Decl(objectSpread.ts, 37, 3))

type Header = { head: string, body: string, authToken: string }
>Header : Symbol(Header, Decl(objectSpread.ts, 37, 42))
>head : Symbol(head, Decl(objectSpread.ts, 39, 15))
>body : Symbol(body, Decl(objectSpread.ts, 39, 29))
>authToken : Symbol(authToken, Decl(objectSpread.ts, 39, 43))

function from16326(this: { header: Header }, header: Header, authToken: string): Header {
>from16326 : Symbol(from16326, Decl(objectSpread.ts, 39, 63))
>this : Symbol(this, Decl(objectSpread.ts, 40, 19))
>header : Symbol(header, Decl(objectSpread.ts, 40, 26))
>Header : Symbol(Header, Decl(objectSpread.ts, 37, 42))
>header : Symbol(header, Decl(objectSpread.ts, 40, 44))
>Header : Symbol(Header, Decl(objectSpread.ts, 37, 42))
>authToken : Symbol(authToken, Decl(objectSpread.ts, 40, 60))
>Header : Symbol(Header, Decl(objectSpread.ts, 37, 42))

    return {
        ...this.header,
>this.header : Symbol(header, Decl(objectSpread.ts, 40, 26))
>this : Symbol(this, Decl(objectSpread.ts, 40, 19))
>header : Symbol(header, Decl(objectSpread.ts, 40, 26))

        ...header,
>header : Symbol(header, Decl(objectSpread.ts, 40, 44))

        ...authToken && { authToken }
>authToken : Symbol(authToken, Decl(objectSpread.ts, 40, 60))
>authToken : Symbol(authToken, Decl(objectSpread.ts, 44, 25))
    }
}
// boolean && T results in Partial<T>
function conditionalSpreadBoolean(b: boolean) : { x: number, y: number } {
>conditionalSpreadBoolean : Symbol(conditionalSpreadBoolean, Decl(objectSpread.ts, 46, 1))
>b : Symbol(b, Decl(objectSpread.ts, 48, 34))
>x : Symbol(x, Decl(objectSpread.ts, 48, 49))
>y : Symbol(y, Decl(objectSpread.ts, 48, 60))

    let o = { x: 12, y: 13 }
>o : Symbol(o, Decl(objectSpread.ts, 49, 7))
>x : Symbol(x, Decl(objectSpread.ts, 49, 13))
>y : Symbol(y, Decl(objectSpread.ts, 49, 20))

    o = {
>o : Symbol(o, Decl(objectSpread.ts, 49, 7))

        ...o,
>o : Symbol(o, Decl(objectSpread.ts, 49, 7))

        ...b && { x: 14 }
>b : Symbol(b, Decl(objectSpread.ts, 48, 34))
>x : Symbol(x, Decl(objectSpread.ts, 52, 17))
    }
    let o2 = { ...b && { x: 21 }}
>o2 : Symbol(o2, Decl(objectSpread.ts, 54, 7))
>b : Symbol(b, Decl(objectSpread.ts, 48, 34))
>x : Symbol(x, Decl(objectSpread.ts, 54, 24))

    return o;
>o : Symbol(o, Decl(objectSpread.ts, 49, 7))
}
function conditionalSpreadNumber(nt: number): { x: number, y: number } {
>conditionalSpreadNumber : Symbol(conditionalSpreadNumber, Decl(objectSpread.ts, 56, 1))
>nt : Symbol(nt, Decl(objectSpread.ts, 57, 33))
>x : Symbol(x, Decl(objectSpread.ts, 57, 47))
>y : Symbol(y, Decl(objectSpread.ts, 57, 58))

    let o = { x: 15, y: 16 }
>o : Symbol(o, Decl(objectSpread.ts, 58, 7))
>x : Symbol(x, Decl(objectSpread.ts, 58, 13))
>y : Symbol(y, Decl(objectSpread.ts, 58, 20))

    o = {
>o : Symbol(o, Decl(objectSpread.ts, 58, 7))

        ...o,
>o : Symbol(o, Decl(objectSpread.ts, 58, 7))

        ...nt && { x: nt }
>nt : Symbol(nt, Decl(objectSpread.ts, 57, 33))
>x : Symbol(x, Decl(objectSpread.ts, 61, 18))
>nt : Symbol(nt, Decl(objectSpread.ts, 57, 33))
    }
    let o2 = { ...nt && { x: nt }}
>o2 : Symbol(o2, Decl(objectSpread.ts, 63, 7))
>nt : Symbol(nt, Decl(objectSpread.ts, 57, 33))
>x : Symbol(x, Decl(objectSpread.ts, 63, 25))
>nt : Symbol(nt, Decl(objectSpread.ts, 57, 33))

    return o;
>o : Symbol(o, Decl(objectSpread.ts, 58, 7))
}
function conditionalSpreadString(st: string): { x: string, y: number } {
>conditionalSpreadString : Symbol(conditionalSpreadString, Decl(objectSpread.ts, 65, 1))
>st : Symbol(st, Decl(objectSpread.ts, 66, 33))
>x : Symbol(x, Decl(objectSpread.ts, 66, 47))
>y : Symbol(y, Decl(objectSpread.ts, 66, 58))

    let o = { x: 'hi', y: 17 }
>o : Symbol(o, Decl(objectSpread.ts, 67, 7))
>x : Symbol(x, Decl(objectSpread.ts, 67, 13))
>y : Symbol(y, Decl(objectSpread.ts, 67, 22))

    o = {
>o : Symbol(o, Decl(objectSpread.ts, 67, 7))

        ...o,
>o : Symbol(o, Decl(objectSpread.ts, 67, 7))

        ...st && { x: st }
>st : Symbol(st, Decl(objectSpread.ts, 66, 33))
>x : Symbol(x, Decl(objectSpread.ts, 70, 18))
>st : Symbol(st, Decl(objectSpread.ts, 66, 33))
    }
    let o2 = { ...st && { x: st }}
>o2 : Symbol(o2, Decl(objectSpread.ts, 72, 7))
>st : Symbol(st, Decl(objectSpread.ts, 66, 33))
>x : Symbol(x, Decl(objectSpread.ts, 72, 25))
>st : Symbol(st, Decl(objectSpread.ts, 66, 33))

    return o;
>o : Symbol(o, Decl(objectSpread.ts, 67, 7))
}

// any results in any
let anything: any;
>anything : Symbol(anything, Decl(objectSpread.ts, 77, 3))

let spreadAny = { ...anything };
>spreadAny : Symbol(spreadAny, Decl(objectSpread.ts, 78, 3))
>anything : Symbol(anything, Decl(objectSpread.ts, 77, 3))

// methods are not enumerable
class C { p = 1; m() { } }
>C : Symbol(C, Decl(objectSpread.ts, 78, 32))
>p : Symbol(C.p, Decl(objectSpread.ts, 81, 9))
>m : Symbol(C.m, Decl(objectSpread.ts, 81, 16))

let c: C = new C()
>c : Symbol(c, Decl(objectSpread.ts, 82, 3))
>C : Symbol(C, Decl(objectSpread.ts, 78, 32))
>C : Symbol(C, Decl(objectSpread.ts, 78, 32))

let spreadC: { p: number } = { ...c }
>spreadC : Symbol(spreadC, Decl(objectSpread.ts, 83, 3))
>p : Symbol(p, Decl(objectSpread.ts, 83, 14))
>c : Symbol(c, Decl(objectSpread.ts, 82, 3))

// own methods are enumerable
let cplus: { p: number, plus(): void } = { ...c, plus() { return this.p + 1; } };
>cplus : Symbol(cplus, Decl(objectSpread.ts, 86, 3))
>p : Symbol(p, Decl(objectSpread.ts, 86, 12))
>plus : Symbol(plus, Decl(objectSpread.ts, 86, 23))
>c : Symbol(c, Decl(objectSpread.ts, 82, 3))
>plus : Symbol(plus, Decl(objectSpread.ts, 86, 48))

cplus.plus();
>cplus.plus : Symbol(plus, Decl(objectSpread.ts, 86, 23))
>cplus : Symbol(cplus, Decl(objectSpread.ts, 86, 3))
>plus : Symbol(plus, Decl(objectSpread.ts, 86, 23))

// new field's type conflicting with existing field is OK
let changeTypeAfter: { a: string, b: string } =
>changeTypeAfter : Symbol(changeTypeAfter, Decl(objectSpread.ts, 90, 3))
>a : Symbol(a, Decl(objectSpread.ts, 90, 22))
>b : Symbol(b, Decl(objectSpread.ts, 90, 33))

    { ...o, a: 'wrong type?' }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>a : Symbol(a, Decl(objectSpread.ts, 91, 11))

let changeTypeBefore: { a: number, b: string } =
>changeTypeBefore : Symbol(changeTypeBefore, Decl(objectSpread.ts, 92, 3))
>a : Symbol(a, Decl(objectSpread.ts, 92, 23))
>b : Symbol(b, Decl(objectSpread.ts, 92, 34))

    { a: 'wrong type?', ...o };
>a : Symbol(a, Decl(objectSpread.ts, 93, 5))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))

let changeTypeBoth: { a: string, b: number } =
>changeTypeBoth : Symbol(changeTypeBoth, Decl(objectSpread.ts, 94, 3))
>a : Symbol(a, Decl(objectSpread.ts, 94, 21))
>b : Symbol(b, Decl(objectSpread.ts, 94, 32))

    { ...o, ...swap };
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>swap : Symbol(swap, Decl(objectSpread.ts, 2, 3))

// optional
function container(
>container : Symbol(container, Decl(objectSpread.ts, 95, 22))

    definiteBoolean: { sn: boolean },
>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpread.ts, 98, 19))
>sn : Symbol(sn, Decl(objectSpread.ts, 99, 22))

    definiteString: { sn: string },
>definiteString : Symbol(definiteString, Decl(objectSpread.ts, 99, 37))
>sn : Symbol(sn, Decl(objectSpread.ts, 100, 21))

    optionalString: { sn?: string },
>optionalString : Symbol(optionalString, Decl(objectSpread.ts, 100, 35))
>sn : Symbol(sn, Decl(objectSpread.ts, 101, 21))

    optionalNumber: { sn?: number }) {
>optionalNumber : Symbol(optionalNumber, Decl(objectSpread.ts, 101, 36))
>sn : Symbol(sn, Decl(objectSpread.ts, 102, 21))

    let optionalUnionStops: { sn: string | number | boolean } = { ...definiteBoolean, ...definiteString, ...optionalNumber };
>optionalUnionStops : Symbol(optionalUnionStops, Decl(objectSpread.ts, 103, 7))
>sn : Symbol(sn, Decl(objectSpread.ts, 103, 29))
>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpread.ts, 98, 19))
>definiteString : Symbol(definiteString, Decl(objectSpread.ts, 99, 37))
>optionalNumber : Symbol(optionalNumber, Decl(objectSpread.ts, 101, 36))

    let optionalUnionDuplicates: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...optionalString, ...optionalNumber };
>optionalUnionDuplicates : Symbol(optionalUnionDuplicates, Decl(objectSpread.ts, 104, 7))
>sn : Symbol(sn, Decl(objectSpread.ts, 104, 34))
>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpread.ts, 98, 19))
>definiteString : Symbol(definiteString, Decl(objectSpread.ts, 99, 37))
>optionalString : Symbol(optionalString, Decl(objectSpread.ts, 100, 35))
>optionalNumber : Symbol(optionalNumber, Decl(objectSpread.ts, 101, 36))

    let allOptional: { sn?: string | number } = { ...optionalString, ...optionalNumber };
>allOptional : Symbol(allOptional, Decl(objectSpread.ts, 105, 7))
>sn : Symbol(sn, Decl(objectSpread.ts, 105, 22))
>optionalString : Symbol(optionalString, Decl(objectSpread.ts, 100, 35))
>optionalNumber : Symbol(optionalNumber, Decl(objectSpread.ts, 101, 36))

    // computed property
    let computedFirst: { a: number, b: string, "before everything": number } =
>computedFirst : Symbol(computedFirst, Decl(objectSpread.ts, 108, 7))
>a : Symbol(a, Decl(objectSpread.ts, 108, 24))
>b : Symbol(b, Decl(objectSpread.ts, 108, 35))
>"before everything" : Symbol("before everything", Decl(objectSpread.ts, 108, 46))

        { ['before everything']: 12, ...o, b: 'yes' }
>['before everything'] : Symbol(['before everything'], Decl(objectSpread.ts, 109, 9))
>'before everything' : Symbol(['before everything'], Decl(objectSpread.ts, 109, 9))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>b : Symbol(b, Decl(objectSpread.ts, 109, 42))

    let computedMiddle: { a: number, b: string, c: boolean, "in the middle": number } =
>computedMiddle : Symbol(computedMiddle, Decl(objectSpread.ts, 110, 7))
>a : Symbol(a, Decl(objectSpread.ts, 110, 25))
>b : Symbol(b, Decl(objectSpread.ts, 110, 36))
>c : Symbol(c, Decl(objectSpread.ts, 110, 47))
>"in the middle" : Symbol("in the middle", Decl(objectSpread.ts, 110, 59))

        { ...o, ['in the middle']: 13, b: 'maybe?', ...o2 }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>['in the middle'] : Symbol(['in the middle'], Decl(objectSpread.ts, 111, 15))
>'in the middle' : Symbol(['in the middle'], Decl(objectSpread.ts, 111, 15))
>b : Symbol(b, Decl(objectSpread.ts, 111, 38))
>o2 : Symbol(o2, Decl(objectSpread.ts, 1, 3))

    let computedAfter: { a: number, b: string, "at the end": number } =
>computedAfter : Symbol(computedAfter, Decl(objectSpread.ts, 112, 7))
>a : Symbol(a, Decl(objectSpread.ts, 112, 24))
>b : Symbol(b, Decl(objectSpread.ts, 112, 35))
>"at the end" : Symbol("at the end", Decl(objectSpread.ts, 112, 46))

        { ...o, b: 'yeah', ['at the end']: 14 }
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>b : Symbol(b, Decl(objectSpread.ts, 113, 15))
>['at the end'] : Symbol(['at the end'], Decl(objectSpread.ts, 113, 26))
>'at the end' : Symbol(['at the end'], Decl(objectSpread.ts, 113, 26))
}
// shortcut syntax
let a = 12;
>a : Symbol(a, Decl(objectSpread.ts, 116, 3))

let shortCutted: { a: number, b: string } = { ...o, a }
>shortCutted : Symbol(shortCutted, Decl(objectSpread.ts, 117, 3))
>a : Symbol(a, Decl(objectSpread.ts, 117, 18))
>b : Symbol(b, Decl(objectSpread.ts, 117, 29))
>o : Symbol(o, Decl(objectSpread.ts, 0, 3))
>a : Symbol(a, Decl(objectSpread.ts, 117, 51))

// non primitive
let spreadNonPrimitive = { ...<object>{}};
>spreadNonPrimitive : Symbol(spreadNonPrimitive, Decl(objectSpread.ts, 119, 3))

// generic spreads
function genericSpread<T, U>(t: T, u: U, v: T | U, w: T | { s: string }, obj: { x: number }) {
>genericSpread : Symbol(genericSpread, Decl(objectSpread.ts, 119, 42))
>T : Symbol(T, Decl(objectSpread.ts, 122, 23))
>U : Symbol(U, Decl(objectSpread.ts, 122, 25))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>T : Symbol(T, Decl(objectSpread.ts, 122, 23))
>u : Symbol(u, Decl(objectSpread.ts, 122, 34))
>U : Symbol(U, Decl(objectSpread.ts, 122, 25))
>v : Symbol(v, Decl(objectSpread.ts, 122, 40))
>T : Symbol(T, Decl(objectSpread.ts, 122, 23))
>U : Symbol(U, Decl(objectSpread.ts, 122, 25))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))
>T : Symbol(T, Decl(objectSpread.ts, 122, 23))
>s : Symbol(s, Decl(objectSpread.ts, 122, 59))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))
>x : Symbol(x, Decl(objectSpread.ts, 122, 79))

    let x01 = { ...t };
>x01 : Symbol(x01, Decl(objectSpread.ts, 123, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))

    let x02 = { ...t, ...t };
>x02 : Symbol(x02, Decl(objectSpread.ts, 124, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))

    let x03 = { ...t, ...u };
>x03 : Symbol(x03, Decl(objectSpread.ts, 125, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>u : Symbol(u, Decl(objectSpread.ts, 122, 34))

    let x04 = { ...u, ...t };
>x04 : Symbol(x04, Decl(objectSpread.ts, 126, 7))
>u : Symbol(u, Decl(objectSpread.ts, 122, 34))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))

    let x05 = { a: 5, b: 'hi', ...t };
>x05 : Symbol(x05, Decl(objectSpread.ts, 127, 7))
>a : Symbol(a, Decl(objectSpread.ts, 127, 15))
>b : Symbol(b, Decl(objectSpread.ts, 127, 21))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))

    let x06 = { ...t, a: 5, b: 'hi' };
>x06 : Symbol(x06, Decl(objectSpread.ts, 128, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>a : Symbol(a, Decl(objectSpread.ts, 128, 21))
>b : Symbol(b, Decl(objectSpread.ts, 128, 27))

    let x07 = { a: 5, b: 'hi', ...t, c: true, ...obj };
>x07 : Symbol(x07, Decl(objectSpread.ts, 129, 7))
>a : Symbol(a, Decl(objectSpread.ts, 129, 15))
>b : Symbol(b, Decl(objectSpread.ts, 129, 21))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>c : Symbol(c, Decl(objectSpread.ts, 129, 36))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x09 = { a: 5, ...t, b: 'hi', c: true, ...obj };
>x09 : Symbol(x09, Decl(objectSpread.ts, 130, 7))
>a : Symbol(a, Decl(objectSpread.ts, 130, 15))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>b : Symbol(b, Decl(objectSpread.ts, 130, 27))
>c : Symbol(c, Decl(objectSpread.ts, 130, 36))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x10 = { a: 5, ...t, b: 'hi', ...u, ...obj };
>x10 : Symbol(x10, Decl(objectSpread.ts, 131, 7))
>a : Symbol(a, Decl(objectSpread.ts, 131, 15))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>b : Symbol(b, Decl(objectSpread.ts, 131, 27))
>u : Symbol(u, Decl(objectSpread.ts, 122, 34))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x11 = { ...v };
>x11 : Symbol(x11, Decl(objectSpread.ts, 132, 7))
>v : Symbol(v, Decl(objectSpread.ts, 122, 40))

    let x12 = { ...v, ...obj };
>x12 : Symbol(x12, Decl(objectSpread.ts, 133, 7))
>v : Symbol(v, Decl(objectSpread.ts, 122, 40))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x13 = { ...w };
>x13 : Symbol(x13, Decl(objectSpread.ts, 134, 7))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))

    let x14 = { ...w, ...obj };
>x14 : Symbol(x14, Decl(objectSpread.ts, 135, 7))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x15 = { ...t, ...v };
>x15 : Symbol(x15, Decl(objectSpread.ts, 136, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>v : Symbol(v, Decl(objectSpread.ts, 122, 40))

    let x16 = { ...t, ...w };
>x16 : Symbol(x16, Decl(objectSpread.ts, 137, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))

    let x17 = { ...t, ...w, ...obj };
>x17 : Symbol(x17, Decl(objectSpread.ts, 138, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))
>obj : Symbol(obj, Decl(objectSpread.ts, 122, 72))

    let x18 = { ...t, ...v, ...w };
>x18 : Symbol(x18, Decl(objectSpread.ts, 139, 7))
>t : Symbol(t, Decl(objectSpread.ts, 122, 29))
>v : Symbol(v, Decl(objectSpread.ts, 122, 40))
>w : Symbol(w, Decl(objectSpread.ts, 122, 50))
}