From 62c186872d986dabf770dc7877de0f1167537af0 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Wed, 19 Oct 2016 13:14:20 -0700
Subject: [PATCH] Update inference test for spread types

---
 .../reference/objectSpreadInference.js        |  80 +-------
 .../reference/objectSpreadInference.symbols   | 147 +--------------
 .../reference/objectSpreadInference.types     | 178 +-----------------
 .../types/spread/objectSpreadInference.ts     |  46 +----
 4 files changed, 19 insertions(+), 432 deletions(-)

diff --git a/tests/baselines/reference/objectSpreadInference.js b/tests/baselines/reference/objectSpreadInference.js
index 06b17cfa1f9..77930e56511 100644
--- a/tests/baselines/reference/objectSpreadInference.js
+++ b/tests/baselines/reference/objectSpreadInference.js
@@ -12,52 +12,12 @@ function generic<W, X, Y>(w: W, x: X, y: Y) {
 }
 let b: { b: number };
 let c: { c: number };
-// should infer { t: {}, u: { b: number, c: number }, v: number }
+// can only infer { t: {}, u: {}, v: {} }
 let i1 = infer({ ...b, ...c, a: 12 });
-// should infer { t: { a: number, b: number, c: number }, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i2 = infer2({ ...b, ...c, a: 12 });
-// should infer { t: {}, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i3 = generic(b, c, { a: 12 });
-
-interface Preserved {
-    kind: 0 | 1 | 2 | 3;
-}
-class C implements Preserved {
-    kind: 0 = 0;
-    a = 1;
-    method() { return "C"; }
-}
-declare function revive<T extends Preserved>(t: { ...T }): T;
-function genericRevive<U extends Preserved>(u: U) {
-    let us: { ...U };
-    return revive(us);
-}
-// result should not have `method`
-let result = revive({ a: 12, kind: 0 });
-// result2 should be of type C and have `method`
-let result2 = revive<C>({ a: 12, kind: 0 });
-
-declare function destructureRevive<T extends Preserved>(t: { ...T, a: number }): T;
-function genericDestructureRevive<U extends Preserved & { a: number }>(u: U) {
-    let us: { ...U };
-    return destructureRevive(us);
-}
-// result3 is just `Preserved` because `a` and `method` both get removed
-let result3 = destructureRevive({ a: 12, kind: 0 });
-// result4 is still C -- a is not removed -- because we specified the argument explicitly
-let result4 = destructureRevive<C>({ a: 12, kind: 0 });
-result4.method();
-result4.a;
-
-declare function removeIndexSignature<T>(t: { ...T, a: number, [s: string]: number, [n: number]: number }): T;
-interface I {
-    a: number;
-    b: number;
-    [s: string]: number;
-    [n: number]: number;
-}
-let i: I;
-let result5 = removeIndexSignature(i);
 
 
 //// [objectSpreadInference.js]
@@ -75,37 +35,9 @@ function generic(w, x, y) {
 }
 var b;
 var c;
-// should infer { t: {}, u: { b: number, c: number }, v: number }
+// can only infer { t: {}, u: {}, v: {} }
 var i1 = infer(__assign({}, b, c, { a: 12 }));
-// should infer { t: { a: number, b: number, c: number }, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 var i2 = infer2(__assign({}, b, c, { a: 12 }));
-// should infer { t: {}, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 var i3 = generic(b, c, { a: 12 });
-var C = (function () {
-    function C() {
-        this.kind = 0;
-        this.a = 1;
-    }
-    C.prototype.method = function () { return "C"; };
-    return C;
-}());
-function genericRevive(u) {
-    var us;
-    return revive(us);
-}
-// result should not have `method`
-var result = revive({ a: 12, kind: 0 });
-// result2 should be of type C and have `method`
-var result2 = revive({ a: 12, kind: 0 });
-function genericDestructureRevive(u) {
-    var us;
-    return destructureRevive(us);
-}
-// result3 is just `Preserved` because `a` and `method` both get removed
-var result3 = destructureRevive({ a: 12, kind: 0 });
-// result4 is still C -- a is not removed -- because we specified the argument explicitly
-var result4 = destructureRevive({ a: 12, kind: 0 });
-result4.method();
-result4.a;
-var i;
-var result5 = removeIndexSignature(i);
diff --git a/tests/baselines/reference/objectSpreadInference.symbols b/tests/baselines/reference/objectSpreadInference.symbols
index f03cd6b44e1..ddecc4d7e5d 100644
--- a/tests/baselines/reference/objectSpreadInference.symbols
+++ b/tests/baselines/reference/objectSpreadInference.symbols
@@ -78,19 +78,19 @@ let c: { c: number };
 >c : Symbol(c, Decl(objectSpreadInference.ts, 12, 3))
 >c : Symbol(c, Decl(objectSpreadInference.ts, 12, 8))
 
