Accept new baselines

Author: ahejlsberg

tests/baselines/reference/asyncFunctionTempVariableScoping.types

@@ -5,7 +5,7 @@ async ({ foo, bar, ...rest }) => bar(await foo);
 >async ({ foo, bar, ...rest }) => bar(await foo) : ({ foo, bar, ...rest }: { [x: string]: any; foo: any; bar: any; }) => Promise<any>
 >foo : any
 >bar : any
->rest : Rest<{ [x: string]: any; foo: any; bar: any; }, "foo" | "bar">
+>rest : { [x: string]: any; }
 >bar(await foo) : any
 >bar : any
 >await foo : any

tests/baselines/reference/forLoopWithDestructuringDoesNotElideFollowingStatement.types

@@ -10,7 +10,7 @@ let array = [{a: 0, b: 1}]
 
 for (let { a, ...rest } of array)
 >a : number
->rest : Rest<{ a: number; b: number; }, "a">
+>rest : { b: number; }
 >array : { a: number; b: number; }[]
 
     void a

tests/baselines/reference/importHelpersInAmbientContext.types

@@ -33,7 +33,7 @@ interface Foo {
 }
 export var { a, ...x } : Foo;
 >a : number
->x : Rest<Foo, "a">
+>x : { b: string; }
 
 === tests/cases/compiler/b.ts ===
 export {};
@@ -72,7 +72,7 @@ declare namespace N {
 	}
 	export var { a, ...x } : Foo;
 >a : number
->x : Rest<Foo, "a">
+>x : { b: string; }
 }
 
 === tests/cases/compiler/tslib.d.ts ===

tests/baselines/reference/nonPrimitiveAccessProperty.types

@@ -19,6 +19,6 @@ var { destructuring } = a; // error
 >a : object
 
 var { ...rest } = a; // ok
->rest : object
+>rest : {}
 >a : object
 

tests/baselines/reference/objectRest.errors.txt

@@ -2,9 +2,9 @@ tests/cases/conformance/types/rest/objectRest.ts(7,12): error TS2339: Property '
 tests/cases/conformance/types/rest/objectRest.ts(7,20): error TS2339: Property '1' does not exist on type 'String'.
 tests/cases/conformance/types/rest/objectRest.ts(43,8): error TS2537: Type '{ a: number; b: string; }' has no matching index signature for type 'string'.
 tests/cases/conformance/types/rest/objectRest.ts(43,35): error TS2537: Type '{ a: number; b: string; }' has no matching index signature for type 'string'.
-tests/cases/conformance/types/rest/objectRest.ts(43,57): error TS2403: Subsequent variable declarations must have the same type.  Variable 'o' must be of type '{ a: number; b: string; }', but here has type 'Rest<{ a: number; b: string; }, string>'.
-tests/cases/conformance/types/rest/objectRest.ts(44,53): error TS2322: Type 'Rest<{ a: number; b: string; }, string>' is not assignable to type '{ a: number; b: string; }'.
-  Property 'a' is missing in type 'Rest<{ a: number; b: string; }, string>'.
+tests/cases/conformance/types/rest/objectRest.ts(43,57): error TS2403: Subsequent variable declarations must have the same type.  Variable 'o' must be of type '{ a: number; b: string; }', but here has type '{}'.
+tests/cases/conformance/types/rest/objectRest.ts(44,53): error TS2322: Type '{}' is not assignable to type '{ a: number; b: string; }'.
+  Property 'a' is missing in type '{}'.
 
 
 ==== tests/cases/conformance/types/rest/objectRest.ts (6 errors) ====
