Revisit old draft implementation of Array#splice

std/assembly/array.ts

@@ -369,19 +369,28 @@ export class Array<T> {
     return sliced;
   }
 
-  splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): void {
-    if (deleteCount < 1) return;
-    var length = this.length_;
-    if (start < 0) start = max(length + start, 0);
-    if (start >= length) return;
-    deleteCount = min(deleteCount, length - start);
-    var buffer = this.buffer_;
+  splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array<T> {
+    var length  = this.length_;
+    start       = start < 0 ? max<i32>(length + start, 0) : min<i32>(start, length);
+    deleteCount = max<i32>(min<i32>(deleteCount, length - start), 0);
+    var buffer  = this.buffer_;
+    var spliced = new Array<T>(deleteCount);
+    var source  = changetype<usize>(buffer) + HEADER_SIZE + (<usize>start << alignof<T>());
     memory.copy(
-      changetype<usize>(buffer) + HEADER_SIZE + (<usize>start << alignof<T>()),
-      changetype<usize>(buffer) + HEADER_SIZE + (<usize>(start + deleteCount) << alignof<T>()),
+      changetype<usize>(spliced.buffer_) + HEADER_SIZE,
+      source,
       <usize>deleteCount << alignof<T>()
     );
+    var offset = start + deleteCount;
+    if (length != offset) {
+      memory.copy(
+        source,
+        changetype<usize>(buffer) + HEADER_SIZE + (<usize>offset << alignof<T>()),
+        <usize>(length - offset) << alignof<T>()
+      );
+    }
     this.length_ = length - deleteCount;
+    return spliced;
   }
 
   reverse(): Array<T> {

std/assembly/index.d.ts

@@ -570,8 +570,8 @@ declare class Array<T> {
   shift(): T;
   some(callbackfn: (element: T, index: i32, array?: Array<T>) => bool): bool;
   unshift(element: T): i32;
-  slice(from: i32, to?: i32): T[];
-  splice(start: i32, deleteCount?: i32): void;
+  slice(from: i32, to?: i32): Array<T>;
+  splice(start: i32, deleteCount?: i32): Array<T>;
   sort(comparator?: (a: T, b: T) => i32): this;
   join(separator?: string): string;
   reverse(): T[];

std/assembly/internal/memory.ts

@@ -144,7 +144,7 @@ export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/s
 
 // this function will go away once `memory.copy` becomes an intrinsic
 export function memmove(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memmove.c
-  if (dest == src) return;
+  if (dest === src) return;
   if (src + n <= dest || dest + n <= src) {
     memcpy(dest, src, n);
     return;

std/portable/index.d.ts

@@ -373,8 +373,8 @@ declare class Array<T> {
   shift(): T;
   some(callbackfn: (element: T, index: i32, array?: Array<T>) => bool): bool;
   unshift(element: T): i32;
-  slice(from?: i32, to?: i32): T[];
-  splice(start: i32, deleteCount?: i32): void;
+  slice(from?: i32, to?: i32): Array<T>;
+  splice(start: i32, deleteCount?: i32): Array<T>;
   sort(comparator?: (a: T, b: T) => i32): this;
   join(separator?: string): string;
   reverse(): T[];

tests/compiler/std/array.ts

@@ -330,6 +330,60 @@ assert(internalCapacity<i32>(arr) == 5);
 assert(arr[0] == 44);
 assert(arr[1] == 42);
 
+// Array#splice ////////////////////////////////////////////////////////////////////////////////////
+
+var sarr: i32[] = [1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(0), <i32[]>[1, 2, 3, 4, 5]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(2), <i32[]>[3, 4, 5]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(2, 2), <i32[]>[3, 4]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(0, 1), <i32[]>[1]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(-1), <i32[]>[5]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(-2), <i32[]>[4, 5]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(-2, 1), <i32[]>[4]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(-7, 1), <i32[]>[1]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(-2, -1), <i32[]>[]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(1, -2), <i32[]>[]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(4, 0), <i32[]>[]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(7, 0), <i32[]>[]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4, 5]));
+
+sarr = <i32[]>[1, 2, 3, 4, 5];
+assert(isArraysEqual<i32>(sarr.splice(7, 5), <i32[]>[]));
+assert(isArraysEqual<i32>(sarr, <i32[]>[1, 2, 3, 4, 5]));
+
 // Array#findIndex /////////////////////////////////////////////////////////////////////////////////
 
 arr[0] = 0;