diff --git a/src/lib/core.d.ts b/src/lib/core.d.ts
index 7259ff5081c31..dc8f40b3f6d91 100644
--- a/src/lib/core.d.ts
+++ b/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.
diff --git a/tests/baselines/reference/implementArrayInterface.js b/tests/baselines/reference/implementArrayInterface.js
index b75de77ea979f..895991f5cdaa7 100644
--- a/tests/baselines/reference/implementArrayInterface.js
+++ b/tests/baselines/reference/implementArrayInterface.js
@@ -9,6 +9,7 @@ declare class MyArray<T> implements Array<T> {
     push(...items: T[]): number;
     reverse(): T[];
     shift(): T;
+    slice(): this;
     slice(start?: number, end?: number): T[];
     sort(compareFn?: (a: T, b: T) => number): T[];
     splice(start: number): T[];
diff --git a/tests/baselines/reference/implementArrayInterface.symbols b/tests/baselines/reference/implementArrayInterface.symbols
index 5a671d41de324..175d187fed686 100644
--- a/tests/baselines/reference/implementArrayInterface.symbols
+++ b/tests/baselines/reference/implementArrayInterface.symbols
@@ -46,172 +46,175 @@ declare class MyArray<T> implements Array<T> {
 >shift : Symbol(shift, Decl(implementArrayInterface.ts, 8, 19))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
+    slice(): this;
+>slice : Symbol(slice, Decl(implementArrayInterface.ts, 9, 15), Decl(implementArrayInterface.ts, 10, 18))
+
     slice(start?: number, end?: number): T[];
->slice : Symbol(slice, Decl(implementArrayInterface.ts, 9, 15))
->start : Symbol(start, Decl(implementArrayInterface.ts, 10, 10))
->end : Symbol(end, Decl(implementArrayInterface.ts, 10, 25))
+>slice : Symbol(slice, Decl(implementArrayInterface.ts, 9, 15), Decl(implementArrayInterface.ts, 10, 18))
+>start : Symbol(start, Decl(implementArrayInterface.ts, 11, 10))
+>end : Symbol(end, Decl(implementArrayInterface.ts, 11, 25))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     sort(compareFn?: (a: T, b: T) => number): T[];
->sort : Symbol(sort, Decl(implementArrayInterface.ts, 10, 45))
->compareFn : Symbol(compareFn, Decl(implementArrayInterface.ts, 11, 9))
->a : Symbol(a, Decl(implementArrayInterface.ts, 11, 22))
+>sort : Symbol(sort, Decl(implementArrayInterface.ts, 11, 45))
+>compareFn : Symbol(compareFn, Decl(implementArrayInterface.ts, 12, 9))
+>a : Symbol(a, Decl(implementArrayInterface.ts, 12, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->b : Symbol(b, Decl(implementArrayInterface.ts, 11, 27))
+>b : Symbol(b, Decl(implementArrayInterface.ts, 12, 27))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     splice(start: number): T[];
->splice : Symbol(splice, Decl(implementArrayInterface.ts, 11, 50), Decl(implementArrayInterface.ts, 12, 31))
->start : Symbol(start, Decl(implementArrayInterface.ts, 12, 11))
+>splice : Symbol(splice, Decl(implementArrayInterface.ts, 12, 50), Decl(implementArrayInterface.ts, 13, 31))
+>start : Symbol(start, Decl(implementArrayInterface.ts, 13, 11))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     splice(start: number, deleteCount: number, ...items: T[]): T[];
->splice : Symbol(splice, Decl(implementArrayInterface.ts, 11, 50), Decl(implementArrayInterface.ts, 12, 31))
->start : Symbol(start, Decl(implementArrayInterface.ts, 13, 11))
->deleteCount : Symbol(deleteCount, Decl(implementArrayInterface.ts, 13, 25))
->items : Symbol(items, Decl(implementArrayInterface.ts, 13, 46))
+>splice : Symbol(splice, Decl(implementArrayInterface.ts, 12, 50), Decl(implementArrayInterface.ts, 13, 31))
+>start : Symbol(start, Decl(implementArrayInterface.ts, 14, 11))
+>deleteCount : Symbol(deleteCount, Decl(implementArrayInterface.ts, 14, 25))
+>items : Symbol(items, Decl(implementArrayInterface.ts, 14, 46))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     unshift(...items: T[]): number;
->unshift : Symbol(unshift, Decl(implementArrayInterface.ts, 13, 67))
->items : Symbol(items, Decl(implementArrayInterface.ts, 14, 12))
+>unshift : Symbol(unshift, Decl(implementArrayInterface.ts, 14, 67))
+>items : Symbol(items, Decl(implementArrayInterface.ts, 15, 12))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     indexOf(searchElement: T, fromIndex?: number): number;
->indexOf : Symbol(indexOf, Decl(implementArrayInterface.ts, 14, 35))
->searchElement : Symbol(searchElement, Decl(implementArrayInterface.ts, 16, 12))
+>indexOf : Symbol(indexOf, Decl(implementArrayInterface.ts, 15, 35))
+>searchElement : Symbol(searchElement, Decl(implementArrayInterface.ts, 17, 12))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->fromIndex : Symbol(fromIndex, Decl(implementArrayInterface.ts, 16, 29))
+>fromIndex : Symbol(fromIndex, Decl(implementArrayInterface.ts, 17, 29))
 
     lastIndexOf(searchElement: T, fromIndex?: number): number;
->lastIndexOf : Symbol(lastIndexOf, Decl(implementArrayInterface.ts, 16, 58))
->searchElement : Symbol(searchElement, Decl(implementArrayInterface.ts, 17, 16))
+>lastIndexOf : Symbol(lastIndexOf, Decl(implementArrayInterface.ts, 17, 58))
+>searchElement : Symbol(searchElement, Decl(implementArrayInterface.ts, 18, 16))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->fromIndex : Symbol(fromIndex, Decl(implementArrayInterface.ts, 17, 33))
+>fromIndex : Symbol(fromIndex, Decl(implementArrayInterface.ts, 18, 33))
 
     every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
->every : Symbol(every, Decl(implementArrayInterface.ts, 17, 62))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 18, 10))
->value : Symbol(value, Decl(implementArrayInterface.ts, 18, 23))
+>every : Symbol(every, Decl(implementArrayInterface.ts, 18, 62))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 19, 10))
+>value : Symbol(value, Decl(implementArrayInterface.ts, 19, 23))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->index : Symbol(index, Decl(implementArrayInterface.ts, 18, 32))
->array : Symbol(array, Decl(implementArrayInterface.ts, 18, 47))
+>index : Symbol(index, Decl(implementArrayInterface.ts, 19, 32))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 19, 47))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 18, 71))
+>thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 19, 71))
 
     some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