@@ -60,11 +60,11 @@ tests/cases/conformance/types/rest/objectRest.ts(44,53): error TS2322: Type 'Res
                                       ~~~~~~~~~
 !!! error TS2537: Type '{ a: number; b: string; }' has no matching index signature for type 'string'.
                                                             ~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'o' must be of type '{ a: number; b: string; }', but here has type 'Rest<{ a: number; b: string; }, string>'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'o' must be of type '{ a: number; b: string; }', but here has type '{}'.
     ({ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o);
                                                         ~
-!!! error TS2322: Type 'Rest<{ a: number; b: string; }, string>' is not assignable to type '{ a: number; b: string; }'.
-!!! error TS2322:   Property 'a' is missing in type 'Rest<{ a: number; b: string; }, string>'.
+!!! error TS2322: Type '{}' is not assignable to type '{ a: number; b: string; }'.
+!!! error TS2322:   Property 'a' is missing in type '{}'.
 
     var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
 

tests/baselines/reference/objectRest.types

@@ -13,32 +13,32 @@ var { ...clone } = o;
 
 var { a, ...justB } = o;
 >a : number
->justB : Rest<{ a: number; b: string; }, "a">
+>justB : { b: string; }
 >o : { a: number; b: string; }
 
 var { a, b: renamed, ...empty } = o;
 >a : number
 >b : any
 >renamed : string
->empty : Rest<{ a: number; b: string; }, "a" | "b">
+>empty : {}
 >o : { a: number; b: string; }
 
 var { ['b']: renamed, ...justA } = o;
 >'b' : "b"
 >renamed : string
->justA : Rest<{ a: number; b: string; }, "b">
+>justA : { a: number; }
 >o : { a: number; b: string; }
 
 var { 'b': renamed, ...justA } = o;
 >renamed : string
->justA : Rest<{ a: number; b: string; }, "b">
+>justA : { a: number; }
 >o : { a: number; b: string; }
 
 var { b: { '0': n, '1': oooo }, ...justA } = o;
 >b : any
 >n : any
 >oooo : any
->justA : Rest<{ a: number; b: string; }, "b">
+>justA : { a: number; }
 >o : { a: number; b: string; }
 
 let o2 = { c: 'terrible idea?', d: 'yes' };
@@ -52,7 +52,7 @@ let o2 = { c: 'terrible idea?', d: 'yes' };
 var { d: renamed, ...d } = o2;
 >d : any
 >renamed : string
->d : Rest<{ c: string; d: string; }, "d">
+>d : { c: string; }
 >o2 : { c: string; d: string; }
 
 let nestedrest: { x: number, n1: { y: number, n2: { z: number, n3: { n4: number } } }, rest: number, restrest: number };
@@ -75,7 +75,7 @@ var { x, n1: { y, n2: { z, n3: { ...nr } } }, ...restrest } = nestedrest;
 >z : number
 >n3 : any
 >nr : { n4: number; }
->restrest : Rest<{ x: number; n1: { y: number; n2: { z: number; n3: { n4: number; }; }; }; rest: number; restrest: number; }, "x" | "n1">
+>restrest : { rest: number; restrest: number; }
 >nestedrest : { x: number; n1: { y: number; n2: { z: number; n3: { n4: number; }; }; }; rest: number; restrest: number; }
 
 let complex: { x: { ka, ki }, y: number };
@@ -88,10 +88,10 @@ let complex: { x: { ka, ki }, y: number };
 var { x: { ka, ...nested }, y: other, ...rest } = complex;
 >x : any
 >ka : any
->nested : Rest<{ ka: any; ki: any; }, "ka">
+>nested : { ki: any; }
 >y : any
 >other : number
->rest : Rest<{ x: { ka: any; ki: any; }; y: number; }, "x" | "y">
+>rest : {}
 >complex : { x: { ka: any; ki: any; }; y: number; }
 
 ({x: { ka, ...nested }, y: other, ...rest} = complex);
@@ -101,15 +101,15 @@ var { x: { ka, ...nested }, y: other, ...rest } = complex;
 >x : { ki: any; ka: any; }
 >{ ka, ...nested } : { ki: any; ka: any; }
 >ka : any
->nested : Rest<{ ka: any; ki: any; }, "ka">
+>nested : { ki: any; }
 >y : number
 >other : number
->rest : Rest<{ x: { ka: any; ki: any; }; y: number; }, "x" | "y">
+>rest : {}
 >complex : { x: { ka: any; ki: any; }; y: number; }
 
 var { x, ...fresh } = { x: 1, y: 2 };
 >x : number
->fresh : Rest<{ x: number; y: number; }, "x">
+>fresh : { y: number; }
 >{ x: 1, y: 2 } : { x: number; y: number; }
 >x : number
 >1 : 1
@@ -121,7 +121,7 @@ var { x, ...fresh } = { x: 1, y: 2 };
 >{ x, ...fresh } = { x: 1, y: 2 } : { x: number; y: number; }
 >{ x, ...fresh } : { y: number; x: number; }
 >x : number
->fresh : Rest<{ x: number; y: number; }, "x">
+>fresh : { y: number; }
 >{ x: 1, y: 2 } : { x: number; y: number; }
 >x : number
 >1 : 1
@@ -175,7 +175,7 @@ var removable = new Removable();
 
 var { removed, ...removableRest } = removable;
 >removed : string
->removableRest : Rest<Removable, "removed">
+>removableRest : { remainder: string; }
 >removable : Removable
 
 var i: I = removable;
@@ -184,7 +184,7 @@ var i: I = removable;
 
 var { removed, ...removableRest2 } = i;
 >removed : string
->removableRest2 : Rest<I, "removed">
+>removableRest2 : { m(): void; remainder: string; }
 >i : I
 
 let computed = 'b';
@@ -221,10 +221,10 @@ var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmp
 >({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes : ({ aNumber, ...notEmptyObject }: { [x: string]: any; aNumber?: number; }) => any
 >aNumber : number
 >12 : 12
->notEmptyObject : Rest<{ [x: string]: any; aNumber?: number; }, "aNumber">
+>notEmptyObject : { [x: string]: any; }
 >aNumber + notEmptyObject.anythingGoes : any
 >aNumber : number
 >notEmptyObject.anythingGoes : any
->notEmptyObject : Rest<{ [x: string]: any; aNumber?: number; }, "aNumber">
+>notEmptyObject : { [x: string]: any; }
 >anythingGoes : any
 

tests/baselines/reference/objectRestAssignment.types

@@ -52,8 +52,8 @@ var { a: [{ ...nested2 }, ...y], b: { z, ...c }, ...rest2 } = overEmit;
 >y : { ka: string; x: string; }[]
 >b : any
 >z : string
->c : Rest<{ z: string; ki: string; ku: string; }, "z">
->rest2 : Rest<{ a: { ka: string; x: string; }[]; b: { z: string; ki: string; ku: string; }; ke: string; ko: string; }, "a" | "b">
+>c : { ki: string; ku: string; }
+>rest2 : { ke: string; ko: string; }
 >overEmit : { a: { ka: string; x: string; }[]; b: { z: string; ki: string; ku: string; }; ke: string; ko: string; }
 
 ({ a: [{ ...nested2 }, ...y], b: { z, ...c }, ...rest2 } = overEmit);
@@ -69,7 +69,7 @@ var { a: [{ ...nested2 }, ...y], b: { z, ...c }, ...rest2 } = overEmit;
 >b : { ki: string; ku: string; z: string; }
 >{ z, ...c } : { ki: string; ku: string; z: string; }
 >z : string
->c : Rest<{ z: string; ki: string; ku: string; }, "z">
->rest2 : Rest<{ a: { ka: string; x: string; }[]; b: { z: string; ki: string; ku: string; }; ke: string; ko: string; }, "a" | "b">
+>c : { ki: string; ku: string; }
+>rest2 : { ke: string; ko: string; }
 >overEmit : { a: { ka: string; x: string; }[]; b: { z: string; ki: string; ku: string; }; ke: string; ko: string; }
 

tests/baselines/reference/objectRestForOf.types

@@ -6,13 +6,13 @@ let array: { x: number, y: string }[];
 
 for (let { x, ...restOf } of array) {
 >x : number
->restOf : Rest<{ x: number; y: string; }, "x">
+>restOf : { y: string; }
 >array : { x: number; y: string; }[]
 
     [x, restOf];
->[x, restOf] : (number | Rest<{ x: number; y: string; }, "x">)[]
+>[x, restOf] : (number | { y: string; })[]
 >x : number
->restOf : Rest<{ x: number; y: string; }, "x">
+>restOf : { y: string; }
 }
 let xx: number;
 >xx : number

tests/baselines/reference/objectRestNegative.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/conformance/types/rest/objectRestNegative.ts(2,10): error TS2462: A rest element must be last in a destructuring pattern.
-tests/cases/conformance/types/rest/objectRestNegative.ts(6,10): error TS2322: Type 'Rest<{ a: number; b: string; }, "b">' is not assignable to type '{ a: string; }'.
+tests/cases/conformance/types/rest/objectRestNegative.ts(6,10): error TS2322: Type '{ a: number; }' is not assignable to type '{ a: string; }'.
   Types of property 'a' are incompatible.
     Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/rest/objectRestNegative.ts(9,31): error TS2462: A rest element must be last in a destructuring pattern.
@@ -18,7 +18,7 @@ tests/cases/conformance/types/rest/objectRestNegative.ts(17,9): error TS2701: Th
     let notAssignable: { a: string };
     ({ b, ...notAssignable } = o);
              ~~~~~~~~~~~~~
-!!! error TS2322: Type 'Rest<{ a: number; b: string; }, "b">' is not assignable to type '{ a: string; }'.
+!!! error TS2322: Type '{ a: number; }' is not assignable to type '{ a: string; }'.
 !!! error TS2322:   Types of property 'a' are incompatible.
 !!! error TS2322:     Type 'number' is not assignable to type 'string'.
 

tests/baselines/reference/objectRestNegative.types

@@ -8,7 +8,7 @@ let o = { a: 1, b: 'no' };
 >'no' : "no"
 
 var { ...mustBeLast, a } = o;
->mustBeLast : Rest<{ a: number; b: string; }, "a">
+>mustBeLast : { b: string; }
 >a : number
 >o : { a: number; b: string; }
 
@@ -30,24 +30,24 @@ let notAssignable: { a: string };
 
 function stillMustBeLast({ ...mustBeLast, a }: { a: number, b: string }): void {
 >stillMustBeLast : ({ ...mustBeLast, a }: { a: number; b: string; }) => void
->mustBeLast : Rest<{ a: number; b: string; }, "a">
+>mustBeLast : { b: string; }
 >a : number
 >a : number
 >b : string
 }
 function generic<T extends { x, y }>(t: T) {
->generic : <T extends { x: any; y: any; }>(t: T) => Rest<T, "x">
+>generic : <T extends { x: any; y: any; }>(t: T) => Pick<T, Exclude<keyof T, "x">>
 >x : any
 >y : any
 >t : T
 
     let { x, ...rest } = t;
 >x : any
->rest : Rest<T, "x">
+>rest : Pick<T, Exclude<keyof T, "x">>
 >t : T
 
     return rest;
->rest : Rest<T, "x">
+>rest : Pick<T, Exclude<keyof T, "x">>
 }
 
 let rest: { b: string }