diff --git a/tests/baselines/reference/asyncFunctionTempVariableScoping.types b/tests/baselines/reference/asyncFunctionTempVariableScoping.types
index cc477523cb9..30b23994903 100644
--- a/tests/baselines/reference/asyncFunctionTempVariableScoping.types
+++ b/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
diff --git a/tests/baselines/reference/forLoopWithDestructuringDoesNotElideFollowingStatement.types b/tests/baselines/reference/forLoopWithDestructuringDoesNotElideFollowingStatement.types
index 600c4f9d717..246c6d2e7db 100644
--- a/tests/baselines/reference/forLoopWithDestructuringDoesNotElideFollowingStatement.types
+++ b/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
diff --git a/tests/baselines/reference/importHelpersInAmbientContext.types b/tests/baselines/reference/importHelpersInAmbientContext.types
index 794bdb2e418..0c3365d7d93 100644
--- a/tests/baselines/reference/importHelpersInAmbientContext.types
+++ b/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 ===
diff --git a/tests/baselines/reference/nonPrimitiveAccessProperty.types b/tests/baselines/reference/nonPrimitiveAccessProperty.types
index 5218aa20fda..900df294d9b 100644
--- a/tests/baselines/reference/nonPrimitiveAccessProperty.types
+++ b/tests/baselines/reference/nonPrimitiveAccessProperty.types
@@ -19,6 +19,6 @@ var { destructuring } = a; // error
 >a : object
 
 var { ...rest } = a; // ok
->rest : object
+>rest : {}
 >a : object
 
diff --git a/tests/baselines/reference/objectRest.errors.txt b/tests/baselines/reference/objectRest.errors.txt
index 48d8bd3f328..2cee03225c3 100644
--- a/tests/baselines/reference/objectRest.errors.txt
+++ b/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;
     
\ No newline at end of file
diff --git a/tests/baselines/reference/objectRest.types b/tests/baselines/reference/objectRest.types
index 6a5f823e9dd..dfce7e47912 100644
--- a/tests/baselines/reference/objectRest.types
+++ b/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
 
diff --git a/tests/baselines/reference/objectRestAssignment.types b/tests/baselines/reference/objectRestAssignment.types
index 04507f688cb..c0c84b6d5e3 100644
--- a/tests/baselines/reference/objectRestAssignment.types
+++ b/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; }
 
diff --git a/tests/baselines/reference/objectRestForOf.types b/tests/baselines/reference/objectRestForOf.types
index 107a38ecea6..30e10999bc7 100644
--- a/tests/baselines/reference/objectRestForOf.types
+++ b/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
diff --git a/tests/baselines/reference/objectRestNegative.errors.txt b/tests/baselines/reference/objectRestNegative.errors.txt
index 8e599f26639..42b25d137ef 100644
--- a/tests/baselines/reference/objectRestNegative.errors.txt
+++ b/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'.
     
diff --git a/tests/baselines/reference/objectRestNegative.types b/tests/baselines/reference/objectRestNegative.types
index 8287f870599..58ed1902f6d 100644
--- a/tests/baselines/reference/objectRestNegative.types
+++ b/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 }
diff --git a/tests/baselines/reference/objectRestParameter.symbols b/tests/baselines/reference/objectRestParameter.symbols
index 536689ae567..f629f46e8e9 100644
--- a/tests/baselines/reference/objectRestParameter.symbols
+++ b/tests/baselines/reference/objectRestParameter.symbols
@@ -21,9 +21,9 @@ suddenly(({ x: a, ...rest }) => rest.y);
 >x : Symbol(x, Decl(objectRestParameter.ts, 3, 34))
 >a : Symbol(a, Decl(objectRestParameter.ts, 4, 11))
 >rest : Symbol(rest, Decl(objectRestParameter.ts, 4, 17))
->rest.y : Symbol(y)
+>rest.y : Symbol(y, Decl(objectRestParameter.ts, 3, 48))
 >rest : Symbol(rest, Decl(objectRestParameter.ts, 4, 17))
->y : Symbol(y)
+>y : Symbol(y, Decl(objectRestParameter.ts, 3, 48))
 
 suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
 >suddenly : Symbol(suddenly, Decl(objectRestParameter.ts, 1, 1))