-// should infer { t: {}, u: { b: number, c: number }, v: number }
+// can only infer { t: {}, u: {}, v: {} }
 let i1 = infer({ ...b, ...c, a: 12 });
 >i1 : Symbol(i1, Decl(objectSpreadInference.ts, 14, 3))
 >infer : Symbol(infer, Decl(objectSpreadInference.ts, 4, 1))
 >a : Symbol(a, Decl(objectSpreadInference.ts, 14, 28))
 
-// should infer { t: { a: number, b: number, c: number }, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i2 = infer2({ ...b, ...c, a: 12 });
 >i2 : Symbol(i2, Decl(objectSpreadInference.ts, 16, 3))
 >infer2 : Symbol(infer2, Decl(objectSpreadInference.ts, 5, 79))
 >a : Symbol(a, Decl(objectSpreadInference.ts, 16, 29))
 
-// should infer { t: {}, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i3 = generic(b, c, { a: 12 });
 >i3 : Symbol(i3, Decl(objectSpreadInference.ts, 18, 3))
 >generic : Symbol(generic, Decl(objectSpreadInference.ts, 6, 80))
@@ -98,144 +98,3 @@ let i3 = generic(b, c, { a: 12 });
 >c : Symbol(c, Decl(objectSpreadInference.ts, 12, 3))
 >a : Symbol(a, Decl(objectSpreadInference.ts, 18, 24))
 
