Add TypedArray#fill (#274)

std/assembly/array.ts

@@ -119,11 +119,13 @@ export class Array<T> {
     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)
-      );
+      if (start < end) {
+        memory.fill(
+          changetype<usize>(buffer) + start + HEADER_SIZE,
+          <u8>value,
+          <usize>(end - start)
+        );
+      }
     } else {
       for (; start < end; ++start) {
         storeUnsafe<T,T>(buffer, start, value);

std/assembly/internal/typedarray.ts

@@ -63,8 +63,30 @@ export abstract class TypedArray<T,V> {
 
   // copyWithin(target: i32, start: i32, end: i32 = this.length): this
 
+  fill(value: V, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {
+    var buffer = this.buffer;
+    var byteOffset = this.byteOffset;
+    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) {
+      if (start < end) {
+        memory.fill(
+          changetype<usize>(buffer) + start + byteOffset + AB_HEADER_SIZE,
+          <u8>value,
+          <usize>(end - start)
+        );
+      }
+    } else {
+      for (; start < end; ++start) {
+        storeUnsafeWithOffset<T,V>(buffer, start, value, byteOffset);
+      }
+    }
+    return this;
+  }
+
   @inline
-  subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T,V> {
+  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): TypedArray<T,V> {
     var length = this.length;
     if (begin < 0) begin = max(length + begin, 0);
     else begin = min(begin, length);

tests/compiler/std/array.ts

@@ -44,6 +44,9 @@ assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 0, 0, 0]));
 arr8.fill(2, -2);
 assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 0, 2, 2]));
 
+arr8.fill(0, 1, 0);
+assert(isArraysEqual<u8>(arr8, <u8[]>[1, 1, 0, 2, 2]));
+
 var arr32: u32[] = [1, 2, 3, 4, 5];
 
 arr32.fill(1, 1, 3);
@@ -58,6 +61,9 @@ assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 0, 0, 0]));
 arr32.fill(2, -2);
 assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 0, 2, 2]));
 
+arr32.fill(0, 1, 0);
+assert(isArraysEqual<u32>(arr32, <u32[]>[1, 1, 0, 2, 2]));
+
 // Array#push/pop //////////////////////////////////////////////////////////////////////////////////
 
 assert(arr.length == 0);

tests/compiler/std/string.optimized.wat

@@ -4905,7 +4905,7 @@
       (call $~lib/env/abort
        (i32.const 0)
        (i32.const 776)
-       (i32.const 172)
+       (i32.const 174)
        (i32.const 42)
       )
       (unreachable)

tests/compiler/std/string.untouched.wat

@@ -5893,7 +5893,7 @@
       (call $~lib/env/abort
        (i32.const 0)
        (i32.const 776)
-       (i32.const 172)
+       (i32.const 174)
        (i32.const 42)
       )
       (unreachable)

tests/compiler/std/typedarray.ts

@@ -10,6 +10,23 @@ assert(Uint64Array.BYTES_PER_ELEMENT == 8);
 assert(Float32Array.BYTES_PER_ELEMENT == 4);
 assert(Float64Array.BYTES_PER_ELEMENT == 8);
 
+
+function isInt8ArrayEqual(a: Int8Array, b: Array<i8>): bool {
+  if (a.length != b.length) return false;
+  for (let i = 0, len = a.length; i < len; i++) {
+    if (a[i] != b[i]) return false;
+  }
+  return true;
+}
+
+function isInt32ArrayEqual(a: Int32Array, b: Array<i32>): bool {
+  if (a.length != b.length) return false;
+  for (let i = 0, len = a.length; i < len; i++) {
+    if (a[i] != b[i]) return false;
+  }
+  return true;
+}
+
 import "allocator/arena";
 
 function testInstantiate(len: i32): void {
@@ -115,6 +132,62 @@ assert(clampedArr[0] == 0);
 assert(clampedArr[1] == 2);
 assert(clampedArr[2] == 255);
 
+var arr8 = new Int8Array(5);
+arr8[0] = 1;
+arr8[1] = 2;
+arr8[2] = 3;
+arr8[3] = 4;
+arr8[4] = 5;
+
+arr8.fill(1, 1, 3);
+assert(isInt8ArrayEqual(arr8, <i8[]>[1, 1, 1, 4, 5]));
+
+arr8.fill(0);
+assert(isInt8ArrayEqual(arr8, <i8[]>[0, 0, 0, 0, 0]));
+
+arr8.fill(1, 0, -3);
+assert(isInt8ArrayEqual(arr8, <i8[]>[1, 1, 0, 0, 0]));
+
+arr8.fill(2, -2);
+assert(isInt8ArrayEqual(arr8, <i8[]>[1, 1, 0, 2, 2]));
+
+arr8.fill(0, 1, 0);
+assert(isInt8ArrayEqual(arr8, <i8[]>[1, 1, 0, 2, 2]));
+
+var sub8 = arr8.subarray(1, 4);
+sub8.fill(0);
+assert(sub8.length == 3);
+assert(isInt8ArrayEqual(sub8, <i8[]>[0, 0, 0]));
+assert(isInt8ArrayEqual(arr8, <i8[]>[1, 0, 0, 0, 2]));
+
+var arr32 = new Int32Array(5);
+arr32[0] = 1;
+arr32[1] = 2;
+arr32[2] = 3;
+arr32[3] = 4;
+arr32[4] = 5;
+
+arr32.fill(1, 1, 3);
+assert(isInt32ArrayEqual(arr32, <i32[]>[1, 1, 1, 4, 5]));
+
+arr32.fill(0);
+assert(isInt32ArrayEqual(arr32, <i32[]>[0, 0, 0, 0, 0]));
+
+arr32.fill(1, 0, -3);
+assert(isInt32ArrayEqual(arr32, <i32[]>[1, 1, 0, 0, 0]));
+
+arr32.fill(2, -2);
+assert(isInt32ArrayEqual(arr32, <i32[]>[1, 1, 0, 2, 2]));
+
+arr32.fill(0, 1, 0);
+assert(isInt32ArrayEqual(arr32, <i32[]>[1, 1, 0, 2, 2]));
+
+var sub32 = arr32.subarray(1, 4);
+sub32.fill(0);
+assert(sub32.length == 3);
+assert(isInt32ArrayEqual(sub32, <i32[]>[0, 0, 0]));
+assert(isInt32ArrayEqual(arr32, <i32[]>[1, 0, 0, 0, 2]));
+
 import { MAX_BLENGTH } from "internal/arraybuffer";
 
 const MAX_F64LENGTH = <u32>MAX_BLENGTH >> alignof<f64>();