@@ -35,12 +35,12 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >z : Symbol(z, Decl(objectRestParameter.ts, 5, 56))
 >ka : Symbol(ka, Decl(objectRestParameter.ts, 5, 62))
 >y : Symbol(y, Decl(objectRestParameter.ts, 5, 71))
->rest.y : Symbol(y)
+>rest.y : Symbol(y, Decl(objectRestParameter.ts, 3, 48))
 >rest : Symbol(rest, Decl(objectRestParameter.ts, 5, 37))
->y : Symbol(y)
->nested.ka : Symbol(ka)
+>y : Symbol(y, Decl(objectRestParameter.ts, 3, 48))
+>nested.ka : Symbol(ka, Decl(objectRestParameter.ts, 3, 42))
 >nested : Symbol(nested, Decl(objectRestParameter.ts, 5, 24))
->ka : Symbol(ka)
+>ka : Symbol(ka, Decl(objectRestParameter.ts, 3, 42))
 
 class C {
 >C : Symbol(C, Decl(objectRestParameter.ts, 5, 107))
diff --git a/tests/baselines/reference/objectRestParameter.types b/tests/baselines/reference/objectRestParameter.types
index c3d1c4f01f2..831ac9df59f 100644
--- a/tests/baselines/reference/objectRestParameter.types
+++ b/tests/baselines/reference/objectRestParameter.types
@@ -2,7 +2,7 @@
 function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
 >cloneAgain : ({ a, ...clone }: { a: number; b: string; }) => void
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 }
@@ -22,9 +22,9 @@ suddenly(({ x: a, ...rest }) => rest.y);
 >({ x: a, ...rest }) => rest.y : ({ x: a, ...rest }: { x: { z: any; ka: any; }; y: string; }) => string
 >x : any
 >a : { z: any; ka: any; }
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >rest.y : string
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >y : string
 
 suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
@@ -34,8 +34,8 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >x : any
 >z : any
 >12 : 12
->nested : Rest<{ z: any; ka: any; }, "z">
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>nested : { ka: any; }
+>rest : { y: string; }
 >{ x: { z: 1, ka: 1 }, y: 'noo' } : { x: { z: number; ka: number; }; y: string; }
 >x : { z: number; ka: number; }
 >{ z: 1, ka: 1 } : { z: number; ka: number; }
@@ -47,10 +47,10 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >'noo' : "noo"
 >rest.y + nested.ka : string
 >rest.y : string
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >y : string
 >nested.ka : any
->nested : Rest<{ z: any; ka: any; }, "z">
+>nested : { ka: any; }
 >ka : any
 
 class C {
@@ -59,7 +59,7 @@ class C {
     m({ a, ...clone }: { a: number, b: string}): void {
 >m : ({ a, ...clone }: { a: number; b: string; }) => void
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 
@@ -68,7 +68,7 @@ class C {
     set p({ a, ...clone }: { a: number, b: string}) {
 >p : { a: number; b: string; }
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 
diff --git a/tests/baselines/reference/objectRestParameterES5.symbols b/tests/baselines/reference/objectRestParameterES5.symbols
index c397e137799..4c6b8115169 100644
--- a/tests/baselines/reference/objectRestParameterES5.symbols
+++ b/tests/baselines/reference/objectRestParameterES5.symbols
@@ -21,9 +21,9 @@ suddenly(({ x: a, ...rest }) => rest.y);
 >x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34))
 >a : Symbol(a, Decl(objectRestParameterES5.ts, 4, 11))
 >rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17))
->rest.y : Symbol(y)
+>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
 >rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17))
->y : Symbol(y)
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
 
 suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
 >suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1))
@@ -35,12 +35,12 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >z : Symbol(z, Decl(objectRestParameterES5.ts, 5, 56))
 >ka : Symbol(ka, Decl(objectRestParameterES5.ts, 5, 62))
 >y : Symbol(y, Decl(objectRestParameterES5.ts, 5, 71))
->rest.y : Symbol(y)
+>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
 >rest : Symbol(rest, Decl(objectRestParameterES5.ts, 5, 37))
->y : Symbol(y)
->nested.ka : Symbol(ka)
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+>nested.ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42))
 >nested : Symbol(nested, Decl(objectRestParameterES5.ts, 5, 24))