->some : Symbol(some, Decl(implementArrayInterface.ts, 18, 96))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 19, 9))
->value : Symbol(value, Decl(implementArrayInterface.ts, 19, 22))
+>some : Symbol(some, Decl(implementArrayInterface.ts, 19, 96))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 20, 9))
+>value : Symbol(value, Decl(implementArrayInterface.ts, 20, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->index : Symbol(index, Decl(implementArrayInterface.ts, 19, 31))
->array : Symbol(array, Decl(implementArrayInterface.ts, 19, 46))
+>index : Symbol(index, Decl(implementArrayInterface.ts, 20, 31))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 20, 46))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 19, 70))
+>thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 20, 70))
 
     forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
->forEach : Symbol(forEach, Decl(implementArrayInterface.ts, 19, 95))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 20, 12))
->value : Symbol(value, Decl(implementArrayInterface.ts, 20, 25))
+>forEach : Symbol(forEach, Decl(implementArrayInterface.ts, 20, 95))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 21, 12))
+>value : Symbol(value, Decl(implementArrayInterface.ts, 21, 25))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->index : Symbol(index, Decl(implementArrayInterface.ts, 20, 34))
->array : Symbol(array, Decl(implementArrayInterface.ts, 20, 49))
+>index : Symbol(index, Decl(implementArrayInterface.ts, 21, 34))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 21, 49))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 20, 70))
+>thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 21, 70))
 
     map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
