Add Array#fill (#250)

std/assembly/array.ts

@@ -99,6 +99,25 @@ export class Array<T> {
     if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
   }
 
+  fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {
+    var buffer = this.buffer_;
+    var len    = this.length_;
+    start = start < 0 ? max(len + start, 0) : min(start, len);
+    end   = end   < 0 ? max(len + end,   0) : min(end,   len);
+    if (sizeof<T>() == 1) {
+      memory.fill(
+        changetype<usize>(buffer) + start + HEADER_SIZE,
+        <u8>value,
+        <usize>(end - start)
+      );
+    } else {
+      for (; start < end; ++start) {
+        storeUnsafe<T,T>(buffer, start, value);
+      }
+    }
+    return this;
+  }
+
   includes(searchElement: T, fromIndex: i32 = 0): bool {
     var length = this.length_;
     if (length == 0 || fromIndex >= length) return false;

std/assembly/index.d.ts

@@ -436,6 +436,7 @@ declare class Array<T> {
   length: i32;
   /** Constructs a new array. */
   constructor(capacity?: i32);
+  fill(value: T, start?: i32, end?: i32): this;
   every(callbackfn: (element: T, index: i32, array?: Array<T>) => bool): bool;
   findIndex(predicate: (element: T, index: i32, array?: Array<T>) => bool): i32;
   includes(searchElement: T, fromIndex?: i32): bool;

std/portable/index.d.ts

@@ -247,6 +247,7 @@ declare class Array<T> {
   [key: number]: T;
   length: i32;
   constructor(capacity?: i32);
+  fill(value: T, start?: i32, end?: i32): this;
   every(callbackfn: (element: T, index: i32, array?: Array<T>) => bool): bool;
   findIndex(predicate: (element: T, index: i32, array?: Array<T>) => bool): i32;
   includes(searchElement: T, fromIndex?: i32): bool;

tests/compiler/std/array.ts

@@ -10,8 +10,54 @@ function internalCapacity<T>(array: Array<T>): i32 {
   return buffer.byteLength >> alignof<T>();
 }
 
+// Checks if two arrays are equal
+function isArraysEqual<T>(a: Array<T>, b: Array<T>, len: i32 = 0): bool {
+  if (!len) {
+    len = a.length;
+    if (len != b.length) return false;
+    if (a === b) return true;
+  }
+  for (let i = 0; i < len; i++) {
+    if (isFloat<T>()) {
+      if (isNaN(a[i]) == isNaN(b[i])) continue;
+    }
+    if (a[i] != b[i]) return false;
+  }
+  return true;
+}
+
 var arr = new Array<i32>();
 
+// Array#fill //////////////////////////////////////////////////////////////////////////////////////
+
+var arr8: u8[] = [1, 2, 3, 4, 5];
+
+arr8.fill(1, 1, 3);
+assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 1, 4, 5]));
+
+arr8.fill(0);
+assert(isArraysEqual<u8>(arr8, <u8[]>[0, 0, 0, 0, 0]));
+
+arr8.fill(1, 0, -3);
+assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 0, 0, 0]));
+
+arr8.fill(2, -2);
+assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 0, 2, 2]));
+
+var arr32: u32[] = [1, 2, 3, 4, 5];
+
+arr32.fill(1, 1, 3);
+assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 1, 4, 5]));
+
+arr32.fill(0);
+assert(isArraysEqual<u32>(arr32, <u32[]>[0, 0, 0, 0, 0]));
+
+arr32.fill(1, 0, -3);
+assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 0, 0, 0]));
+
+arr32.fill(2, -2);
+assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 0, 2, 2]));
+
 // Array#push/pop //////////////////////////////////////////////////////////////////////////////////
 
 assert(arr.length == 0);
@@ -531,21 +577,6 @@ function isSorted<T>(data: Array<T>, comparator: (a: T, b: T) => i32 = defaultCo
   return true;
 }
 
-// Checks if two arrays are equal
-function isArraysEqual<T>(a: Array<T>, b: Array<T>, len: i32 = 0): bool {
-  if (!len) {
-    if (a.length != b.length) return false;
-    len = a.length;
-  }
-  for (let i = 0; i < len; i++) {
-    if (isFloat<T>()) {
-      if (isNaN(a[i]) && isNaN(a[i]) == isNaN(b[i])) continue;
-    }
-    if (a[i] != b[i]) return false;
-  }
-  return true;
-}
-
 function createReverseOrderedArray(size: i32): Array<i32> {
   var arr = new Array<i32>(size);
   for (let i = 0; i < arr.length; i++) {