-interface Preserved {
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
-
-    kind: 0 | 1 | 2 | 3;
->kind : Symbol(Preserved.kind, Decl(objectSpreadInference.ts, 20, 21))
-}
-class C implements Preserved {
->C : Symbol(C, Decl(objectSpreadInference.ts, 22, 1))
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
-
-    kind: 0 = 0;
->kind : Symbol(C.kind, Decl(objectSpreadInference.ts, 23, 30))
-
-    a = 1;
->a : Symbol(C.a, Decl(objectSpreadInference.ts, 24, 16))
-
-    method() { return "C"; }
->method : Symbol(C.method, Decl(objectSpreadInference.ts, 25, 10))
-}
-declare function revive<T extends Preserved>(t: { ...T }): T;
->revive : Symbol(revive, Decl(objectSpreadInference.ts, 27, 1))
->T : Symbol(T, Decl(objectSpreadInference.ts, 28, 24))
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
->t : Symbol(t, Decl(objectSpreadInference.ts, 28, 45))
->T : Symbol(T, Decl(objectSpreadInference.ts, 28, 24))
->T : Symbol(T, Decl(objectSpreadInference.ts, 28, 24))
-
-function genericRevive<U extends Preserved>(u: U) {
->genericRevive : Symbol(genericRevive, Decl(objectSpreadInference.ts, 28, 61))
->U : Symbol(U, Decl(objectSpreadInference.ts, 29, 23))
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
->u : Symbol(u, Decl(objectSpreadInference.ts, 29, 44))
->U : Symbol(U, Decl(objectSpreadInference.ts, 29, 23))
-
-    let us: { ...U };
->us : Symbol(us, Decl(objectSpreadInference.ts, 30, 7))
->U : Symbol(U, Decl(objectSpreadInference.ts, 29, 23))
-
-    return revive(us);
->revive : Symbol(revive, Decl(objectSpreadInference.ts, 27, 1))
->us : Symbol(us, Decl(objectSpreadInference.ts, 30, 7))
-}
-// result should not have `method`
-let result = revive({ a: 12, kind: 0 });
->result : Symbol(result, Decl(objectSpreadInference.ts, 34, 3))
->revive : Symbol(revive, Decl(objectSpreadInference.ts, 27, 1))
->a : Symbol(a, Decl(objectSpreadInference.ts, 34, 21))
->kind : Symbol(kind, Decl(objectSpreadInference.ts, 34, 28))
-
-// result2 should be of type C and have `method`
-let result2 = revive<C>({ a: 12, kind: 0 });
->result2 : Symbol(result2, Decl(objectSpreadInference.ts, 36, 3))
->revive : Symbol(revive, Decl(objectSpreadInference.ts, 27, 1))
->C : Symbol(C, Decl(objectSpreadInference.ts, 22, 1))
->a : Symbol(a, Decl(objectSpreadInference.ts, 36, 25))
->kind : Symbol(kind, Decl(objectSpreadInference.ts, 36, 32))
-
-declare function destructureRevive<T extends Preserved>(t: { ...T, a: number }): T;
->destructureRevive : Symbol(destructureRevive, Decl(objectSpreadInference.ts, 36, 44))
->T : Symbol(T, Decl(objectSpreadInference.ts, 38, 35))
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
->t : Symbol(t, Decl(objectSpreadInference.ts, 38, 56))
->T : Symbol(T, Decl(objectSpreadInference.ts, 38, 35))
->a : Symbol(a, Decl(objectSpreadInference.ts, 38, 66))
->T : Symbol(T, Decl(objectSpreadInference.ts, 38, 35))
-
-function genericDestructureRevive<U extends Preserved & { a: number }>(u: U) {
->genericDestructureRevive : Symbol(genericDestructureRevive, Decl(objectSpreadInference.ts, 38, 83))
->U : Symbol(U, Decl(objectSpreadInference.ts, 39, 34))
->Preserved : Symbol(Preserved, Decl(objectSpreadInference.ts, 18, 34))
->a : Symbol(a, Decl(objectSpreadInference.ts, 39, 57))
->u : Symbol(u, Decl(objectSpreadInference.ts, 39, 71))
->U : Symbol(U, Decl(objectSpreadInference.ts, 39, 34))
-
-    let us: { ...U };
->us : Symbol(us, Decl(objectSpreadInference.ts, 40, 7))
->U : Symbol(U, Decl(objectSpreadInference.ts, 39, 34))
-
-    return destructureRevive(us);
->destructureRevive : Symbol(destructureRevive, Decl(objectSpreadInference.ts, 36, 44))
->us : Symbol(us, Decl(objectSpreadInference.ts, 40, 7))
-}
-// result3 is just `Preserved` because `a` and `method` both get removed
-let result3 = destructureRevive({ a: 12, kind: 0 });
->result3 : Symbol(result3, Decl(objectSpreadInference.ts, 44, 3))
->destructureRevive : Symbol(destructureRevive, Decl(objectSpreadInference.ts, 36, 44))
->a : Symbol(a, Decl(objectSpreadInference.ts, 44, 33))
->kind : Symbol(kind, Decl(objectSpreadInference.ts, 44, 40))
-
-// result4 is still C -- a is not removed -- because we specified the argument explicitly
-let result4 = destructureRevive<C>({ a: 12, kind: 0 });
->result4 : Symbol(result4, Decl(objectSpreadInference.ts, 46, 3))
->destructureRevive : Symbol(destructureRevive, Decl(objectSpreadInference.ts, 36, 44))
->C : Symbol(C, Decl(objectSpreadInference.ts, 22, 1))
->a : Symbol(a, Decl(objectSpreadInference.ts, 46, 36))
->kind : Symbol(kind, Decl(objectSpreadInference.ts, 46, 43))
-
-result4.method();
->result4.method : Symbol(C.method, Decl(objectSpreadInference.ts, 25, 10))
->result4 : Symbol(result4, Decl(objectSpreadInference.ts, 46, 3))
->method : Symbol(C.method, Decl(objectSpreadInference.ts, 25, 10))
-
-result4.a;
->result4.a : Symbol(C.a, Decl(objectSpreadInference.ts, 24, 16))
->result4 : Symbol(result4, Decl(objectSpreadInference.ts, 46, 3))
->a : Symbol(C.a, Decl(objectSpreadInference.ts, 24, 16))
-
-declare function removeIndexSignature<T>(t: { ...T, a: number, [s: string]: number, [n: number]: number }): T;
->removeIndexSignature : Symbol(removeIndexSignature, Decl(objectSpreadInference.ts, 48, 10))
->T : Symbol(T, Decl(objectSpreadInference.ts, 50, 38))
->t : Symbol(t, Decl(objectSpreadInference.ts, 50, 41))
->T : Symbol(T, Decl(objectSpreadInference.ts, 50, 38))
->a : Symbol(a, Decl(objectSpreadInference.ts, 50, 51))
->s : Symbol(s, Decl(objectSpreadInference.ts, 50, 64))
->n : Symbol(n, Decl(objectSpreadInference.ts, 50, 85))
->T : Symbol(T, Decl(objectSpreadInference.ts, 50, 38))
-
-interface I {
->I : Symbol(I, Decl(objectSpreadInference.ts, 50, 110))
-
-    a: number;
->a : Symbol(I.a, Decl(objectSpreadInference.ts, 51, 13))
-
-    b: number;
->b : Symbol(I.b, Decl(objectSpreadInference.ts, 52, 14))
-
-    [s: string]: number;
->s : Symbol(s, Decl(objectSpreadInference.ts, 54, 5))
-
-    [n: number]: number;
->n : Symbol(n, Decl(objectSpreadInference.ts, 55, 5))
-}
-let i: I;
->i : Symbol(i, Decl(objectSpreadInference.ts, 57, 3))
->I : Symbol(I, Decl(objectSpreadInference.ts, 50, 110))
-
-let result5 = removeIndexSignature(i);
->result5 : Symbol(result5, Decl(objectSpreadInference.ts, 58, 3))
->removeIndexSignature : Symbol(removeIndexSignature, Decl(objectSpreadInference.ts, 48, 10))
->i : Symbol(i, Decl(objectSpreadInference.ts, 57, 3))
-
diff --git a/tests/baselines/reference/objectSpreadInference.types b/tests/baselines/reference/objectSpreadInference.types
index 55303119932..3e71e29b83c 100644
--- a/tests/baselines/reference/objectSpreadInference.types
+++ b/tests/baselines/reference/objectSpreadInference.types
@@ -83,10 +83,10 @@ let c: { c: number };
 >c : { c: number; }
 >c : number
 
