Object spread hotspot N=25

// Object spread hotspot benchmark.
// Exercises repeated object-literal spread inference and property merging.

interface SpreadBase {
    common: string;
    enabled: boolean;
}

interface SpreadInput0 extends SpreadBase {
    value0: number;
    nested0: { readonly id: number; name: string };
}

declare const spreadInput0: SpreadInput0;
const spreadMerged0 = {
    ...spreadInput0,
    extra0: spreadInput0.value0,
    nested0: { ...spreadInput0.nested0, name: spreadInput0.common },
};
type SpreadResult0 = typeof spreadMerged0;
const spreadCheck0: SpreadResult0 = spreadMerged0;

interface SpreadInput1 extends SpreadBase {
    value1: number;
    nested1: { readonly id: number; name: string };
}

declare const spreadInput1: SpreadInput1;
const spreadMerged1 = {
    ...spreadInput1,
    extra1: spreadInput1.value1,
    nested1: { ...spreadInput1.nested1, name: spreadInput1.common },
};
type SpreadResult1 = typeof spreadMerged1;
const spreadCheck1: SpreadResult1 = spreadMerged1;

interface SpreadInput2 extends SpreadBase {
    value2: number;
    nested2: { readonly id: number; name: string };
}

declare const spreadInput2: SpreadInput2;
const spreadMerged2 = {
    ...spreadInput2,
    extra2: spreadInput2.value2,
    nested2: { ...spreadInput2.nested2, name: spreadInput2.common },
};
type SpreadResult2 = typeof spreadMerged2;
const spreadCheck2: SpreadResult2 = spreadMerged2;

interface SpreadInput3 extends SpreadBase {
    value3: number;
    nested3: { readonly id: number; name: string };
}

declare const spreadInput3: SpreadInput3;
const spreadMerged3 = {
    ...spreadInput3,
    extra3: spreadInput3.value3,
    nested3: { ...spreadInput3.nested3, name: spreadInput3.common },
};
type SpreadResult3 = typeof spreadMerged3;
const spreadCheck3: SpreadResult3 = spreadMerged3;

interface SpreadInput4 extends SpreadBase {
    value4: number;
    nested4: { readonly id: number; name: string };
}

declare const spreadInput4: SpreadInput4;
const spreadMerged4 = {
    ...spreadInput4,
    extra4: spreadInput4.value4,
    nested4: { ...spreadInput4.nested4, name: spreadInput4.common },
};
type SpreadResult4 = typeof spreadMerged4;
const spreadCheck4: SpreadResult4 = spreadMerged4;

interface SpreadInput5 extends SpreadBase {
    value5: number;
    nested5: { readonly id: number; name: string };
}

declare const spreadInput5: SpreadInput5;
const spreadMerged5 = {
    ...spreadInput5,
    extra5: spreadInput5.value5,
    nested5: { ...spreadInput5.nested5, name: spreadInput5.common },
};
type SpreadResult5 = typeof spreadMerged5;
const spreadCheck5: SpreadResult5 = spreadMerged5;

interface SpreadInput6 extends SpreadBase {
    value6: number;
    nested6: { readonly id: number; name: string };
}

declare const spreadInput6: SpreadInput6;
const spreadMerged6 = {
    ...spreadInput6,
    extra6: spreadInput6.value6,
    nested6: { ...spreadInput6.nested6, name: spreadInput6.common },
};
type SpreadResult6 = typeof spreadMerged6;
const spreadCheck6: SpreadResult6 = spreadMerged6;

interface SpreadInput7 extends SpreadBase {
    value7: number;
    nested7: { readonly id: number; name: string };
}

declare const spreadInput7: SpreadInput7;
const spreadMerged7 = {
    ...spreadInput7,
    extra7: spreadInput7.value7,
    nested7: { ...spreadInput7.nested7, name: spreadInput7.common },
};
type SpreadResult7 = typeof spreadMerged7;
const spreadCheck7: SpreadResult7 = spreadMerged7;

