Add TypedArray#fill (AssemblyScript#274)

Author: MaxGraey

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.optimized.wat

@@ -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/array.ts

@@ -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/array.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)