-// should infer { t: {}, u: { b: number, c: number }, v: number }
+// can only infer { t: {}, u: {}, v: {} }
 let i1 = infer({ ...b, ...c, a: 12 });
->i1 : { t: {}; u: { c: number; b: number; }; v: number; }
->infer({ ...b, ...c, a: 12 }) : { t: {}; u: { c: number; b: number; }; v: number; }
+>i1 : { t: {}; u: {}; v: {}; }
+>infer({ ...b, ...c, a: 12 }) : { t: {}; u: {}; v: {}; }
 >infer : <T, U, V>(tuv: { ...T; ...U; a: V; }) => { t: T; u: U; v: V; }
 >{ ...b, ...c, a: 12 } : { a: number; c: number; b: number; }
 >b : any
@@ -94,10 +94,10 @@ let i1 = infer({ ...b, ...c, a: 12 });
 >a : number
 >12 : 12
 
-// should infer { t: { a: number, b: number, c: number }, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i2 = infer2({ ...b, ...c, a: 12 });
->i2 : { t: { a: number; c: number; b: number; }; u: {}; v: {}; }
->infer2({ ...b, ...c, a: 12 }) : { t: { a: number; c: number; b: number; }; u: {}; v: {}; }
+>i2 : { t: {}; u: {}; v: {}; }
+>infer2({ ...b, ...c, a: 12 }) : { t: {}; u: {}; v: {}; }
 >infer2 : <T, U, V>(utv: { ...U; a: V; ...T }) => { t: T; u: U; v: V; }
 >{ ...b, ...c, a: 12 } : { a: number; c: number; b: number; }
 >b : any