interface SpreadInput8 extends SpreadBase {
    value8: number;
    nested8: { readonly id: number; name: string };
}

declare const spreadInput8: SpreadInput8;
const spreadMerged8 = {
    ...spreadInput8,
    extra8: spreadInput8.value8,
    nested8: { ...spreadInput8.nested8, name: spreadInput8.common },
};
type SpreadResult8 = typeof spreadMerged8;
const spreadCheck8: SpreadResult8 = spreadMerged8;

interface SpreadInput9 extends SpreadBase {
    value9: number;
    nested9: { readonly id: number; name: string };
}

declare const spreadInput9: SpreadInput9;
const spreadMerged9 = {
    ...spreadInput9,
    extra9: spreadInput9.value9,
    nested9: { ...spreadInput9.nested9, name: spreadInput9.common },
};
type SpreadResult9 = typeof spreadMerged9;
const spreadCheck9: SpreadResult9 = spreadMerged9;

interface SpreadInput10 extends SpreadBase {
    value10: number;
    nested10: { readonly id: number; name: string };
}

declare const spreadInput10: SpreadInput10;
const spreadMerged10 = {
    ...spreadInput10,
    extra10: spreadInput10.value10,
    nested10: { ...spreadInput10.nested10, name: spreadInput10.common },
};
type SpreadResult10 = typeof spreadMerged10;
const spreadCheck10: SpreadResult10 = spreadMerged10;

interface SpreadInput11 extends SpreadBase {
    value11: number;
    nested11: { readonly id: number; name: string };
}

declare const spreadInput11: SpreadInput11;
const spreadMerged11 = {
    ...spreadInput11,
    extra11: spreadInput11.value11,
    nested11: { ...spreadInput11.nested11, name: spreadInput11.common },
};
type SpreadResult11 = typeof spreadMerged11;
const spreadCheck11: SpreadResult11 = spreadMerged11;

interface SpreadInput12 extends SpreadBase {
    value12: number;
    nested12: { readonly id: number; name: string };
}

declare const spreadInput12: SpreadInput12;
const spreadMerged12 = {
    ...spreadInput12,
    extra12: spreadInput12.value12,
    nested12: { ...spreadInput12.nested12, name: spreadInput12.common },
};
type SpreadResult12 = typeof spreadMerged12;
const spreadCheck12: SpreadResult12 = spreadMerged12;

interface SpreadInput13 extends SpreadBase {
    value13: number;
    nested13: { readonly id: number; name: string };
}

declare const spreadInput13: SpreadInput13;
const spreadMerged13 = {
    ...spreadInput13,
    extra13: spreadInput13.value13,
    nested13: { ...spreadInput13.nested13, name: spreadInput13.common },
};
type SpreadResult13 = typeof spreadMerged13;
const spreadCheck13: SpreadResult13 = spreadMerged13;

interface SpreadInput14 extends SpreadBase {
    value14: number;
    nested14: { readonly id: number; name: string };
}

declare const spreadInput14: SpreadInput14;
const spreadMerged14 = {
    ...spreadInput14,
    extra14: spreadInput14.value14,
    nested14: { ...spreadInput14.nested14, name: spreadInput14.common },
};
type SpreadResult14 = typeof spreadMerged14;
const spreadCheck14: SpreadResult14 = spreadMerged14;

interface SpreadInput15 extends SpreadBase {
    value15: number;
    nested15: { readonly id: number; name: string };
}

declare const spreadInput15: SpreadInput15;
const spreadMerged15 = {
    ...spreadInput15,
    extra15: spreadInput15.value15,
    nested15: { ...spreadInput15.nested15, name: spreadInput15.common },
};
type SpreadResult15 = typeof spreadMerged15;
const spreadCheck15: SpreadResult15 = spreadMerged15;

interface SpreadInput16 extends SpreadBase {
    value16: number;
    nested16: { readonly id: number; name: string };
}

