Accept new baselines

Author: ahejlsberg

tests/baselines/reference/objectRestNegative.errors.txt

@@ -5,10 +5,11 @@ tests/cases/conformance/types/rest/objectRestNegative.ts(6,10): error TS2322: Ty
 tests/cases/conformance/types/rest/objectRestNegative.ts(9,31): error TS2462: A rest element must be last in a destructuring pattern.
 tests/cases/conformance/types/rest/objectRestNegative.ts(11,30): error TS7008: Member 'x' implicitly has an 'any' type.
 tests/cases/conformance/types/rest/objectRestNegative.ts(11,33): error TS7008: Member 'y' implicitly has an 'any' type.
+tests/cases/conformance/types/rest/objectRestNegative.ts(12,17): error TS2700: Rest types may only be created from object types.
 tests/cases/conformance/types/rest/objectRestNegative.ts(17,9): error TS2701: The target of an object rest assignment must be a variable or a property access.
 
 
-==== tests/cases/conformance/types/rest/objectRestNegative.ts (6 errors) ====
+==== tests/cases/conformance/types/rest/objectRestNegative.ts (7 errors) ====
     let o = { a: 1, b: 'no' };
     var { ...mustBeLast, a } = o;
              ~~~~~~~~~~
@@ -33,6 +34,8 @@ tests/cases/conformance/types/rest/objectRestNegative.ts(17,9): error TS2701: Th
                                     ~
 !!! error TS7008: Member 'y' implicitly has an 'any' type.
         let { x, ...rest } = t;
+                    ~~~~
+!!! error TS2700: Rest types may only be created from object types.
         return rest;
     }
 

tests/baselines/reference/objectRestNegative.types

@@ -36,18 +36,18 @@ function stillMustBeLast({ ...mustBeLast, a }: { a: number, b: string }): void {
 >b : string
 }
 function generic<T extends { x, y }>(t: T) {
->generic : <T extends { x: any; y: any; }>(t: T) => { y: any; }
+>generic : <T extends { x: any; y: any; }>(t: T) => any
 >x : any
 >y : any
 >t : T
 
     let { x, ...rest } = t;
 >x : any
->rest : { y: any; }
+>rest : any
 >t : T
 
     return rest;
->rest : { y: any; }
+>rest : any
 }
 
 let rest: { b: string }

tests/baselines/reference/restInvalidArgumentType.errors.txt

@@ -1,5 +1,11 @@
+tests/cases/compiler/restInvalidArgumentType.ts(27,13): error TS2700: Rest types may only be created from object types.
+tests/cases/compiler/restInvalidArgumentType.ts(29,13): error TS2700: Rest types may only be created from object types.
+tests/cases/compiler/restInvalidArgumentType.ts(30,13): error TS2700: Rest types may only be created from object types.
 tests/cases/compiler/restInvalidArgumentType.ts(31,13): error TS2700: Rest types may only be created from object types.
+tests/cases/compiler/restInvalidArgumentType.ts(33,13): error TS2700: Rest types may only be created from object types.
+tests/cases/compiler/restInvalidArgumentType.ts(36,13): error TS2700: Rest types may only be created from object types.
 tests/cases/compiler/restInvalidArgumentType.ts(37,13): error TS2700: Rest types may only be created from object types.
+tests/cases/compiler/restInvalidArgumentType.ts(39,13): error TS2700: Rest types may only be created from object types.
 tests/cases/compiler/restInvalidArgumentType.ts(40,13): error TS2700: Rest types may only be created from object types.
 tests/cases/compiler/restInvalidArgumentType.ts(42,13): error TS2700: Rest types may only be created from object types.
 tests/cases/compiler/restInvalidArgumentType.ts(43,13): error TS2700: Rest types may only be created from object types.
@@ -10,7 +16,7 @@ tests/cases/compiler/restInvalidArgumentType.ts(51,13): error TS2700: Rest types
 tests/cases/compiler/restInvalidArgumentType.ts(53,13): error TS2700: Rest types may only be created from object types.
 
 