@@ -105,7 +105,7 @@ let i2 = infer2({ ...b, ...c, a: 12 });
 >a : number
 >12 : 12
 
-// should infer { t: {}, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i3 = generic(b, c, { a: 12 });
 >i3 : { t: {}; u: {}; v: {}; }
 >generic(b, c, { a: 12 }) : { t: {}; u: {}; v: {}; }
@@ -116,167 +116,3 @@ let i3 = generic(b, c, { a: 12 });
 >a : number
 >12 : 12
 
-interface Preserved {
->Preserved : Preserved
-
-    kind: 0 | 1 | 2 | 3;
->kind : 0 | 1 | 2 | 3
-}
-class C implements Preserved {
->C : C
->Preserved : Preserved
-
-    kind: 0 = 0;
->kind : 0
->0 : 0
-
-    a = 1;
->a : number
->1 : 1
-
-    method() { return "C"; }
->method : () => string
->"C" : "C"
-}
-declare function revive<T extends Preserved>(t: { ...T }): T;
->revive : <T extends Preserved>(t: { ...T }) => T
->T : T
->Preserved : Preserved
->t : { ...T }
->T : T
->T : T
-
-function genericRevive<U extends Preserved>(u: U) {
->genericRevive : <U extends Preserved>(u: U) => U
->U : U
->Preserved : Preserved
->u : U
->U : U
-
-    let us: { ...U };
->us : { ...U }
->U : U
-
-    return revive(us);
->revive(us) : U
->revive : <T extends Preserved>(t: { ...T }) => T
->us : { ...U }
-}
-// result should not have `method`
-let result = revive({ a: 12, kind: 0 });
->result : { a: number; kind: 0; }
->revive({ a: 12, kind: 0 }) : { a: number; kind: 0; }
->revive : <T extends Preserved>(t: { ...T }) => T
->{ a: 12, kind: 0 } : { a: number; kind: 0; }
->a : number
->12 : 12
->kind : number
->0 : 0
-
-// result2 should be of type C and have `method`
-let result2 = revive<C>({ a: 12, kind: 0 });
->result2 : C
->revive<C>({ a: 12, kind: 0 }) : C
->revive : <T extends Preserved>(t: { ...T }) => T
->C : C
->{ a: 12, kind: 0 } : { a: number; kind: 0; }
->a : number
->12 : 12
->kind : number
->0 : 0
-
-declare function destructureRevive<T extends Preserved>(t: { ...T, a: number }): T;
->destructureRevive : <T extends Preserved>(t: { ...T; a: number; }) => T
->T : T
->Preserved : Preserved
->t : { ...T; a: number; }
->T : T
->a : number
->T : T
-
-function genericDestructureRevive<U extends Preserved & { a: number }>(u: U) {
->genericDestructureRevive : <U extends Preserved & { a: number; }>(u: U) => Preserved
->U : U
->Preserved : Preserved
->a : number
->u : U
->U : U
-
-    let us: { ...U };
->us : { ...U }
->U : U
-
-    return destructureRevive(us);
->destructureRevive(us) : Preserved
->destructureRevive : <T extends Preserved>(t: { ...T; a: number; }) => T
->us : { ...U }
-}
-// result3 is just `Preserved` because `a` and `method` both get removed
-let result3 = destructureRevive({ a: 12, kind: 0 });
->result3 : { kind: 0; }
->destructureRevive({ a: 12, kind: 0 }) : { kind: 0; }
->destructureRevive : <T extends Preserved>(t: { ...T; a: number; }) => T
->{ a: 12, kind: 0 } : { a: number; kind: 0; }
->a : number
->12 : 12
->kind : number
->0 : 0
-
-// result4 is still C -- a is not removed -- because we specified the argument explicitly
-let result4 = destructureRevive<C>({ a: 12, kind: 0 });
->result4 : C
->destructureRevive<C>({ a: 12, kind: 0 }) : C
->destructureRevive : <T extends Preserved>(t: { ...T; a: number; }) => T
->C : C
->{ a: 12, kind: 0 } : { a: number; kind: 0; }
->a : number
->12 : 12
->kind : number
->0 : 0
-
-result4.method();
->result4.method() : string
->result4.method : () => string
->result4 : C
->method : () => string
-
-result4.a;
->result4.a : number
->result4 : C
->a : number
-
-declare function removeIndexSignature<T>(t: { ...T, a: number, [s: string]: number, [n: number]: number }): T;
->removeIndexSignature : <T>(t: { ...T; [s: string]: number; [n: number]: number; a: number; }) => T
->T : T
->t : { ...T; [s: string]: number; [n: number]: number; a: number; }
->T : T
->a : number
->s : string
->n : number
->T : T
-
-interface I {
->I : I
-
-    a: number;
->a : number
-
-    b: number;
->b : number
-
-    [s: string]: number;
->s : string
-
-    [n: number]: number;
->n : number
-}
-let i: I;
->i : I
->I : I
-
-let result5 = removeIndexSignature(i);
->result5 : { b: number; }
->removeIndexSignature(i) : { b: number; }
->removeIndexSignature : <T>(t: { ...T; [s: string]: number; [n: number]: number; a: number; }) => T
->i : I
-
diff --git a/tests/cases/conformance/types/spread/objectSpreadInference.ts b/tests/cases/conformance/types/spread/objectSpreadInference.ts
index 19841932419..9608f0a16cb 100644
--- a/tests/cases/conformance/types/spread/objectSpreadInference.ts
+++ b/tests/cases/conformance/types/spread/objectSpreadInference.ts
@@ -11,49 +11,9 @@ function generic<W, X, Y>(w: W, x: X, y: Y) {
 }
 let b: { b: number };
 let c: { c: number };
