Fix functional Array & String methods and avoid buffer caching (AssemblyScript#415)

Author: MaxGraey

std/assembly/array.ts

@@ -72,17 +72,15 @@ export class Array<T> {
   }
 
   every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
-    var buffer = this.buffer_;
-    for (let index = 0, toIndex = this.length_; index < min(toIndex, this.length_); ++index) {
-      if (!callbackfn(LOAD<T>(buffer, index), index, this)) return false;
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
+      if (!callbackfn(LOAD<T>(this.buffer_, index), index, this)) return false;
     }
     return true;
   }
 
   findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
-    var buffer = this.buffer_;
-    for (let index = 0, toIndex = this.length_; index < min(toIndex, this.length_); ++index) {
-      if (predicate(LOAD<T>(buffer, index), index, this)) return index;
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
+      if (predicate(LOAD<T>(this.buffer_, index), index, this)) return index;
     }
     return -1;
   }
@@ -193,7 +191,7 @@ export class Array<T> {
 
   concat(items: Array<T>): Array<T> {
     var thisLen = this.length_;
-    var otherLen = items === null ? 0 : items.length_;
+    var otherLen = select(0, items.length_, items === null);
     var outLen = thisLen + otherLen;
     var out = new Array<T>(outLen);
 
@@ -250,27 +248,25 @@ export class Array<T> {
   }
 
   forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
-    for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
       callbackfn(LOAD<T>(this.buffer_, index), index, this);
     }
   }
 
   map<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
-    var buffer = this.buffer_;
     var length = this.length_;
     var result = new Array<U>(length);
-    var resultBuffer = result.buffer_;
+    var buffer = result.buffer_;
     for (let index = 0; index < min(length, this.length_); ++index) {
-      STORE<U>(resultBuffer, index, callbackfn(LOAD<T>(buffer, index), index, this));
+      STORE<U>(buffer, index, callbackfn(LOAD<T>(this.buffer_, index), index, this));
     }
     return result;
   }
 
   filter(callbackfn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
-    var buffer = this.buffer_;
     var result = new Array<T>();
-    for (let index = 0, toIndex = this.length_; index < min(toIndex, this.length_); ++index) {
-      let value = LOAD<T>(buffer, index);
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
+      let value = LOAD<T>(this.buffer_, index);
       if (callbackfn(value, index, this)) result.push(value);
     }
     return result;
@@ -281,9 +277,8 @@ export class Array<T> {
     initialValue: U
   ): U {
     var accum = initialValue;
-    var buffer = this.buffer_;
-    for (let index = 0, toIndex = this.length_; index < min(toIndex, this.length_); ++index) {
-      accum = callbackfn(accum, LOAD<T>(buffer, index), index, this);
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
+      accum = callbackfn(accum, LOAD<T>(this.buffer_, index), index, this);
     }
     return accum;
   }
@@ -293,9 +288,8 @@ export class Array<T> {
     initialValue: U
   ): U {
     var accum = initialValue;
-    var buffer = this.buffer_;
-    for (let index: i32 = this.length_ - 1; index >= 0; --index) {
-      accum = callbackfn(accum, LOAD<T>(buffer, index), index, this);
+    for (let index = this.length_ - 1; index >= 0; --index) {
+      accum = callbackfn(accum, LOAD<T>(this.buffer_, index), index, this);
     }
     return accum;
   }
@@ -317,9 +311,8 @@ export class Array<T> {
   }
 
   some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
-    var buffer = this.buffer_;
-    for (let index = 0, toIndex = this.length_; index < min(toIndex, this.length_); ++index) {
-      if (callbackfn(LOAD<T>(buffer, index), index, this)) return true;
+    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
+      if (callbackfn(LOAD<T>(this.buffer_, index), index, this)) return true;
     }
     return false;
   }
@@ -348,20 +341,16 @@ export class Array<T> {
   }
 
   slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {
-    var length = this.length_;
-    if (begin < 0) begin = max(length + begin, 0);
-    else if (begin > length) begin = length;
-    if (end < 0) end = length + end; // no need to clamp
-    else if (end > length) end = length;
-    if (end < begin) end = begin;    // ^
-    var newLength = end - begin;
-    assert(newLength >= 0);
-    var sliced = new Array<T>(newLength);
-    if (newLength) {
+    var len = this.length_;
+    begin = begin < 0 ? max(begin + len, 0) : min(begin, len);
+    end = end < 0 ? max(end + len, 0) : min(end, len);
+    len = end - begin;
+    var sliced = new Array<T>(len);
+    if (len) {
       memory.copy(
         changetype<usize>(sliced.buffer_) + HEADER_SIZE,
         changetype<usize>(this.buffer_) + HEADER_SIZE + (<usize>begin << alignof<T>()),
-        <usize>newLength << alignof<T>()
+        <usize>len << alignof<T>()
       );
     }
     return sliced;
@@ -430,9 +419,8 @@ export class Array<T> {
     var sepLen = separator.length;
     var hasSeparator = sepLen != 0;
     if (value instanceof bool) {
-      if (!lastIndex) {
-        return select<string>("true", "false", LOAD<T,bool>(buffer, 0));
-      }
+      if (!lastIndex) return select<string>("true", "false", LOAD<T,bool>(buffer, 0));
+
       let valueLen = 5; // max possible length of element len("false")
       let estLen = (valueLen + sepLen) * lastIndex + valueLen;
       let result = allocateUnsafeString(estLen);
@@ -459,9 +447,8 @@ export class Array<T> {
       }
       return out;
     } else if (isInteger<T>()) {
-      if (!lastIndex) {
-        return changetype<string>(itoa<T>(LOAD<T>(buffer, 0)));
-      }
+      if (!lastIndex) return changetype<string>(itoa<T>(LOAD<T>(buffer, 0)));
+
       const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + <i32>isSigned<T>();
       let estLen = (valueLen + sepLen) * lastIndex + valueLen;
       let result = allocateUnsafeString(estLen);
@@ -483,9 +470,8 @@ export class Array<T> {
       }
       return out;
     } else if (isFloat<T>()) {
-      if (!lastIndex) {
-        return changetype<string>(dtoa(LOAD<T,f64>(buffer, 0)));
-      }
+      if (!lastIndex) return changetype<string>(dtoa(LOAD<T,f64>(buffer, 0)));
+
       const valueLen = MAX_DOUBLE_LENGTH;
       let estLen = (valueLen + sepLen) * lastIndex + valueLen;
       let result = allocateUnsafeString(estLen);
@@ -507,9 +493,8 @@ export class Array<T> {
       }
       return out;
     } else if (isString<T>()) {
-      if (!lastIndex) {
-        return LOAD<string>(buffer, 0);
-      }
+      if (!lastIndex) return LOAD<string>(buffer, 0);
+
       let estLen = 0;
       for (let i = 0, len = lastIndex + 1; i < len; ++i) {
         estLen += LOAD<string>(buffer, i).length;

std/assembly/string.ts

@@ -451,7 +451,9 @@ export class String {
       }
       return result;
     } else if (!length) {
-      return <String[]>[changetype<String>("")];
+      let result = new Array<String>(1);
+      unchecked(result[0] = changetype<String>(""));
+      return result;
     }
     var result = new Array<String>();
     var end = 0, start = 0, i = 0;
@@ -467,7 +469,11 @@ export class String {
       if (++i == limit) return result;
       start = end + sepLen;
     }
-    if (!start) return <String[]>[this];
+    if (!start) {
+      let result = new Array<String>(1);
+      unchecked(result[0] = this);
+      return result;
+    }
     var len = length - start;
     if (len > 0) {
       let out = allocateUnsafe(len);