From ad10ec56c1214ee5a52f1de3f2dce00f0ca3d025 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 19 Oct 2016 15:05:42 -0700 Subject: [PATCH] Update tests w/spread assignability+apparent type --- tests/baselines/reference/objectSpread.js | 8 +- .../baselines/reference/objectSpread.symbols | 16 +-- tests/baselines/reference/objectSpread.types | 40 ++++---- .../reference/objectSpreadGeneric.errors.txt | 49 ++++++---- .../reference/objectSpreadGeneric.js | 36 ++++--- .../reference/objectSpreadIntersection.js | 32 +++--- .../objectSpreadIntersection.symbols | 70 ++++++------- .../reference/objectSpreadIntersection.types | 98 +++++++++---------- .../baselines/reference/objectSpreadUnion.js | 16 +-- .../reference/objectSpreadUnion.symbols | 34 +++---- .../reference/objectSpreadUnion.types | 48 ++++----- .../conformance/types/spread/objectSpread.ts | 6 +- .../types/spread/objectSpreadGeneric.ts | 18 ++-- .../types/spread/objectSpreadIntersection.ts | 24 ++--- .../types/spread/objectSpreadUnion.ts | 12 +-- 15 files changed, 262 insertions(+), 245 deletions(-) diff --git a/tests/baselines/reference/objectSpread.js b/tests/baselines/reference/objectSpread.js index efb73bcb353..359284f9c6c 100644 --- a/tests/baselines/reference/objectSpread.js +++ b/tests/baselines/reference/objectSpread.js @@ -83,8 +83,8 @@ let a = 12; let shortCutted: { a: number, b: string } = { ...o, a } // generics -function f(t: T, u: U): { id: string, ...T, ...U } { - return { id: 'id', ...t, ...u }; +function f(t: T, u: U): { ...T, ...U, id: string } { + return { ...t, ...u, id: 'id' }; } let exclusive: { id: string, a: number, b: string, c: string, d: boolean } = f({ a: 1, b: 'yes' }, { c: 'no', d: false }) @@ -92,7 +92,7 @@ let overlap: { id: string, a: number, b: string } = f({ a: 1 }, { a: 2, b: 'extra' }) let overlapConflict: { id:string, a: string } = f({ a: 1 }, { a: 'mismatch' }) -let overwriteId: { id: boolean, a: number, c: number, d: string } = +let overwriteId: { id: string, a: number, c: number, d: string } = f({ a: 1, id: true }, { c: 1, d: 'no' }) class D { m() { }; q = 2; } @@ -172,7 +172,7 @@ var a = 12; var shortCutted = __assign({}, o, { a: a }); // generics function f(t, u) { - return __assign({ id: 'id' }, t, u); + return __assign({}, t, u, { id: 'id' }); } var exclusive = f({ a: 1, b: 'yes' }, { c: 'no', d: false }); var overlap = f({ a: 1 }, { a: 2, b: 'extra' }); diff --git a/tests/baselines/reference/objectSpread.symbols b/tests/baselines/reference/objectSpread.symbols index d23016ddb1e..fb7a1e22b33 100644 --- a/tests/baselines/reference/objectSpread.symbols +++ b/tests/baselines/reference/objectSpread.symbols @@ -290,7 +290,7 @@ let shortCutted: { a: number, b: string } = { ...o, a } >a : Symbol(a, Decl(objectSpread.ts, 81, 51)) // generics -function f(t: T, u: U): { id: string, ...T, ...U } { +function f(t: T, u: U): { ...T, ...U, id: string } { >f : Symbol(f, Decl(objectSpread.ts, 81, 55)) >T : Symbol(T, Decl(objectSpread.ts, 84, 11)) >U : Symbol(U, Decl(objectSpread.ts, 84, 13)) @@ -298,12 +298,12 @@ function f(t: T, u: U): { id: string, ...T, ...U } { >T : Symbol(T, Decl(objectSpread.ts, 84, 11)) >u : Symbol(u, Decl(objectSpread.ts, 84, 22)) >U : Symbol(U, Decl(objectSpread.ts, 84, 13)) ->id : Symbol(id, Decl(objectSpread.ts, 84, 31)) >T : Symbol(T, Decl(objectSpread.ts, 84, 11)) >U : Symbol(U, Decl(objectSpread.ts, 84, 13)) +>id : Symbol(id, Decl(objectSpread.ts, 84, 43)) - return { id: 'id', ...t, ...u }; ->id : Symbol(id, Decl(objectSpread.ts, 85, 12)) + return { ...t, ...u, id: 'id' }; +>id : Symbol(id, Decl(objectSpread.ts, 85, 24)) } let exclusive: { id: string, a: number, b: string, c: string, d: boolean } = >exclusive : Symbol(exclusive, Decl(objectSpread.ts, 87, 3)) @@ -342,12 +342,12 @@ let overlapConflict: { id:string, a: string } = >a : Symbol(a, Decl(objectSpread.ts, 92, 7)) >a : Symbol(a, Decl(objectSpread.ts, 92, 17)) -let overwriteId: { id: boolean, a: number, c: number, d: string } = +let overwriteId: { id: string, a: number, c: number, d: string } = >overwriteId : Symbol(overwriteId, Decl(objectSpread.ts, 93, 3)) >id : Symbol(id, Decl(objectSpread.ts, 93, 18)) ->a : Symbol(a, Decl(objectSpread.ts, 93, 31)) ->c : Symbol(c, Decl(objectSpread.ts, 93, 42)) ->d : Symbol(d, Decl(objectSpread.ts, 93, 53)) +>a : Symbol(a, Decl(objectSpread.ts, 93, 30)) +>c : Symbol(c, Decl(objectSpread.ts, 93, 41)) +>d : Symbol(d, Decl(objectSpread.ts, 93, 52)) f({ a: 1, id: true }, { c: 1, d: 'no' }) >f : Symbol(f, Decl(objectSpread.ts, 81, 55)) diff --git a/tests/baselines/reference/objectSpread.types b/tests/baselines/reference/objectSpread.types index efab098fd6e..b6fcb9150bf 100644 --- a/tests/baselines/reference/objectSpread.types +++ b/tests/baselines/reference/objectSpread.types @@ -423,24 +423,24 @@ let shortCutted: { a: number, b: string } = { ...o, a } >a : number // generics -function f(t: T, u: U): { id: string, ...T, ...U } { ->f : (t: T, u: U) => { id: string; ...T; ...U } +function f(t: T, u: U): { ...T, ...U, id: string } { +>f : (t: T, u: U) => { ...T; ...U; id: string; } >T : T >U : U >t : T >T : T >u : U >U : U ->id : string >T : T >U : U - - return { id: 'id', ...t, ...u }; ->{ id: 'id', ...t, ...u } : { id: string; ...T; ...U } >id : string ->'id' : "id" + + return { ...t, ...u, id: 'id' }; +>{ ...t, ...u, id: 'id' } : { ...T; ...U; id: string; } >t : any >u : any +>id : string +>'id' : "id" } let exclusive: { id: string, a: number, b: string, c: string, d: boolean } = >exclusive : { id: string; a: number; b: string; c: string; d: boolean; } @@ -451,8 +451,8 @@ let exclusive: { id: string, a: number, b: string, c: string, d: boolean } = >d : boolean f({ a: 1, b: 'yes' }, { c: 'no', d: false }) ->f({ a: 1, b: 'yes' }, { c: 'no', d: false }) : { c: string; d: boolean; a: number; b: string; id: string; } ->f : (t: T, u: U) => { id: string; ...T; ...U } +>f({ a: 1, b: 'yes' }, { c: 'no', d: false }) : { id: string; c: string; d: boolean; a: number; b: string; } +>f : (t: T, u: U) => { ...T; ...U; id: string; } >{ a: 1, b: 'yes' } : { a: number; b: string; } >a : number >1 : 1 @@ -471,8 +471,8 @@ let overlap: { id: string, a: number, b: string } = >b : string f({ a: 1 }, { a: 2, b: 'extra' }) ->f({ a: 1 }, { a: 2, b: 'extra' }) : { a: number; b: string; id: string; } ->f : (t: T, u: U) => { id: string; ...T; ...U } +>f({ a: 1 }, { a: 2, b: 'extra' }) : { id: string; a: number; b: string; } +>f : (t: T, u: U) => { ...T; ...U; id: string; } >{ a: 1 } : { a: number; } >a : number >1 : 1 @@ -488,8 +488,8 @@ let overlapConflict: { id:string, a: string } = >a : string f({ a: 1 }, { a: 'mismatch' }) ->f({ a: 1 }, { a: 'mismatch' }) : { a: string; id: string; } ->f : (t: T, u: U) => { id: string; ...T; ...U } +>f({ a: 1 }, { a: 'mismatch' }) : { id: string; a: string; } +>f : (t: T, u: U) => { ...T; ...U; id: string; } >{ a: 1 } : { a: number; } >a : number >1 : 1 @@ -497,16 +497,16 @@ let overlapConflict: { id:string, a: string } = >a : string >'mismatch' : "mismatch" -let overwriteId: { id: boolean, a: number, c: number, d: string } = ->overwriteId : { id: boolean; a: number; c: number; d: string; } ->id : boolean +let overwriteId: { id: string, a: number, c: number, d: string } = +>overwriteId : { id: string; a: number; c: number; d: string; } +>id : string >a : number >c : number >d : string f({ a: 1, id: true }, { c: 1, d: 'no' }) ->f({ a: 1, id: true }, { c: 1, d: 'no' }) : { c: number; d: string; a: number; id: boolean; } ->f : (t: T, u: U) => { id: string; ...T; ...U } +>f({ a: 1, id: true }, { c: 1, d: 'no' }) : { id: string; c: number; d: string; a: number; } +>f : (t: T, u: U) => { ...T; ...U; id: string; } >{ a: 1, id: true } : { a: number; id: true; } >a : number >1 : 1 @@ -531,8 +531,8 @@ let classesAreWrong: { id: string, ...C, ...D } = >D : D f(new C(), new D()) ->f(new C(), new D()) : { q: number; p: number; id: string; } ->f : (t: T, u: U) => { id: string; ...T; ...U } +>f(new C(), new D()) : { id: string; q: number; p: number; } +>f : (t: T, u: U) => { ...T; ...U; id: string; } >new C() : C >C : typeof C >new D() : D diff --git a/tests/baselines/reference/objectSpreadGeneric.errors.txt b/tests/baselines/reference/objectSpreadGeneric.errors.txt index 6e55040f223..8b9c767f6de 100644 --- a/tests/baselines/reference/objectSpreadGeneric.errors.txt +++ b/tests/baselines/reference/objectSpreadGeneric.errors.txt @@ -4,17 +4,19 @@ tests/cases/conformance/types/spread/objectSpreadGeneric.ts(11,11): error TS2322 tests/cases/conformance/types/spread/objectSpreadGeneric.ts(12,11): error TS2322: Type '{ ...T; ...U; ...V }' is not assignable to type '{ ...U; ...V }'. tests/cases/conformance/types/spread/objectSpreadGeneric.ts(13,11): error TS2322: Type '{ ...T; ...U; ...V }' is not assignable to type '{ ...T; ...V }'. tests/cases/conformance/types/spread/objectSpreadGeneric.ts(14,11): error TS2322: Type '{ ...T; ...U; ...V }' is not assignable to type '{ ...T; ...U }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(16,11): error TS2322: Type '{ first: string; ...T; ...U }' is not assignable to type '{ first: string; ...T; ...U }'. tests/cases/conformance/types/spread/objectSpreadGeneric.ts(19,11): error TS2322: Type '{}' is not assignable to type '{ ...T; ...U }'. -tests/cases/conformance/types/spread/objectSpreadGeneric.ts(32,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; second: string; ...T; third: string; }'. -tests/cases/conformance/types/spread/objectSpreadGeneric.ts(40,11): error TS2322: Type '{ firrrrrrst: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. - Property 'first' is missing in type '{ third: string; second: string; firrrrrrst: string; }'. -tests/cases/conformance/types/spread/objectSpreadGeneric.ts(42,11): error TS2322: Type '{ first: string; ...T; ssssssssecond: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. - Property 'second' is missing in type '{ third: string; ssssssssecond: string; first: string; }'. -tests/cases/conformance/types/spread/objectSpreadGeneric.ts(44,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; thirrrrrrrd: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. - Property 'third' is missing in type '{ thirrrrrrrd: string; second: string; first: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(26,11): error TS2322: Type '{ sn?: boolean; ...T; sn?: string | number; }' is not assignable to type '{ ...T; sn?: string | number | boolean; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(32,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(34,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; second: string; ...T; third: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(36,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(38,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }' is not assignable to type '{ first: string; second: string; secondsecond: string; third: string; ...T; ...U }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(42,11): error TS2322: Type '{ firrrrrrst: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(44,11): error TS2322: Type '{ first: string; ...T; ssssssssecond: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. +tests/cases/conformance/types/spread/objectSpreadGeneric.ts(46,11): error TS2322: Type '{ first: string; ...T; second: string; ...U; thirrrrrrrd: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. -==== tests/cases/conformance/types/spread/objectSpreadGeneric.ts (11 errors) ==== +==== tests/cases/conformance/types/spread/objectSpreadGeneric.ts (16 errors) ==== function f(t: T, u: U, v: V): void { let o: { ...T, ...U, ...V }; let uus: { ...U, ...U}; @@ -42,48 +44,57 @@ tests/cases/conformance/types/spread/objectSpreadGeneric.ts(44,11): error TS2322 ~~~~~~~~ !!! error TS2322: Type '{ ...T; ...U; ...V }' is not assignable to type '{ ...T; ...U }'. const atEnd: { ...T, ...U, second: string } = { ...t, ...u, second: 'foo' }; // ok - const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // ok + const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // error, not assignable + ~~~~~~~~~~~ +!!! error TS2322: Type '{ first: string; ...T; ...U }' is not assignable to type '{ first: string; ...T; ...U }'. const emptyTarget: { } = { ...t, ...u } // ok const emptySource: { ...T, ...U } = { }; // error, {} is not assignable to U (or T) ~~~~~~~~~~~ !!! error TS2322: Type '{}' is not assignable to type '{ ...T; ...U }'. + // error, { sn?: boolean } ...T ... { sn?: number | string } is not assignable to + // T ... { sn?: number | string | boolean } let optionalNumber: { sn?: number }; let optionalString: { sn?: string }; let optionalBoolean: { sn?: boolean }; const unionCutoff: { ...T, sn?: number | string | boolean } = - { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } // ok + ~~~~~~~~~~~ +!!! error TS2322: Type '{ sn?: boolean; ...T; sn?: string | number; }' is not assignable to type '{ ...T; sn?: string | number | boolean; }'. + { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } unionCutoff.sn; // ok const optionalCutoff = { ...t, ...optionalNumber }; // ok optionalCutoff.sn; // ok const interspersed: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, second: '2', ...u, third: '3' }; // ok + ~~~~~~~~~~~~ +!!! error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. + { first: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const interspersedMissingU: { first: string, second: string, ...T, third: string } = ~~~~~~~~~~~~~~~~~~~~ !!! error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; second: string; ...T; third: string; }'. { first: '1', ...t, second: '2', ...u, third: '3' }; // error, 'U' is missing const interspersedOrder1: { first: string, ...T, second: string, ...U, third: string, secondsecond: string } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + ~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }'. + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const interspersedOrder2: { first: string, second: string, secondsecond: string, third: string, ...T, ...U } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + ~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ first: string; ...T; second: string; ...U; third: string; secondsecond: string; }' is not assignable to type '{ first: string; second: string; secondsecond: string; third: string; ...T; ...U }'. + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const mismatchFirst: { first: string, ...T, second: string, ...U, third: string } = ~~~~~~~~~~~~~ !!! error TS2322: Type '{ firrrrrrst: string; ...T; second: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. -!!! error TS2322: Property 'first' is missing in type '{ third: string; second: string; firrrrrrst: string; }'. - { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, 'first' not found + { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const mismatchSecond: { first: string, ...T, second: string, ...U, third: string } = ~~~~~~~~~~~~~~ !!! error TS2322: Type '{ first: string; ...T; ssssssssecond: string; ...U; third: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. -!!! error TS2322: Property 'second' is missing in type '{ third: string; ssssssssecond: string; first: string; }'. - { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, 'second' not found + { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, not assignable const mismatchLast: { first: string, ...T, second: string, ...U, third: string } = ~~~~~~~~~~~~ !!! error TS2322: Type '{ first: string; ...T; second: string; ...U; thirrrrrrrd: string; }' is not assignable to type '{ first: string; ...T; second: string; ...U; third: string; }'. -!!! error TS2322: Property 'third' is missing in type '{ thirrrrrrrd: string; second: string; first: string; }'. - { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, 'third' not found + { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, not assignable } \ No newline at end of file diff --git a/tests/baselines/reference/objectSpreadGeneric.js b/tests/baselines/reference/objectSpreadGeneric.js index 9414b9ef76e..fa19e47df39 100644 --- a/tests/baselines/reference/objectSpreadGeneric.js +++ b/tests/baselines/reference/objectSpreadGeneric.js @@ -14,36 +14,38 @@ function f(t: T, u: U, v: V): void { const missingU: { ...T, ...V } = o; // error, missing U const missingV: { ...T, ...U } = o; // error, missing V const atEnd: { ...T, ...U, second: string } = { ...t, ...u, second: 'foo' }; // ok - const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // ok + const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // error, not assignable const emptyTarget: { } = { ...t, ...u } // ok const emptySource: { ...T, ...U } = { }; // error, {} is not assignable to U (or T) + // error, { sn?: boolean } ...T ... { sn?: number | string } is not assignable to + // T ... { sn?: number | string | boolean } let optionalNumber: { sn?: number }; let optionalString: { sn?: string }; let optionalBoolean: { sn?: boolean }; const unionCutoff: { ...T, sn?: number | string | boolean } = - { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } // ok + { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } unionCutoff.sn; // ok const optionalCutoff = { ...t, ...optionalNumber }; // ok optionalCutoff.sn; // ok const interspersed: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, second: '2', ...u, third: '3' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const interspersedMissingU: { first: string, second: string, ...T, third: string } = { first: '1', ...t, second: '2', ...u, third: '3' }; // error, 'U' is missing const interspersedOrder1: { first: string, ...T, second: string, ...U, third: string, secondsecond: string } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const interspersedOrder2: { first: string, second: string, secondsecond: string, third: string, ...T, ...U } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const mismatchFirst: { first: string, ...T, second: string, ...U, third: string } = - { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, 'first' not found + { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const mismatchSecond: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, 'second' not found + { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, not assignable const mismatchLast: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, 'third' not found + { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, not assignable } @@ -71,21 +73,23 @@ function f(t, u, v) { var missingU = o; // error, missing U var missingV = o; // error, missing V var atEnd = __assign({}, t, u, { second: 'foo' }); // ok - var atBeginning = __assign({ first: 'foo' }, t, u); // ok + var atBeginning = __assign({ first: 'foo' }, t, u); // error, not assignable var emptyTarget = __assign({}, t, u); // ok var emptySource = {}; // error, {} is not assignable to U (or T) + // error, { sn?: boolean } ...T ... { sn?: number | string } is not assignable to + // T ... { sn?: number | string | boolean } var optionalNumber; var optionalString; var optionalBoolean; - var unionCutoff = __assign({}, optionalBoolean, t, optionalString, optionalNumber); // ok + var unionCutoff = __assign({}, optionalBoolean, t, optionalString, optionalNumber); unionCutoff.sn; // ok var optionalCutoff = __assign({}, t, optionalNumber); // ok optionalCutoff.sn; // ok - var interspersed = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3' }); // ok + var interspersed = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3' }); // error, not assignable var interspersedMissingU = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3' }); // error, 'U' is missing - var interspersedOrder1 = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3', secondsecond: 'false' }); // ok - var interspersedOrder2 = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3', secondsecond: 'false' }); // ok - var mismatchFirst = __assign({ firrrrrrst: '1' }, t, { second: '2' }, u, { third: '3' }); // error, 'first' not found - var mismatchSecond = __assign({ first: '1' }, t, { ssssssssecond: '2' }, u, { third: '3' }); // error, 'second' not found - var mismatchLast = __assign({ first: '1' }, t, { second: '2' }, u, { thirrrrrrrd: '3' }); // error, 'third' not found + var interspersedOrder1 = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3', secondsecond: 'false' }); // error, not assignable + var interspersedOrder2 = __assign({ first: '1' }, t, { second: '2' }, u, { third: '3', secondsecond: 'false' }); // error, not assignable + var mismatchFirst = __assign({ firrrrrrst: '1' }, t, { second: '2' }, u, { third: '3' }); // error, not assignable + var mismatchSecond = __assign({ first: '1' }, t, { ssssssssecond: '2' }, u, { third: '3' }); // error, not assignable + var mismatchLast = __assign({ first: '1' }, t, { second: '2' }, u, { thirrrrrrrd: '3' }); // error, not assignable } diff --git a/tests/baselines/reference/objectSpreadIntersection.js b/tests/baselines/reference/objectSpreadIntersection.js index cb93c547963..0a7f1ddfcee 100644 --- a/tests/baselines/reference/objectSpreadIntersection.js +++ b/tests/baselines/reference/objectSpreadIntersection.js @@ -2,9 +2,9 @@ function iteratedUnionIntersection(t: T, u: U, v: V): void { let tu: T | U; let uv: U & V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: ({ id: string, ...T, ...U } & { id: string, ...T, ...V }) | ({ id: string, ...U } & { id: string, ...U, ...V }); - let assignable: { id: string, ...(T | U), ...(U & V) } = result; + let result = { ...tu, ...uv, id: 'foo' }; + let expected: ({ ...T, ...U, id: string } & { ...T, ...V, id: string }) | ({ ...U, id: string } & { ...U, ...V, id: string }); + let assignable: { ...(T | U), ...(U & V), id: string } = result; } // concrete types work interface A1 { a: number } @@ -16,23 +16,23 @@ let assignable: { ...(A1 & A2) } = result; function tripleIntersection(t: T, u: U, v: V): void { let tuv: T & U & V; - let result = { id: 'foo', ...tuv }; - let expected: { id: string, ...T } & { id: string, ...U } & { id: string, ...V } = result; - let assignable: { id: string, ...(T & U & V) } = result; + let result = { ...tuv, id: 'bar' }; + let expected: { ...T, id: string } & { ...U, id: string } & { ...V, id: string } = result; + let assignable: { ...(T & U & V), id: string } = result; } function iteratedDoubleIntersection(t: T, u: U, v: V): void { let tu: T & U; let uv: U & V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: { id: string, ...T, ...U } & { id: string, ...T, ...V } & { id: string, ...U } & { id: string, ...U, ...V }; - let assignable: { id: string, ...(T & U), ...(U & V) } = result; + let result = { ...tu, ...uv, id: 'baz' }; + let expected: { ...T, ...U, id: string } & { ...T, ...V, id: string } & { ...U, id: string } & { ...U, ...V, id: string }; + let assignable: { ...(T & U), ...(U & V), id: string } = result; } function iteratedIntersectionUnion(t: T, u: U, v: V): void { let tu: T & U; let uv: U | V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: ({ id: string, ...T, ...U } & { id: string, ...U }) | ({ id: string, ...T, ...V } & { id: string, ...U, ...V }); - let assignable: { id: string, ...(T & U), ...(U | V) } = result; + let result = { ...tu, ...uv, id: 'qux' }; + let expected: ({ ...T, ...U, id: string } & { ...U, id: string }) | ({ ...T, ...V, id: string } & { ...U, ...V, id: string }); + let assignable: { ...(T & U), ...(U | V), id: string } = result; } @@ -49,7 +49,7 @@ var __assign = (this && this.__assign) || Object.assign || function(t) { function iteratedUnionIntersection(t, u, v) { var tu; var uv; - var result = __assign({ id: 'bar' }, tu, uv); + var result = __assign({}, tu, uv, { id: 'foo' }); var expected; var assignable = result; } @@ -59,21 +59,21 @@ var sn = result.a; var assignable = result; function tripleIntersection(t, u, v) { var tuv; - var result = __assign({ id: 'foo' }, tuv); + var result = __assign({}, tuv, { id: 'bar' }); var expected = result; var assignable = result; } function iteratedDoubleIntersection(t, u, v) { var tu; var uv; - var result = __assign({ id: 'bar' }, tu, uv); + var result = __assign({}, tu, uv, { id: 'baz' }); var expected; var assignable = result; } function iteratedIntersectionUnion(t, u, v) { var tu; var uv; - var result = __assign({ id: 'bar' }, tu, uv); + var result = __assign({}, tu, uv, { id: 'qux' }); var expected; var assignable = result; } diff --git a/tests/baselines/reference/objectSpreadIntersection.symbols b/tests/baselines/reference/objectSpreadIntersection.symbols index f45b04a20a5..c59c37670b2 100644 --- a/tests/baselines/reference/objectSpreadIntersection.symbols +++ b/tests/baselines/reference/objectSpreadIntersection.symbols @@ -21,31 +21,31 @@ function iteratedUnionIntersection(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 0, 40)) - let result = { id: 'bar', ...tu, ...uv }; + let result = { ...tu, ...uv, id: 'foo' }; >result : Symbol(result, Decl(objectSpreadIntersection.ts, 3, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 3, 18)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 3, 32)) - let expected: ({ id: string, ...T, ...U } & { id: string, ...T, ...V }) | ({ id: string, ...U } & { id: string, ...U, ...V }); + let expected: ({ ...T, ...U, id: string } & { ...T, ...V, id: string }) | ({ ...U, id: string } & { ...U, ...V, id: string }); >expected : Symbol(expected, Decl(objectSpreadIntersection.ts, 4, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 20)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 0, 35)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 49)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 32)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 0, 35)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 0, 40)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 80)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 61)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 103)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 86)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 0, 40)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 4, 115)) - let assignable: { id: string, ...(T | U), ...(U & V) } = result; + let assignable: { ...(T | U), ...(U & V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadIntersection.ts, 5, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 5, 21)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 0, 35)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 0, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 0, 40)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 5, 45)) >result : Symbol(result, Decl(objectSpreadIntersection.ts, 3, 7)) } // concrete types work @@ -95,26 +95,26 @@ function tripleIntersection(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadIntersection.ts, 15, 30)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 15, 33)) - let result = { id: 'foo', ...tuv }; + let result = { ...tuv, id: 'bar' }; >result : Symbol(result, Decl(objectSpreadIntersection.ts, 17, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 17, 18)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 17, 26)) - let expected: { id: string, ...T } & { id: string, ...U } & { id: string, ...V } = result; + let expected: { ...T, id: string } & { ...U, id: string } & { ...V, id: string } = result; >expected : Symbol(expected, Decl(objectSpreadIntersection.ts, 18, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 19)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 15, 28)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 42)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 25)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 15, 30)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 65)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 48)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 15, 33)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 18, 71)) >result : Symbol(result, Decl(objectSpreadIntersection.ts, 17, 7)) - let assignable: { id: string, ...(T & U & V) } = result; + let assignable: { ...(T & U & V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadIntersection.ts, 19, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 19, 21)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 15, 28)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 15, 30)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 15, 33)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 19, 37)) >result : Symbol(result, Decl(objectSpreadIntersection.ts, 17, 7)) } function iteratedDoubleIntersection(t: T, u: U, v: V): void { @@ -139,31 +139,31 @@ function iteratedDoubleIntersection(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 21, 41)) - let result = { id: 'bar', ...tu, ...uv }; + let result = { ...tu, ...uv, id: 'baz' }; >result : Symbol(result, Decl(objectSpreadIntersection.ts, 24, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 24, 18)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 24, 32)) - let expected: { id: string, ...T, ...U } & { id: string, ...T, ...V } & { id: string, ...U } & { id: string, ...U, ...V }; + let expected: { ...T, ...U, id: string } & { ...T, ...V, id: string } & { ...U, id: string } & { ...U, ...V, id: string }; >expected : Symbol(expected, Decl(objectSpreadIntersection.ts, 25, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 19)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 21, 36)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 48)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 31)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 21, 36)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 21, 41)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 77)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 60)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 100)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 83)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 21, 41)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 25, 112)) - let assignable: { id: string, ...(T & U), ...(U & V) } = result; + let assignable: { ...(T & U), ...(U & V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadIntersection.ts, 26, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 26, 21)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 21, 36)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 21, 38)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 21, 41)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 26, 45)) >result : Symbol(result, Decl(objectSpreadIntersection.ts, 24, 7)) } function iteratedIntersectionUnion(t: T, u: U, v: V): void { @@ -188,31 +188,31 @@ function iteratedIntersectionUnion(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 28, 40)) - let result = { id: 'bar', ...tu, ...uv }; + let result = { ...tu, ...uv, id: 'qux' }; >result : Symbol(result, Decl(objectSpreadIntersection.ts, 31, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 31, 18)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 31, 32)) - let expected: ({ id: string, ...T, ...U } & { id: string, ...U }) | ({ id: string, ...T, ...V } & { id: string, ...U, ...V }); + let expected: ({ ...T, ...U, id: string } & { ...U, id: string }) | ({ ...T, ...V, id: string } & { ...U, ...V, id: string }); >expected : Symbol(expected, Decl(objectSpreadIntersection.ts, 32, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 20)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 28, 35)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 49)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 32)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 74)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 55)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 28, 35)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 28, 40)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 103)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 86)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 28, 40)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 32, 115)) - let assignable: { id: string, ...(T & U), ...(U | V) } = result; + let assignable: { ...(T & U), ...(U | V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadIntersection.ts, 33, 7)) ->id : Symbol(id, Decl(objectSpreadIntersection.ts, 33, 21)) >T : Symbol(T, Decl(objectSpreadIntersection.ts, 28, 35)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) >U : Symbol(U, Decl(objectSpreadIntersection.ts, 28, 37)) >V : Symbol(V, Decl(objectSpreadIntersection.ts, 28, 40)) +>id : Symbol(id, Decl(objectSpreadIntersection.ts, 33, 45)) >result : Symbol(result, Decl(objectSpreadIntersection.ts, 31, 7)) } diff --git a/tests/baselines/reference/objectSpreadIntersection.types b/tests/baselines/reference/objectSpreadIntersection.types index 7700d8aa384..30820017916 100644 --- a/tests/baselines/reference/objectSpreadIntersection.types +++ b/tests/baselines/reference/objectSpreadIntersection.types @@ -21,17 +21,16 @@ function iteratedUnionIntersection(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'bar', ...tu, ...uv }; ->result : ({ id: string; ...T; ...U } | { id: string; ...U }) & ({ id: string; ...T; ...V } | { id: string; ...U; ...V }) ->{ id: 'bar', ...tu, ...uv } : ({ id: string; ...T; ...U } | { id: string; ...U }) & ({ id: string; ...T; ...V } | { id: string; ...U; ...V }) ->id : string ->'bar' : "bar" + let result = { ...tu, ...uv, id: 'foo' }; +>result : ({ ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...U; ...T; ...U; id: string; }) & ({ ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } | { ...T; ...U; ...T; ...V; id: string; } | { ...U; ...T; ...U; ...V; id: string; }) +>{ ...tu, ...uv, id: 'foo' } : ({ ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...U; ...T; ...U; id: string; }) & ({ ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } | { ...T; ...U; ...T; ...V; id: string; } | { ...U; ...T; ...U; ...V; id: string; }) >tu : any >uv : any +>id : string +>'foo' : "foo" - let expected: ({ id: string, ...T, ...U } & { id: string, ...T, ...V }) | ({ id: string, ...U } & { id: string, ...U, ...V }); ->expected : ({ id: string; ...T; ...U } & { id: string; ...T; ...V }) | ({ id: string; ...U } & { id: string; ...U; ...V }) ->id : string + let expected: ({ ...T, ...U, id: string } & { ...T, ...V, id: string }) | ({ ...U, id: string } & { ...U, ...V, id: string }); +>expected : ({ ...T; ...U; id: string; } & { ...T; ...V; id: string; }) | ({ ...U; id: string; } & { ...U; ...V; id: string; }) >T : T >U : U >id : string @@ -42,15 +41,16 @@ function iteratedUnionIntersection(t: T, u: U, v: V): void { >id : string >U : U >V : V +>id : string - let assignable: { id: string, ...(T | U), ...(U & V) } = result; ->assignable : ({ id: string; ...T; ...U } | { id: string; ...U }) & ({ id: string; ...T; ...V } | { id: string; ...U; ...V }) ->id : string + let assignable: { ...(T | U), ...(U & V), id: string } = result; +>assignable : ({ ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...U; ...T; ...U; id: string; }) & ({ ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } | { ...T; ...U; ...T; ...V; id: string; } | { ...U; ...T; ...U; ...V; id: string; }) >T : T >U : U >U : U >V : V ->result : ({ id: string; ...T; ...U } | { id: string; ...U }) & ({ id: string; ...T; ...V } | { id: string; ...U; ...V }) +>id : string +>result : ({ ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...U; ...T; ...U; id: string; }) & ({ ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } | { ...T; ...U; ...T; ...V; id: string; } | { ...U; ...T; ...U; ...V; id: string; }) } // concrete types work interface A1 { a: number } @@ -101,30 +101,30 @@ function tripleIntersection(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'foo', ...tuv }; ->result : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } ->{ id: 'foo', ...tuv } : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } ->id : string ->'foo' : "foo" + let result = { ...tuv, id: 'bar' }; +>result : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } +>{ ...tuv, id: 'bar' } : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } >tuv : any - - let expected: { id: string, ...T } & { id: string, ...U } & { id: string, ...V } = result; ->expected : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } >id : string +>'bar' : "bar" + + let expected: { ...T, id: string } & { ...U, id: string } & { ...V, id: string } = result; +>expected : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } >T : T >id : string >U : U >id : string >V : V ->result : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } - - let assignable: { id: string, ...(T & U & V) } = result; ->assignable : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } >id : string +>result : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } + + let assignable: { ...(T & U & V), id: string } = result; +>assignable : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } >T : T >U : U >V : V ->result : { id: string; ...T } & { id: string; ...U } & { id: string; ...V } +>id : string +>result : { ...T; id: string; } & { ...U; id: string; } & { ...V; id: string; } } function iteratedDoubleIntersection(t: T, u: U, v: V): void { >iteratedDoubleIntersection : (t: T, u: U, v: V) => void @@ -148,17 +148,16 @@ function iteratedDoubleIntersection(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'bar', ...tu, ...uv }; ->result : { id: string; ...T; ...U } & { id: string; ...U } & { id: string; ...T; ...V } & { id: string; ...U; ...V } ->{ id: 'bar', ...tu, ...uv } : { id: string; ...T; ...U } & { id: string; ...U } & { id: string; ...T; ...V } & { id: string; ...U; ...V } ->id : string ->'bar' : "bar" + let result = { ...tu, ...uv, id: 'baz' }; +>result : { ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...U; id: string; } & { ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; } +>{ ...tu, ...uv, id: 'baz' } : { ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...U; id: string; } & { ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; } >tu : any >uv : any +>id : string +>'baz' : "baz" - let expected: { id: string, ...T, ...U } & { id: string, ...T, ...V } & { id: string, ...U } & { id: string, ...U, ...V }; ->expected : { id: string; ...T; ...U } & { id: string; ...T; ...V } & { id: string; ...U } & { id: string; ...U; ...V } ->id : string + let expected: { ...T, ...U, id: string } & { ...T, ...V, id: string } & { ...U, id: string } & { ...U, ...V, id: string }; +>expected : { ...T; ...U; id: string; } & { ...T; ...V; id: string; } & { ...U; id: string; } & { ...U; ...V; id: string; } >T : T >U : U >id : string @@ -169,15 +168,16 @@ function iteratedDoubleIntersection(t: T, u: U, v: V): void { >id : string >U : U >V : V +>id : string - let assignable: { id: string, ...(T & U), ...(U & V) } = result; ->assignable : { id: string; ...T; ...U } & { id: string; ...U } & { id: string; ...T; ...V } & { id: string; ...U; ...V } ->id : string + let assignable: { ...(T & U), ...(U & V), id: string } = result; +>assignable : { ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...U; id: string; } & { ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; } >T : T >U : U >U : U >V : V ->result : { id: string; ...T; ...U } & { id: string; ...U } & { id: string; ...T; ...V } & { id: string; ...U; ...V } +>id : string +>result : { ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...U; id: string; } & { ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; } } function iteratedIntersectionUnion(t: T, u: U, v: V): void { >iteratedIntersectionUnion : (t: T, u: U, v: V) => void @@ -201,17 +201,16 @@ function iteratedIntersectionUnion(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'bar', ...tu, ...uv }; ->result : ({ id: string; ...T; ...U } & { id: string; ...U }) | ({ id: string; ...T; ...V } & { id: string; ...U; ...V }) ->{ id: 'bar', ...tu, ...uv } : ({ id: string; ...T; ...U } & { id: string; ...U }) | ({ id: string; ...T; ...V } & { id: string; ...U; ...V }) ->id : string ->'bar' : "bar" + let result = { ...tu, ...uv, id: 'qux' }; +>result : ({ ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...T; ...U; ...T; ...U; id: string; } & { ...U; id: string; }) | ({ ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; }) +>{ ...tu, ...uv, id: 'qux' } : ({ ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...T; ...U; ...T; ...U; id: string; } & { ...U; id: string; }) | ({ ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; }) >tu : any >uv : any +>id : string +>'qux' : "qux" - let expected: ({ id: string, ...T, ...U } & { id: string, ...U }) | ({ id: string, ...T, ...V } & { id: string, ...U, ...V }); ->expected : ({ id: string; ...T; ...U } & { id: string; ...U }) | ({ id: string; ...T; ...V } & { id: string; ...U; ...V }) ->id : string + let expected: ({ ...T, ...U, id: string } & { ...U, id: string }) | ({ ...T, ...V, id: string } & { ...U, ...V, id: string }); +>expected : ({ ...T; ...U; id: string; } & { ...U; id: string; }) | ({ ...T; ...V; id: string; } & { ...U; ...V; id: string; }) >T : T >U : U >id : string @@ -222,15 +221,16 @@ function iteratedIntersectionUnion(t: T, u: U, v: V): void { >id : string >U : U >V : V +>id : string - let assignable: { id: string, ...(T & U), ...(U | V) } = result; ->assignable : ({ id: string; ...T; ...U } & { id: string; ...U }) | ({ id: string; ...T; ...V } & { id: string; ...U; ...V }) ->id : string + let assignable: { ...(T & U), ...(U | V), id: string } = result; +>assignable : ({ ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...T; ...U; ...T; ...U; id: string; } & { ...U; id: string; }) | ({ ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; }) >T : T >U : U >U : U >V : V ->result : ({ id: string; ...T; ...U } & { id: string; ...U }) | ({ id: string; ...T; ...V } & { id: string; ...U; ...V }) +>id : string +>result : ({ ...T; ...U; id: string; } & { ...U; ...T; ...U; id: string; } & { ...T; ...U; ...T; ...U; id: string; } & { ...U; id: string; }) | ({ ...T; ...V; id: string; } & { ...U; ...T; ...V; id: string; } & { ...T; ...U; ...T; ...V; id: string; } & { ...T; ...U; ...V; id: string; } & { ...U; ...T; ...U; ...V; id: string; } & { ...U; ...V; id: string; }) } diff --git a/tests/baselines/reference/objectSpreadUnion.js b/tests/baselines/reference/objectSpreadUnion.js index 500b8a5ddc7..b3a114c7722 100644 --- a/tests/baselines/reference/objectSpreadUnion.js +++ b/tests/baselines/reference/objectSpreadUnion.js @@ -9,16 +9,16 @@ let assignable: { ...(A1 | A2) } = result; function tripleUnion(t: T, u: U, v: V): void { let tuv: T | U | V; - let result = { id: 'foo', ...tuv }; - let expected: { id: string, ...T } | { id: string, ...U } | { id: string, ...V } = result; - let assignable: { id: string, ...(T | U | V) } = result; + let result = { ...tuv, id: 'foo' }; + let expected: { ...T, id: string } | { ...U, id: string } | { ...V, id: string } = result; + let assignable: { ...(T | U | V), id: string } = result; } function iteratedDoubleUnion(t: T, u: U, v: V): void { let tu: T | U; let uv: U | V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: { id: string, ...T, ...U } | { id: string, ...T, ...V } | { id: string, ...U } | { id: string, ...U, ...V }; - let assignable: { id: string, ...(T | U), ...(U | V) } = result; + let result = { ...tu, ...uv, id: 'bar' }; + let expected: { ...T, ...U, id: string } | { ...T, ...V, id: string } | { ...U, id: string } | { ...U, ...V, id: string }; + let assignable: { ...(T | U), ...(U | V), id: string } = result; } @@ -39,14 +39,14 @@ var sn = result.a; var assignable = result; function tripleUnion(t, u, v) { var tuv; - var result = __assign({ id: 'foo' }, tuv); + var result = __assign({}, tuv, { id: 'foo' }); var expected = result; var assignable = result; } function iteratedDoubleUnion(t, u, v) { var tu; var uv; - var result = __assign({ id: 'bar' }, tu, uv); + var result = __assign({}, tu, uv, { id: 'bar' }); var expected; var assignable = result; } diff --git a/tests/baselines/reference/objectSpreadUnion.symbols b/tests/baselines/reference/objectSpreadUnion.symbols index eea9e65185d..d630fde518b 100644 --- a/tests/baselines/reference/objectSpreadUnion.symbols +++ b/tests/baselines/reference/objectSpreadUnion.symbols @@ -46,26 +46,26 @@ function tripleUnion(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadUnion.ts, 8, 23)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 8, 26)) - let result = { id: 'foo', ...tuv }; + let result = { ...tuv, id: 'foo' }; >result : Symbol(result, Decl(objectSpreadUnion.ts, 10, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 10, 18)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 10, 26)) - let expected: { id: string, ...T } | { id: string, ...U } | { id: string, ...V } = result; + let expected: { ...T, id: string } | { ...U, id: string } | { ...V, id: string } = result; >expected : Symbol(expected, Decl(objectSpreadUnion.ts, 11, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 19)) >T : Symbol(T, Decl(objectSpreadUnion.ts, 8, 21)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 42)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 25)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 8, 23)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 65)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 48)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 8, 26)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 11, 71)) >result : Symbol(result, Decl(objectSpreadUnion.ts, 10, 7)) - let assignable: { id: string, ...(T | U | V) } = result; + let assignable: { ...(T | U | V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadUnion.ts, 12, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 12, 21)) >T : Symbol(T, Decl(objectSpreadUnion.ts, 8, 21)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 8, 23)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 8, 26)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 12, 37)) >result : Symbol(result, Decl(objectSpreadUnion.ts, 10, 7)) } function iteratedDoubleUnion(t: T, u: U, v: V): void { @@ -90,31 +90,31 @@ function iteratedDoubleUnion(t: T, u: U, v: V): void { >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 14, 34)) - let result = { id: 'bar', ...tu, ...uv }; + let result = { ...tu, ...uv, id: 'bar' }; >result : Symbol(result, Decl(objectSpreadUnion.ts, 17, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 17, 18)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 17, 32)) - let expected: { id: string, ...T, ...U } | { id: string, ...T, ...V } | { id: string, ...U } | { id: string, ...U, ...V }; + let expected: { ...T, ...U, id: string } | { ...T, ...V, id: string } | { ...U, id: string } | { ...U, ...V, id: string }; >expected : Symbol(expected, Decl(objectSpreadUnion.ts, 18, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 19)) >T : Symbol(T, Decl(objectSpreadUnion.ts, 14, 29)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 48)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 31)) >T : Symbol(T, Decl(objectSpreadUnion.ts, 14, 29)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 14, 34)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 77)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 60)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 100)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 83)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 14, 34)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 18, 112)) - let assignable: { id: string, ...(T | U), ...(U | V) } = result; + let assignable: { ...(T | U), ...(U | V), id: string } = result; >assignable : Symbol(assignable, Decl(objectSpreadUnion.ts, 19, 7)) ->id : Symbol(id, Decl(objectSpreadUnion.ts, 19, 21)) >T : Symbol(T, Decl(objectSpreadUnion.ts, 14, 29)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) >U : Symbol(U, Decl(objectSpreadUnion.ts, 14, 31)) >V : Symbol(V, Decl(objectSpreadUnion.ts, 14, 34)) +>id : Symbol(id, Decl(objectSpreadUnion.ts, 19, 45)) >result : Symbol(result, Decl(objectSpreadUnion.ts, 17, 7)) } diff --git a/tests/baselines/reference/objectSpreadUnion.types b/tests/baselines/reference/objectSpreadUnion.types index 7cbffcf0a58..5d8cdbae24a 100644 --- a/tests/baselines/reference/objectSpreadUnion.types +++ b/tests/baselines/reference/objectSpreadUnion.types @@ -48,30 +48,30 @@ function tripleUnion(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'foo', ...tuv }; ->result : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } ->{ id: 'foo', ...tuv } : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } + let result = { ...tuv, id: 'foo' }; +>result : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } +>{ ...tuv, id: 'foo' } : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } +>tuv : any >id : string >'foo' : "foo" ->tuv : any - let expected: { id: string, ...T } | { id: string, ...U } | { id: string, ...V } = result; ->expected : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } ->id : string + let expected: { ...T, id: string } | { ...U, id: string } | { ...V, id: string } = result; +>expected : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } >T : T >id : string >U : U >id : string >V : V ->result : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } - - let assignable: { id: string, ...(T | U | V) } = result; ->assignable : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } >id : string +>result : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } + + let assignable: { ...(T | U | V), id: string } = result; +>assignable : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } >T : T >U : U >V : V ->result : { id: string; ...T } | { id: string; ...U } | { id: string; ...V } +>id : string +>result : { ...T; id: string; } | { ...U; id: string; } | { ...V; id: string; } } function iteratedDoubleUnion(t: T, u: U, v: V): void { >iteratedDoubleUnion : (t: T, u: U, v: V) => void @@ -95,17 +95,16 @@ function iteratedDoubleUnion(t: T, u: U, v: V): void { >U : U >V : V - let result = { id: 'bar', ...tu, ...uv }; ->result : { id: string; ...T; ...U } | { id: string; ...U } | { id: string; ...T; ...V } | { id: string; ...U; ...V } ->{ id: 'bar', ...tu, ...uv } : { id: string; ...T; ...U } | { id: string; ...U } | { id: string; ...T; ...V } | { id: string; ...U; ...V } ->id : string ->'bar' : "bar" + let result = { ...tu, ...uv, id: 'bar' }; +>result : { ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } +>{ ...tu, ...uv, id: 'bar' } : { ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } >tu : any >uv : any +>id : string +>'bar' : "bar" - let expected: { id: string, ...T, ...U } | { id: string, ...T, ...V } | { id: string, ...U } | { id: string, ...U, ...V }; ->expected : { id: string; ...T; ...U } | { id: string; ...T; ...V } | { id: string; ...U } | { id: string; ...U; ...V } ->id : string + let expected: { ...T, ...U, id: string } | { ...T, ...V, id: string } | { ...U, id: string } | { ...U, ...V, id: string }; +>expected : { ...T; ...U; id: string; } | { ...T; ...V; id: string; } | { ...U; id: string; } | { ...U; ...V; id: string; } >T : T >U : U >id : string @@ -116,15 +115,16 @@ function iteratedDoubleUnion(t: T, u: U, v: V): void { >id : string >U : U >V : V +>id : string - let assignable: { id: string, ...(T | U), ...(U | V) } = result; ->assignable : { id: string; ...T; ...U } | { id: string; ...U } | { id: string; ...T; ...V } | { id: string; ...U; ...V } ->id : string + let assignable: { ...(T | U), ...(U | V), id: string } = result; +>assignable : { ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } >T : T >U : U >U : U >V : V ->result : { id: string; ...T; ...U } | { id: string; ...U } | { id: string; ...T; ...V } | { id: string; ...U; ...V } +>id : string +>result : { ...U; id: string; } | { ...T; ...U; id: string; } | { ...U; ...T; ...U; id: string; } | { ...T; ...V; id: string; } | { ...U; ...T; ...V; id: string; } | { ...U; ...V; id: string; } | { ...T; ...U; ...V; id: string; } } diff --git a/tests/cases/conformance/types/spread/objectSpread.ts b/tests/cases/conformance/types/spread/objectSpread.ts index fc076e79543..e35a84956c0 100644 --- a/tests/cases/conformance/types/spread/objectSpread.ts +++ b/tests/cases/conformance/types/spread/objectSpread.ts @@ -83,8 +83,8 @@ let a = 12; let shortCutted: { a: number, b: string } = { ...o, a } // generics -function f(t: T, u: U): { id: string, ...T, ...U } { - return { id: 'id', ...t, ...u }; +function f(t: T, u: U): { ...T, ...U, id: string } { + return { ...t, ...u, id: 'id' }; } let exclusive: { id: string, a: number, b: string, c: string, d: boolean } = f({ a: 1, b: 'yes' }, { c: 'no', d: false }) @@ -92,7 +92,7 @@ let overlap: { id: string, a: number, b: string } = f({ a: 1 }, { a: 2, b: 'extra' }) let overlapConflict: { id:string, a: string } = f({ a: 1 }, { a: 'mismatch' }) -let overwriteId: { id: boolean, a: number, c: number, d: string } = +let overwriteId: { id: string, a: number, c: number, d: string } = f({ a: 1, id: true }, { c: 1, d: 'no' }) class D { m() { }; q = 2; } diff --git a/tests/cases/conformance/types/spread/objectSpreadGeneric.ts b/tests/cases/conformance/types/spread/objectSpreadGeneric.ts index e3bd1ab7bb3..63e9f00aaae 100644 --- a/tests/cases/conformance/types/spread/objectSpreadGeneric.ts +++ b/tests/cases/conformance/types/spread/objectSpreadGeneric.ts @@ -13,34 +13,36 @@ function f(t: T, u: U, v: V): void { const missingU: { ...T, ...V } = o; // error, missing U const missingV: { ...T, ...U } = o; // error, missing V const atEnd: { ...T, ...U, second: string } = { ...t, ...u, second: 'foo' }; // ok - const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // ok + const atBeginning: { first: string, ...T, ...U, } = { first: 'foo', ...t, ...u }; // error, not assignable const emptyTarget: { } = { ...t, ...u } // ok const emptySource: { ...T, ...U } = { }; // error, {} is not assignable to U (or T) + // error, { sn?: boolean } ...T ... { sn?: number | string } is not assignable to + // T ... { sn?: number | string | boolean } let optionalNumber: { sn?: number }; let optionalString: { sn?: string }; let optionalBoolean: { sn?: boolean }; const unionCutoff: { ...T, sn?: number | string | boolean } = - { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } // ok + { ...optionalBoolean, ...t, ...optionalString, ...optionalNumber } unionCutoff.sn; // ok const optionalCutoff = { ...t, ...optionalNumber }; // ok optionalCutoff.sn; // ok const interspersed: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, second: '2', ...u, third: '3' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const interspersedMissingU: { first: string, second: string, ...T, third: string } = { first: '1', ...t, second: '2', ...u, third: '3' }; // error, 'U' is missing const interspersedOrder1: { first: string, ...T, second: string, ...U, third: string, secondsecond: string } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const interspersedOrder2: { first: string, second: string, secondsecond: string, third: string, ...T, ...U } = - { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // ok + { first: '1', ...t, second: '2', ...u, third: '3', secondsecond: 'false' }; // error, not assignable const mismatchFirst: { first: string, ...T, second: string, ...U, third: string } = - { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, 'first' not found + { firrrrrrst: '1', ...t, second: '2', ...u, third: '3' }; // error, not assignable const mismatchSecond: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, 'second' not found + { first: '1', ...t, ssssssssecond: '2', ...u, third: '3' }; // error, not assignable const mismatchLast: { first: string, ...T, second: string, ...U, third: string } = - { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, 'third' not found + { first: '1', ...t, second: '2', ...u, thirrrrrrrd: '3' }; // error, not assignable } diff --git a/tests/cases/conformance/types/spread/objectSpreadIntersection.ts b/tests/cases/conformance/types/spread/objectSpreadIntersection.ts index 6471e622b68..f70995cb4b2 100644 --- a/tests/cases/conformance/types/spread/objectSpreadIntersection.ts +++ b/tests/cases/conformance/types/spread/objectSpreadIntersection.ts @@ -1,9 +1,9 @@ function iteratedUnionIntersection(t: T, u: U, v: V): void { let tu: T | U; let uv: U & V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: ({ id: string, ...T, ...U } & { id: string, ...T, ...V }) | ({ id: string, ...U } & { id: string, ...U, ...V }); - let assignable: { id: string, ...(T | U), ...(U & V) } = result; + let result = { ...tu, ...uv, id: 'foo' }; + let expected: ({ ...T, ...U, id: string } & { ...T, ...V, id: string }) | ({ ...U, id: string } & { ...U, ...V, id: string }); + let assignable: { ...(T | U), ...(U & V), id: string } = result; } // concrete types work interface A1 { a: number } @@ -15,22 +15,22 @@ let assignable: { ...(A1 & A2) } = result; function tripleIntersection(t: T, u: U, v: V): void { let tuv: T & U & V; - let result = { id: 'foo', ...tuv }; - let expected: { id: string, ...T } & { id: string, ...U } & { id: string, ...V } = result; - let assignable: { id: string, ...(T & U & V) } = result; + let result = { ...tuv, id: 'bar' }; + let expected: { ...T, id: string } & { ...U, id: string } & { ...V, id: string } = result; + let assignable: { ...(T & U & V), id: string } = result; } function iteratedDoubleIntersection(t: T, u: U, v: V): void { let tu: T & U; let uv: U & V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: { id: string, ...T, ...U } & { id: string, ...T, ...V } & { id: string, ...U } & { id: string, ...U, ...V }; - let assignable: { id: string, ...(T & U), ...(U & V) } = result; + let result = { ...tu, ...uv, id: 'baz' }; + let expected: { ...T, ...U, id: string } & { ...T, ...V, id: string } & { ...U, id: string } & { ...U, ...V, id: string }; + let assignable: { ...(T & U), ...(U & V), id: string } = result; } function iteratedIntersectionUnion(t: T, u: U, v: V): void { let tu: T & U; let uv: U | V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: ({ id: string, ...T, ...U } & { id: string, ...U }) | ({ id: string, ...T, ...V } & { id: string, ...U, ...V }); - let assignable: { id: string, ...(T & U), ...(U | V) } = result; + let result = { ...tu, ...uv, id: 'qux' }; + let expected: ({ ...T, ...U, id: string } & { ...U, id: string }) | ({ ...T, ...V, id: string } & { ...U, ...V, id: string }); + let assignable: { ...(T & U), ...(U | V), id: string } = result; } diff --git a/tests/cases/conformance/types/spread/objectSpreadUnion.ts b/tests/cases/conformance/types/spread/objectSpreadUnion.ts index 03a4251ca81..cd490d76bda 100644 --- a/tests/cases/conformance/types/spread/objectSpreadUnion.ts +++ b/tests/cases/conformance/types/spread/objectSpreadUnion.ts @@ -8,16 +8,16 @@ let assignable: { ...(A1 | A2) } = result; function tripleUnion(t: T, u: U, v: V): void { let tuv: T | U | V; - let result = { id: 'foo', ...tuv }; - let expected: { id: string, ...T } | { id: string, ...U } | { id: string, ...V } = result; - let assignable: { id: string, ...(T | U | V) } = result; + let result = { ...tuv, id: 'foo' }; + let expected: { ...T, id: string } | { ...U, id: string } | { ...V, id: string } = result; + let assignable: { ...(T | U | V), id: string } = result; } function iteratedDoubleUnion(t: T, u: U, v: V): void { let tu: T | U; let uv: U | V; - let result = { id: 'bar', ...tu, ...uv }; - let expected: { id: string, ...T, ...U } | { id: string, ...T, ...V } | { id: string, ...U } | { id: string, ...U, ...V }; - let assignable: { id: string, ...(T | U), ...(U | V) } = result; + let result = { ...tu, ...uv, id: 'bar' }; + let expected: { ...T, ...U, id: string } | { ...T, ...V, id: string } | { ...U, id: string } | { ...U, ...V, id: string }; + let assignable: { ...(T | U), ...(U | V), id: string } = result; }