-// should infer { t: {}, u: { b: number, c: number }, v: number }
+// can only infer { t: {}, u: {}, v: {} }
 let i1 = infer({ ...b, ...c, a: 12 });
-// should infer { t: { a: number, b: number, c: number }, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i2 = infer2({ ...b, ...c, a: 12 });
-// should infer { t: {}, u: {}, v: {} }
+// can only infer { t: {}, u: {}, v: {} }
 let i3 = generic(b, c, { a: 12 });
-
-interface Preserved {
-    kind: 0 | 1 | 2 | 3;
-}
-class C implements Preserved {
-    kind: 0 = 0;
-    a = 1;
-    method() { return "C"; }
-}
-declare function revive<T extends Preserved>(t: { ...T }): T;
-function genericRevive<U extends Preserved>(u: U) {
-    let us: { ...U };
-    return revive(us);
-}
-// result should not have `method`
-let result = revive({ a: 12, kind: 0 });
-// result2 should be of type C and have `method`
-let result2 = revive<C>({ a: 12, kind: 0 });
-
-declare function destructureRevive<T extends Preserved>(t: { ...T, a: number }): T;
-function genericDestructureRevive<U extends Preserved & { a: number }>(u: U) {
-    let us: { ...U };
-    return destructureRevive(us);
-}
-// result3 is just `Preserved` because `a` and `method` both get removed
-let result3 = destructureRevive({ a: 12, kind: 0 });
-// result4 is still C -- a is not removed -- because we specified the argument explicitly
-let result4 = destructureRevive<C>({ a: 12, kind: 0 });
-result4.method();
-result4.a;
-
-declare function removeIndexSignature<T>(t: { ...T, a: number, [s: string]: number, [n: number]: number }): T;
-interface I {
-    a: number;
-    b: number;
-    [s: string]: number;
-    [n: number]: number;
-}
-let i: I;
-let result5 = removeIndexSignature(i);