->ka : Symbol(ka)
+>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42))
 
 class C {
 >C : Symbol(C, Decl(objectRestParameterES5.ts, 5, 107))
diff --git a/tests/baselines/reference/objectRestParameterES5.types b/tests/baselines/reference/objectRestParameterES5.types
index 329f69bedcd..1b8dd29e29e 100644
--- a/tests/baselines/reference/objectRestParameterES5.types
+++ b/tests/baselines/reference/objectRestParameterES5.types
@@ -2,7 +2,7 @@
 function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
 >cloneAgain : ({ a, ...clone }: { a: number; b: string; }) => void
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 }
@@ -22,9 +22,9 @@ suddenly(({ x: a, ...rest }) => rest.y);
 >({ x: a, ...rest }) => rest.y : ({ x: a, ...rest }: { x: { z: any; ka: any; }; y: string; }) => string
 >x : any
 >a : { z: any; ka: any; }
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >rest.y : string
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >y : string
 
 suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
@@ -34,8 +34,8 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >x : any
 >z : any
 >12 : 12
->nested : Rest<{ z: any; ka: any; }, "z">
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>nested : { ka: any; }
+>rest : { y: string; }
 >{ x: { z: 1, ka: 1 }, y: 'noo' } : { x: { z: number; ka: number; }; y: string; }
 >x : { z: number; ka: number; }
 >{ z: 1, ka: 1 } : { z: number; ka: number; }
@@ -47,10 +47,10 @@ suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo'
 >'noo' : "noo"
 >rest.y + nested.ka : string
 >rest.y : string
->rest : Rest<{ x: { z: any; ka: any; }; y: string; }, "x">
+>rest : { y: string; }
 >y : string
 >nested.ka : any
->nested : Rest<{ z: any; ka: any; }, "z">
+>nested : { ka: any; }
 >ka : any
 
 class C {
@@ -59,7 +59,7 @@ class C {
     m({ a, ...clone }: { a: number, b: string}): void {
 >m : ({ a, ...clone }: { a: number; b: string; }) => void
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 
@@ -68,7 +68,7 @@ class C {
     set p({ a, ...clone }: { a: number, b: string}) {
 >p : { a: number; b: string; }
 >a : number
->clone : Rest<{ a: number; b: string; }, "a">
+>clone : { b: string; }
 >a : number
 >b : string
 
diff --git a/tests/baselines/reference/objectRestReadonly.symbols b/tests/baselines/reference/objectRestReadonly.symbols
index ef32c8b616a..f2a7504e9b5 100644
--- a/tests/baselines/reference/objectRestReadonly.symbols
+++ b/tests/baselines/reference/objectRestReadonly.symbols
@@ -34,7 +34,7 @@ const { foo, ...rest } = obj
 >obj : Symbol(obj, Decl(objectRestReadonly.ts, 7, 5))
 
 delete rest.baz
->rest.baz : Symbol(baz)
+>rest.baz : Symbol(baz, Decl(objectRestReadonly.ts, 2, 13))
 >rest : Symbol(rest, Decl(objectRestReadonly.ts, 13, 12))
->baz : Symbol(baz)
+>baz : Symbol(baz, Decl(objectRestReadonly.ts, 2, 13))
 
diff --git a/tests/baselines/reference/objectRestReadonly.types b/tests/baselines/reference/objectRestReadonly.types
index d21b5793c66..5f015aeb1e5 100644
--- a/tests/baselines/reference/objectRestReadonly.types
+++ b/tests/baselines/reference/objectRestReadonly.types
@@ -32,12 +32,12 @@ const obj: Readonly<ObjType> = {
 
 const { foo, ...rest } = obj
 >foo : string
->rest : Rest<Readonly<ObjType>, "foo">
+>rest : { baz: string; quux: string; }
 >obj : Readonly<ObjType>
 
 delete rest.baz
 >delete rest.baz : boolean
 >rest.baz : string
->rest : Rest<Readonly<ObjType>, "foo">
+>rest : { baz: string; quux: string; }
 >baz : string
 
diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols
index e3e6dcdc9a4..857310bf87c 100644
--- a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols
+++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols
@@ -18,9 +18,9 @@ function foobar({ bar = {}, ...opts }: Foo = {}) {
     "use strict";
     "Some other prologue";
     opts.baz(bar);
->opts.baz : Symbol(baz)
+>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
 >opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 27))
->baz : Symbol(baz)
+>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
 >bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 17))
 }
 
@@ -35,9 +35,9 @@ class C {
         "use strict";
         "Some other prologue";
         opts.baz(bar);
->opts.baz : Symbol(baz)
+>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
 >opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 27))
->baz : Symbol(baz)
+>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
 >bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 17))
     }
 }
diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types
index 28f71d1362b..bbdf5580a60 100644
--- a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types
+++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types
@@ -11,7 +11,7 @@ function foobar({ bar = {}, ...opts }: Foo = {}) {
 >foobar : ({ bar, ...opts }?: Foo) => void
 >bar : any
 >{} : {}
->opts : Rest<Foo, "bar">
+>opts : { baz?: any; }
 >{} : {}
 
     "use strict";
@@ -23,7 +23,7 @@ function foobar({ bar = {}, ...opts }: Foo = {}) {
     opts.baz(bar);
 >opts.baz(bar) : any
 >opts.baz : any
->opts : Rest<Foo, "bar">
+>opts : { baz?: any; }
 >baz : any
 >bar : any
 }
@@ -34,7 +34,7 @@ class C {
     constructor({ bar = {}, ...opts }: Foo = {}) {
 >bar : any
 >{} : {}
->opts : Rest<Foo, "bar">
+>opts : { baz?: any; }
 >{} : {}
 
         "use strict";
@@ -46,7 +46,7 @@ class C {
         opts.baz(bar);
 >opts.baz(bar) : any
 >opts.baz : any
->opts : Rest<Foo, "bar">
+>opts : { baz?: any; }
 >baz : any
 >bar : any
     }
diff --git a/tests/baselines/reference/restInvalidArgumentType.types b/tests/baselines/reference/restInvalidArgumentType.types
index e04395b2407..54af9099c31 100644
--- a/tests/baselines/reference/restInvalidArgumentType.types
+++ b/tests/baselines/reference/restInvalidArgumentType.types
@@ -71,7 +71,7 @@ function f<T extends { b: string }>(p1: T, p2: T[]) {
 >p1 : T
 
     var {...r2} = p2;   // OK
->r2 : T[]
+>r2 : { [n: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >p2 : T[]
 
     var {...r3} = t;   // Error, generic type paramter
diff --git a/tests/baselines/reference/unusedLocalsAndObjectSpread.types b/tests/baselines/reference/unusedLocalsAndObjectSpread.types
index 233ea57ae6f..3fc4ae1e751 100644
--- a/tests/baselines/reference/unusedLocalsAndObjectSpread.types
+++ b/tests/baselines/reference/unusedLocalsAndObjectSpread.types
@@ -18,7 +18,7 @@ function one() {
     // 'a' is declared but never used
     const {a, ...bar} = foo;
 >a : number
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 >foo : { a: number; b: number; }
 
     console.log(bar);
@@ -26,7 +26,7 @@ function one() {
 >console.log : (a: any) => void
 >console : { log(a: any): void; }
 >log : (a: any) => void
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 }
 
 function two() {
@@ -44,7 +44,7 @@ function two() {
     const {a: _, ...bar} = foo;
 >a : any
 >_ : number
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 >foo : { a: number; b: number; }
 
     console.log(bar);
@@ -52,7 +52,7 @@ function two() {
 >console.log : (a: any) => void
 >console : { log(a: any): void; }
 >log : (a: any) => void
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 }
 
 function three() {
@@ -69,7 +69,7 @@ function three() {
     // 'a' is declared but never used
     const {a, ...bar} = foo; // bar should be unused
 >a : number
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 >foo : { a: number; b: number; }
 
     //console.log(bar);
@@ -90,7 +90,7 @@ function four() {
     const {a: _, ...bar} = foo; // bar should be unused
 >a : any
 >_ : number
->bar : Rest<{ a: number; b: number; }, "a">
+>bar : { b: number; }
 >foo : { a: number; b: number; }
 
     //console.log(bar);