-==== tests/cases/compiler/restInvalidArgumentType.ts (10 errors) ====
+==== tests/cases/compiler/restInvalidArgumentType.ts (16 errors) ====
     enum E { v1, v2 };
 
     function f<T extends { b: string }>(p1: T, p2: T[]) {
@@ -38,22 +44,34 @@ tests/cases/compiler/restInvalidArgumentType.ts(53,13): error TS2700: Rest types
         var a: any;
 
         var {...r1} = p1;   // Error, generic type paramterre
+                ~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r2} = p2;   // OK
         var {...r3} = t;   // Error, generic type paramter
+                ~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r4} = i;   // Error, index access
+                ~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r5} = k;   // Error, index
                 ~~
 !!! error TS2700: Rest types may only be created from object types.
 
         var {...r6} = mapped_generic; // Error, generic mapped object type
+                ~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r7} = mapped;  // OK, non-generic mapped type
 
         var {...r8} = union_generic;  // Error, union with generic type parameter
+                ~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r9} = union_primitive;  // Error, union with generic type parameter
                 ~~
 !!! error TS2700: Rest types may only be created from object types.
 
         var {...r10} = intersection_generic;  // Error, intersection with generic type parameter
+                ~~~
+!!! error TS2700: Rest types may only be created from object types.
         var {...r11} = intersection_primitive;  // Error, intersection with generic type parameter
                 ~~~
 !!! error TS2700: Rest types may only be created from object types.

tests/baselines/reference/restInvalidArgumentType.types

@@ -67,43 +67,43 @@ function f<T extends { b: string }>(p1: T, p2: T[]) {
 >a : any
 
     var {...r1} = p1;   // Error, generic type paramterre
->r1 : { b: string; }
+>r1 : any
 >p1 : T
 
     var {...r2} = p2;   // OK
 >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
->r3 : { b: string; }
+>r3 : any
 >t : T
 
     var {...r4} = i;   // Error, index access
->r4 : { readonly [index: number]: string; toString(): string; charAt(pos: number): string; charCodeAt(index: number): number; concat(...strings: string[]): string; indexOf(searchString: string, position?: number): number; lastIndexOf(searchString: string, position?: number): number; localeCompare(that: string): number; localeCompare(that: string, locales?: string | string[], options?: Intl.CollatorOptions): number; match(regexp: string | RegExp): RegExpMatchArray; replace(searchValue: string | RegExp, replaceValue: string): string; replace(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; search(regexp: string | RegExp): number; slice(start?: number, end?: number): string; split(separator: string | RegExp, limit?: number): string[]; substring(start: number, end?: number): string; toLowerCase(): string; toLocaleLowerCase(): string; toUpperCase(): string; toLocaleUpperCase(): string; trim(): string; length: number; substr(from: number, length?: number): string; valueOf(): string; }
+>r4 : any
 >i : T["b"]
 
     var {...r5} = k;   // Error, index
 >r5 : any
 >k : keyof T
 
     var {...r6} = mapped_generic; // Error, generic mapped object type
->r6 : { b: T["b"]; }
+>r6 : any
 >mapped_generic : { [P in keyof T]: T[P]; }
 
     var {...r7} = mapped;  // OK, non-generic mapped type
 >r7 : { b: T["b"]; }
 >mapped : { b: T["b"]; }
 
     var {...r8} = union_generic;  // Error, union with generic type parameter
->r8 : { b: string; } | { a: number; }
+>r8 : any
 >union_generic : T | { a: number; }
 
     var {...r9} = union_primitive;  // Error, union with generic type parameter
 >r9 : any
 >union_primitive : number | { a: number; }
 
     var {...r10} = intersection_generic;  // Error, intersection with generic type parameter
->r10 : { b: string; a: number; }
+>r10 : any
 >intersection_generic : T & { a: number; }
 
     var {...r11} = intersection_primitive;  // Error, intersection with generic type parameter