->map : Symbol(map, Decl(implementArrayInterface.ts, 20, 92))
->U : Symbol(U, Decl(implementArrayInterface.ts, 21, 8))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 21, 11))
->value : Symbol(value, Decl(implementArrayInterface.ts, 21, 24))
->T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->index : Symbol(index, Decl(implementArrayInterface.ts, 21, 33))
->array : Symbol(array, Decl(implementArrayInterface.ts, 21, 48))
->T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->U : Symbol(U, Decl(implementArrayInterface.ts, 21, 8))
->thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 21, 66))
->U : Symbol(U, Decl(implementArrayInterface.ts, 21, 8))
-
-    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
->filter : Symbol(filter, Decl(implementArrayInterface.ts, 21, 87))
+>map : Symbol(map, Decl(implementArrayInterface.ts, 21, 92))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 22, 8))
 >callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 22, 11))
 >value : Symbol(value, Decl(implementArrayInterface.ts, 22, 24))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >index : Symbol(index, Decl(implementArrayInterface.ts, 22, 33))
 >array : Symbol(array, Decl(implementArrayInterface.ts, 22, 48))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 22, 72))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 22, 8))
+>thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 22, 66))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 22, 8))
+
+    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
+>filter : Symbol(filter, Decl(implementArrayInterface.ts, 22, 87))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 23, 11))
+>value : Symbol(value, Decl(implementArrayInterface.ts, 23, 24))
+>T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
+>index : Symbol(index, Decl(implementArrayInterface.ts, 23, 33))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 23, 48))
+>T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
+>thisArg : Symbol(thisArg, Decl(implementArrayInterface.ts, 23, 72))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
->reduce : Symbol(reduce, Decl(implementArrayInterface.ts, 22, 93), Decl(implementArrayInterface.ts, 23, 120))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 23, 11))
->previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 23, 24))
+>reduce : Symbol(reduce, Decl(implementArrayInterface.ts, 23, 93), Decl(implementArrayInterface.ts, 24, 120))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 24, 11))
+>previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 24, 24))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 23, 41))
+>currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 24, 41))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 23, 58))
->array : Symbol(array, Decl(implementArrayInterface.ts, 23, 80))
+>currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 24, 58))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 24, 80))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 23, 98))
+>initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 24, 98))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
->reduce : Symbol(reduce, Decl(implementArrayInterface.ts, 22, 93), Decl(implementArrayInterface.ts, 23, 120))
->U : Symbol(U, Decl(implementArrayInterface.ts, 24, 11))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 24, 14))
->previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 24, 27))
->U : Symbol(U, Decl(implementArrayInterface.ts, 24, 11))
->currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 24, 44))
+>reduce : Symbol(reduce, Decl(implementArrayInterface.ts, 23, 93), Decl(implementArrayInterface.ts, 24, 120))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 25, 11))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 25, 14))
+>previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 25, 27))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 25, 11))
+>currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 25, 44))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 24, 61))
->array : Symbol(array, Decl(implementArrayInterface.ts, 24, 83))
+>currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 25, 61))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 25, 83))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->U : Symbol(U, Decl(implementArrayInterface.ts, 24, 11))
->initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 24, 101))
->U : Symbol(U, Decl(implementArrayInterface.ts, 24, 11))
->U : Symbol(U, Decl(implementArrayInterface.ts, 24, 11))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 25, 11))
+>initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 25, 101))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 25, 11))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 25, 11))
 
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
->reduceRight : Symbol(reduceRight, Decl(implementArrayInterface.ts, 24, 122), Decl(implementArrayInterface.ts, 25, 125))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 25, 16))
->previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 25, 29))
+>reduceRight : Symbol(reduceRight, Decl(implementArrayInterface.ts, 25, 122), Decl(implementArrayInterface.ts, 26, 125))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 26, 16))
+>previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 26, 29))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 25, 46))
+>currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 26, 46))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 25, 63))
->array : Symbol(array, Decl(implementArrayInterface.ts, 25, 85))
+>currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 26, 63))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 26, 85))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 25, 103))
+>initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 26, 103))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
->reduceRight : Symbol(reduceRight, Decl(implementArrayInterface.ts, 24, 122), Decl(implementArrayInterface.ts, 25, 125))
->U : Symbol(U, Decl(implementArrayInterface.ts, 26, 16))
->callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 26, 19))
->previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 26, 32))
->U : Symbol(U, Decl(implementArrayInterface.ts, 26, 16))
->currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 26, 49))
+>reduceRight : Symbol(reduceRight, Decl(implementArrayInterface.ts, 25, 122), Decl(implementArrayInterface.ts, 26, 125))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 27, 16))
+>callbackfn : Symbol(callbackfn, Decl(implementArrayInterface.ts, 27, 19))
+>previousValue : Symbol(previousValue, Decl(implementArrayInterface.ts, 27, 32))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 27, 16))
+>currentValue : Symbol(currentValue, Decl(implementArrayInterface.ts, 27, 49))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 26, 66))
->array : Symbol(array, Decl(implementArrayInterface.ts, 26, 88))
+>currentIndex : Symbol(currentIndex, Decl(implementArrayInterface.ts, 27, 66))
+>array : Symbol(array, Decl(implementArrayInterface.ts, 27, 88))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->U : Symbol(U, Decl(implementArrayInterface.ts, 26, 16))
->initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 26, 106))
->U : Symbol(U, Decl(implementArrayInterface.ts, 26, 16))
->U : Symbol(U, Decl(implementArrayInterface.ts, 26, 16))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 27, 16))
+>initialValue : Symbol(initialValue, Decl(implementArrayInterface.ts, 27, 106))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 27, 16))
+>U : Symbol(U, Decl(implementArrayInterface.ts, 27, 16))
 
     length: number;
