mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-14 19:16:17 -06:00
Update inference test for spread types
This commit is contained in:
Nathan Shively-Sanders
parent
18c692a429
commit
62c186872d
@ -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);
|
||||
|
||||
@ -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))
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user