Array.prototype.slice() returns this

src/lib/core.d.ts

@@ -1032,6 +1032,12 @@ interface Array<T> {
       * Removes the first element from an array and returns it.
       */
     shift(): T;
+
+    /** 
+      * Returns a shallow copy of an array.
+      */
+    slice(): this;
+
     /** 
       * Returns a section of an array.
       * @param start The beginning of the specified portion of the array.

tests/baselines/reference/2dArrays.symbols

@@ -25,11 +25,11 @@ class Board {
 >allShipsSunk : Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
 
         return this.ships.every(function (val) { return val.isSunk; });
->this.ships.every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>this.ships.every : Symbol(Array.every, Decl(lib.d.ts, 1100, 62))
 >this.ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
 >ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>every : Symbol(Array.every, Decl(lib.d.ts, 1100, 62))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))

tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols

@@ -11,11 +11,11 @@ module A {
 
     export var beez: Array<B>;
 >beez : Symbol(beez, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 5, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
 
     export var beez2 = new Array<B>();
 >beez2 : Symbol(beez2, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 6, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
 }

tests/baselines/reference/TypeGuardWithArrayUnion.symbols

@@ -14,7 +14,7 @@ function saySize(message: Message | Message[]) {
 
     if (message instanceof Array) {
 >message : Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
         return message.length;  // Should have type Message[] here
 >message.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))

tests/baselines/reference/anyInferenceAnonymousFunctions.symbols

@@ -3,9 +3,9 @@ var paired: any[];
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 
 paired.reduce(function (a1, a2) {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
 >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27))
 
@@ -15,9 +15,9 @@ paired.reduce(function (a1, a2) {
 } , []);
 
 paired.reduce((b1, b2) => {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
 >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18))
 
@@ -27,24 +27,24 @@ paired.reduce((b1, b2) => {
 } , []);
 
 paired.reduce((b3, b4) => b3.concat({}), []);
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1135, 93), Decl(lib.d.ts, 1142, 120))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 
 paired.map((c1) => c1.count);
->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 
 paired.map(function (c2) { return c2.count; });
->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 

tests/baselines/reference/argumentsObjectIterator02_ES6.symbols

@@ -9,9 +9,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
     let blah = arguments[Symbol.iterator];
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
 >arguments : Symbol(arguments)
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3896, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3846, 52), Decl(lib.d.ts, 3952, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3896, 31))
 
     let result = [];
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))

tests/baselines/reference/arrayAugment.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/arrayAugment.ts ===
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(arrayAugment.ts, 0, 0))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11), Decl(arrayAugment.ts, 0, 0))
 >T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(arrayAugment.ts, 0, 16))
 
     split: (parts: number) => T[][];

tests/baselines/reference/arrayConcat2.symbols

@@ -14,7 +14,7 @@ a.concat('Hello');
 
 var b = new Array<string>();
 >b : Symbol(b, Decl(arrayConcat2.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 b.concat('hello');
 >b.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))

tests/baselines/reference/arrayConcatMap.symbols

@@ -1,14 +1,14 @@
 === tests/cases/compiler/arrayConcatMap.ts ===
 var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >x : Symbol(x, Decl(arrayConcatMap.ts, 0, 3))
->[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >[].concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
 >concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32))
 
           .map(b => b.a);
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, 1121, 92))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 

tests/baselines/reference/arrayConstructors1.symbols

@@ -4,28 +4,28 @@ var x: string[];
 
 x = new Array(1);
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 x = new Array('hi', 'bye'); 
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 x = new Array<string>('hi', 'bye');
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 var y: number[];
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
 
 y = new Array(1);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 y = new Array(1,2);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 y = new Array<number>(1, 2);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 

tests/baselines/reference/arrayLiteral.symbols

@@ -6,7 +6,7 @@ var x = [];
 
 var x = new Array(1);
 >x : Symbol(x, Decl(arrayLiteral.ts, 2, 3), Decl(arrayLiteral.ts, 3, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 var y = [1];
 >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3))
@@ -16,14 +16,14 @@ var y = [1, 2];
 
 var y = new Array<number>();
 >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 var x2: number[] = [];
 >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3))
 
 var x2: number[] = new Array(1);
 >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 
 var y2: number[] = [1];
 >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3))
@@ -33,5 +33,5 @@ var y2: number[] = [1, 2];
 
 var y2: number[] = new Array<number>();
 >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 

tests/baselines/reference/arrayLiterals2ES5.symbols

@@ -80,12 +80,12 @@ var temp4 = [];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES5.ts, 42, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES5.ts, 44, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 >String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
 

tests/baselines/reference/arrayLiterals2ES6.symbols

@@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11), Decl(lib.d.ts, 4124, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11), Decl(lib.d.ts, 4124, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4242, 1))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))

tests/baselines/reference/arrayconcat.symbols

@@ -39,11 +39,11 @@ class parser {
 >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
->this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, 1060, 45))
 >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
->sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>sort : Symbol(Array.sort, Decl(lib.d.ts, 1060, 45))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
 

tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols

@@ -106,23 +106,23 @@ var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures3.ts, 18, 3))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 18, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 18, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures3.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(assignmentCompatWithCallSignatures3.ts, 19, 3))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 19, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 19, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 var a14: (x: { a: string; b: number }) => Object;
@@ -407,14 +407,14 @@ b11 = a11; // ok
 var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures3.ts, 77, 3))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 77, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 77, 48))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 a12 = b12; // ok
@@ -428,10 +428,10 @@ b12 = a12; // ok
 var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : Symbol(b13, Decl(assignmentCompatWithCallSignatures3.ts, 80, 3))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 80, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1177, 11))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 80, 51))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10))