declare const spreadInput16: SpreadInput16;
const spreadMerged16 = {
    ...spreadInput16,
    extra16: spreadInput16.value16,
    nested16: { ...spreadInput16.nested16, name: spreadInput16.common },
};
type SpreadResult16 = typeof spreadMerged16;
const spreadCheck16: SpreadResult16 = spreadMerged16;

interface SpreadInput17 extends SpreadBase {
    value17: number;
    nested17: { readonly id: number; name: string };
}

declare const spreadInput17: SpreadInput17;
const spreadMerged17 = {
    ...spreadInput17,
    extra17: spreadInput17.value17,
    nested17: { ...spreadInput17.nested17, name: spreadInput17.common },
};
type SpreadResult17 = typeof spreadMerged17;
const spreadCheck17: SpreadResult17 = spreadMerged17;

interface SpreadInput18 extends SpreadBase {
    value18: number;
    nested18: { readonly id: number; name: string };
}

declare const spreadInput18: SpreadInput18;
const spreadMerged18 = {
    ...spreadInput18,
    extra18: spreadInput18.value18,
    nested18: { ...spreadInput18.nested18, name: spreadInput18.common },
};
type SpreadResult18 = typeof spreadMerged18;
const spreadCheck18: SpreadResult18 = spreadMerged18;

interface SpreadInput19 extends SpreadBase {
    value19: number;
    nested19: { readonly id: number; name: string };
}

declare const spreadInput19: SpreadInput19;
const spreadMerged19 = {
    ...spreadInput19,
    extra19: spreadInput19.value19,
    nested19: { ...spreadInput19.nested19, name: spreadInput19.common },
};
type SpreadResult19 = typeof spreadMerged19;
const spreadCheck19: SpreadResult19 = spreadMerged19;

interface SpreadInput20 extends SpreadBase {
    value20: number;
    nested20: { readonly id: number; name: string };
}

declare const spreadInput20: SpreadInput20;
const spreadMerged20 = {
    ...spreadInput20,
    extra20: spreadInput20.value20,
    nested20: { ...spreadInput20.nested20, name: spreadInput20.common },
};
type SpreadResult20 = typeof spreadMerged20;
const spreadCheck20: SpreadResult20 = spreadMerged20;

interface SpreadInput21 extends SpreadBase {
    value21: number;
    nested21: { readonly id: number; name: string };
}

declare const spreadInput21: SpreadInput21;
const spreadMerged21 = {
    ...spreadInput21,
    extra21: spreadInput21.value21,
    nested21: { ...spreadInput21.nested21, name: spreadInput21.common },
};
type SpreadResult21 = typeof spreadMerged21;
const spreadCheck21: SpreadResult21 = spreadMerged21;

interface SpreadInput22 extends SpreadBase {
    value22: number;
    nested22: { readonly id: number; name: string };
}

declare const spreadInput22: SpreadInput22;
const spreadMerged22 = {
    ...spreadInput22,
    extra22: spreadInput22.value22,
    nested22: { ...spreadInput22.nested22, name: spreadInput22.common },
};
type SpreadResult22 = typeof spreadMerged22;
const spreadCheck22: SpreadResult22 = spreadMerged22;

interface SpreadInput23 extends SpreadBase {
    value23: number;
    nested23: { readonly id: number; name: string };
}

declare const spreadInput23: SpreadInput23;
const spreadMerged23 = {
    ...spreadInput23,
    extra23: spreadInput23.value23,
    nested23: { ...spreadInput23.nested23, name: spreadInput23.common },
};
type SpreadResult23 = typeof spreadMerged23;
const spreadCheck23: SpreadResult23 = spreadMerged23;

interface SpreadInput24 extends SpreadBase {
    value24: number;
    nested24: { readonly id: number; name: string };
}

declare const spreadInput24: SpreadInput24;
const spreadMerged24 = {
    ...spreadInput24,
    extra24: spreadInput24.value24,
    nested24: { ...spreadInput24.nested24, name: spreadInput24.common },
};
type SpreadResult24 = typeof spreadMerged24;
const spreadCheck24: SpreadResult24 = spreadMerged24;