->length : Symbol(length, Decl(implementArrayInterface.ts, 26, 127))
+>length : Symbol(length, Decl(implementArrayInterface.ts, 27, 127))
 
     [n: number]: T;
->n : Symbol(n, Decl(implementArrayInterface.ts, 30, 5))
+>n : Symbol(n, Decl(implementArrayInterface.ts, 31, 5))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 }
 
diff --git a/tests/baselines/reference/implementArrayInterface.types b/tests/baselines/reference/implementArrayInterface.types
index 347fcf37693e6..3b6dedf32f197 100644
--- a/tests/baselines/reference/implementArrayInterface.types
+++ b/tests/baselines/reference/implementArrayInterface.types
@@ -46,8 +46,11 @@ declare class MyArray<T> implements Array<T> {
 >shift : () => T
 >T : T
 
+    slice(): this;
+>slice : { (): this; (start?: number, end?: number): T[]; }
+
     slice(start?: number, end?: number): T[];
->slice : (start?: number, end?: number) => T[]
+>slice : { (): this; (start?: number, end?: number): T[]; }
 >start : number
 >end : number
 >T : T
diff --git a/tests/baselines/reference/library_ArraySlice.errors.txt b/tests/baselines/reference/library_ArraySlice.errors.txt
new file mode 100644
index 0000000000000..8b545d810529f
--- /dev/null
+++ b/tests/baselines/reference/library_ArraySlice.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/compiler/library_ArraySlice.ts(9,5): error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
+  Property '0' is missing in type 'number[]'.
+tests/cases/compiler/library_ArraySlice.ts(10,5): error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
+
+
+==== tests/cases/compiler/library_ArraySlice.ts (2 errors) ====
+    // Array.prototype.slice can have zero, one, or two arguments
+    Array.prototype.slice();
+    Array.prototype.slice(0);
+    Array.prototype.slice(0, 1);
+    
+    // Array.prototype.slice returns this with zero arguments, allowing tuple slicing
+    let t1: [number, number] = [1, 2];
+    let t2: [number, number] = t1.slice();
+    let t3: [number, number] = t1.slice(0);
+        ~~
+!!! error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
+!!! error TS2322:   Property '0' is missing in type 'number[]'.
+    let t4: [number, number] = t1.slice(0,1);
+        ~~
+!!! error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/library_ArraySlice.js b/tests/baselines/reference/library_ArraySlice.js
index e4f2222d1fed4..f85bf7b7d094c 100644
--- a/tests/baselines/reference/library_ArraySlice.js
+++ b/tests/baselines/reference/library_ArraySlice.js
@@ -2,10 +2,22 @@
 // Array.prototype.slice can have zero, one, or two arguments
 Array.prototype.slice();
 Array.prototype.slice(0);
-Array.prototype.slice(0, 1);
+Array.prototype.slice(0, 1);
+
+// Array.prototype.slice returns this with zero arguments, allowing tuple slicing
+let t1: [number, number] = [1, 2];
+let t2: [number, number] = t1.slice();
+let t3: [number, number] = t1.slice(0);
+let t4: [number, number] = t1.slice(0,1);
+
 
 //// [library_ArraySlice.js]
 // Array.prototype.slice can have zero, one, or two arguments
 Array.prototype.slice();
 Array.prototype.slice(0);
 Array.prototype.slice(0, 1);
+// Array.prototype.slice returns this with zero arguments, allowing tuple slicing
+var t1 = [1, 2];
+var t2 = t1.slice();
+var t3 = t1.slice(0);
+var t4 = t1.slice(0, 1);
diff --git a/tests/baselines/reference/library_ArraySlice.symbols b/tests/baselines/reference/library_ArraySlice.symbols
deleted file mode 100644
index f29defbc3f959..0000000000000
--- a/tests/baselines/reference/library_ArraySlice.symbols
+++ /dev/null
@@ -1,23 +0,0 @@
-=== tests/cases/compiler/library_ArraySlice.ts ===
-// Array.prototype.slice can have zero, one, or two arguments
-Array.prototype.slice();
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
-
-Array.prototype.slice(0);
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
-
-Array.prototype.slice(0, 1);
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
-
diff --git a/tests/baselines/reference/library_ArraySlice.types b/tests/baselines/reference/library_ArraySlice.types
deleted file mode 100644
index b92d925439013..0000000000000
--- a/tests/baselines/reference/library_ArraySlice.types
+++ /dev/null
@@ -1,29 +0,0 @@
-=== tests/cases/compiler/library_ArraySlice.ts ===
-// Array.prototype.slice can have zero, one, or two arguments
-Array.prototype.slice();
->Array.prototype.slice() : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
->Array.prototype : any[]
->Array : ArrayConstructor
->prototype : any[]
->slice : (start?: number, end?: number) => any[]
-
-Array.prototype.slice(0);
->Array.prototype.slice(0) : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
->Array.prototype : any[]
->Array : ArrayConstructor
->prototype : any[]
->slice : (start?: number, end?: number) => any[]
->0 : number
-
-Array.prototype.slice(0, 1);
->Array.prototype.slice(0, 1) : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
->Array.prototype : any[]
->Array : ArrayConstructor
->prototype : any[]
->slice : (start?: number, end?: number) => any[]
->0 : number
->1 : number
-
diff --git a/tests/baselines/reference/library_RegExpExecArraySlice.symbols b/tests/baselines/reference/library_RegExpExecArraySlice.symbols
index d1ad57ff1d566..374b15723b34f 100644
--- a/tests/baselines/reference/library_RegExpExecArraySlice.symbols
+++ b/tests/baselines/reference/library_RegExpExecArraySlice.symbols
@@ -5,17 +5,17 @@ var regExpExecArrayValue: RegExpExecArray;
 >RegExpExecArray : Symbol(RegExpExecArray, Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice();
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice(0);
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice(0,1);
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/library_RegExpExecArraySlice.types b/tests/baselines/reference/library_RegExpExecArraySlice.types
index b4673adb98835..2feab5fe9db56 100644
--- a/tests/baselines/reference/library_RegExpExecArraySlice.types
+++ b/tests/baselines/reference/library_RegExpExecArraySlice.types
@@ -5,23 +5,23 @@ var regExpExecArrayValue: RegExpExecArray;
 >RegExpExecArray : RegExpExecArray
 
 regExpExecArrayValue.slice();
->regExpExecArrayValue.slice() : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice() : RegExpExecArray
+>regExpExecArrayValue.slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 
 regExpExecArrayValue.slice(0);
 >regExpExecArrayValue.slice(0) : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 >0 : number
 
 regExpExecArrayValue.slice(0,1);
 >regExpExecArrayValue.slice(0,1) : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : { (): RegExpExecArray; (start?: number, end?: number): string[]; }
 >0 : number
 >1 : number
 
diff --git a/tests/baselines/reference/thisTypeInTuples.symbols b/tests/baselines/reference/thisTypeInTuples.symbols
index 256f182dd694d..bf5fcfceeee06 100644
--- a/tests/baselines/reference/thisTypeInTuples.symbols
+++ b/tests/baselines/reference/thisTypeInTuples.symbols
@@ -4,7 +4,7 @@ interface Array<T> {
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 16))
 
     slice(): this;
->slice : Symbol(slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 }
 
 let t: [number, string] = [42, "hello"];
@@ -12,19 +12,19 @@ let t: [number, string] = [42, "hello"];
 
 let a = t.slice();
 >a : Symbol(a, Decl(thisTypeInTuples.ts, 5, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
 let b = t.slice(1);
 >b : Symbol(b, Decl(thisTypeInTuples.ts, 6, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
 let c = t.slice(0, 1);
 >c : Symbol(c, Decl(thisTypeInTuples.ts, 7, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
diff --git a/tests/baselines/reference/thisTypeInTuples.types b/tests/baselines/reference/thisTypeInTuples.types
index e0268840317b9..39b943c7c6d96 100644
--- a/tests/baselines/reference/thisTypeInTuples.types
+++ b/tests/baselines/reference/thisTypeInTuples.types
@@ -4,7 +4,7 @@ interface Array<T> {
 >T : T
 
     slice(): this;
->slice : { (start?: number, end?: number): T[]; (): this; }
+>slice : { (): this; (start?: number, end?: number): T[]; (): this; }
 }
 
 let t: [number, string] = [42, "hello"];
@@ -16,24 +16,24 @@ let t: [number, string] = [42, "hello"];
 let a = t.slice();
 >a : [number, string]
 >t.slice() : [number, string]
->t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>t.slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 
 let b = t.slice(1);
 >b : (number | string)[]
 >t.slice(1) : (number | string)[]
->t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>t.slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 >1 : number
 
 let c = t.slice(0, 1);
 >c : (number | string)[]
 >t.slice(0, 1) : (number | string)[]
->t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>t.slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; }
+>slice : { (): [number, string]; (start?: number, end?: number): (number | string)[]; (): [number, string]; }
 >0 : number
 >1 : number
 
diff --git a/tests/cases/compiler/implementArrayInterface.ts b/tests/cases/compiler/implementArrayInterface.ts
index 1ba8b8f25240d..8a8ade57ee603 100644
--- a/tests/cases/compiler/implementArrayInterface.ts
+++ b/tests/cases/compiler/implementArrayInterface.ts
@@ -8,6 +8,7 @@ declare class MyArray<T> implements Array<T> {
     push(...items: T[]): number;
     reverse(): T[];
     shift(): T;
+    slice(): this;
     slice(start?: number, end?: number): T[];
     sort(compareFn?: (a: T, b: T) => number): T[];
     splice(start: number): T[];
diff --git a/tests/cases/compiler/library_ArraySlice.ts b/tests/cases/compiler/library_ArraySlice.ts
index e73f853f52f38..6fd4f3cddd363 100644
--- a/tests/cases/compiler/library_ArraySlice.ts
+++ b/tests/cases/compiler/library_ArraySlice.ts
@@ -1,4 +1,10 @@
 // Array.prototype.slice can have zero, one, or two arguments
 Array.prototype.slice();
 Array.prototype.slice(0);
-Array.prototype.slice(0, 1);
\ No newline at end of file
+Array.prototype.slice(0, 1);
+
+// Array.prototype.slice returns this with zero arguments, allowing tuple slicing
+let t1: [number, number] = [1, 2];
+let t2: [number, number] = t1.slice();
+let t3: [number, number] = t1.slice(0);
+let t4: [number, number] = t1.slice(0,1);