Make the transition to ArrayBuffer backed Arrays (#70)

* Traverse base classes when resolving overloads
* Implement preliminary TypedArray accessors
* Extract decorator flags from common flags to make space
* Add '**' overload
* Implement basic explicit inlining
* Support inlining of instance methods
* Reduce number of required locals when inlining
* Implement inlining of operator overloads
* Fix issues when inlining generic functions

std/assembly.d.ts

@@ -298,6 +298,8 @@ declare abstract class TypedArray<T> implements ArrayBufferView<T> {
   readonly byteLength: i32;
   /** The length (in elements). */
   readonly length: i32;
+  /** Returns a new TypedArray of this type on the same ArrayBuffer from begin inclusive to end exclusive. */
+  subarray(begin?: i32, end?: i32): this;
 }
 
 /** An array of twos-complement 8-bit signed integers. */
@@ -534,5 +536,5 @@ declare function unmanaged(target: Function): any;
 /** Annotates a class as being sealed / non-derivable. */
 declare function sealed(target: Function): any;
 
-/** Annotates a class field with an explicit offset. */
-declare function offset(offset: usize): any;
+/** Annotates a method or function as always inlined. */
+declare function inline(target: any, propertyKey: any, descriptor: any): any;

std/assembly/array.ts

@@ -1,3 +1,12 @@
+import {
+  MAX_BLENGTH,
+  HEADER_SIZE as HEADER_SIZE_AB,
+  allocUnsafe,
+  reallocUnsafe,
+  loadUnsafe,
+  storeUnsafe
+} from "./internal/arraybuffer";
+
 import {
   defaultComparator,
   insertionSort,
@@ -6,147 +15,130 @@ import {
 
 export class Array<T> {
 
-  __memory: usize;
-  __capacity: i32;  // capped to [0, 0x7fffffff]
-  __length: i32;    // capped to [0, __capacity]
+  /* @internal */ buffer_: ArrayBuffer;
+  /* @internal */ length_: i32;
 
-  private __grow(newCapacity: i32): void {
-    var oldMemory = this.__memory;
-    var oldCapacity = this.__capacity;
-    assert(newCapacity > oldCapacity);
-    var newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
-    if (oldMemory) {
-      move_memory(newMemory, oldMemory, <usize>oldCapacity * sizeof<T>());
-      free_memory(oldMemory);
-    }
-    this.__memory = newMemory;
-    this.__capacity = newCapacity;
+  constructor(length: i32 = 0) {
+    const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
+    if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
+    this.buffer_ = allocUnsafe(length << alignof<T>());
+    this.length_ = length;
   }
 
-  constructor(capacity: i32 = 0) {
-    if (capacity < 0) throw new RangeError("Invalid array length");
-    this.__memory = capacity
-      ? allocate_memory(<usize>capacity * sizeof<T>())
-      : 0;
-    this.__capacity = capacity;
-    this.__length = capacity;
+  get length(): i32 {
+    return this.length_;
+  }
+
+  set length(length: i32) {
+    var buffer = this.buffer_;
+    var capacity = buffer.byteLength >>> alignof<T>();
+    if (<u32>length > <u32>capacity) {
+      const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
+      if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
+      buffer = reallocUnsafe(buffer, length << alignof<T>());
+      this.buffer_ = buffer;
+    }
+    this.length_ = length;
   }
 
   every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
-    var toIndex: i32 = this.__length;
-    var i: i32 = 0;
-    while (i < toIndex && i < this.__length) {
-      if (!callbackfn(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) {
-        return false;
-      }
-      i += 1;
+    var buffer = this.buffer_;
+    for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
+      if (!callbackfn(loadUnsafe<T>(buffer, index), index, this)) return false;
     }
     return true;
   }
 
   findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
-    var toIndex: i32 = this.__length;
-    var i: i32 = 0;
-    while (i < toIndex && i < this.__length) {
-      if (predicate(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) {
-        return i;
-      }
-      i += 1;
+    var buffer = this.buffer_;
+    for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
+      if (predicate(loadUnsafe<T>(buffer, index), index, this)) return index;
     }
     return -1;
   }
 
-  get length(): i32 {
-    return this.__length;
-  }
-
-  set length(length: i32) {
-    if (length < 0) throw new RangeError("Invalid array length");
-    if (length > this.__capacity) this.__grow(max(length, this.__capacity << 1));
-    this.__length = length;
-  }
-
   @operator("[]")
   private __get(index: i32): T {
-    if (<u32>index >= <u32>this.__capacity) throw new Error("Index out of bounds");
-    return load<T>(this.__memory + <usize>index * sizeof<T>());
+    var buffer = this.buffer_;
+    var capacity = buffer.byteLength >>> alignof<T>();
+    if (<u32>index >= <u32>capacity) throw new Error("Index out of bounds");
+    // return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE_AB);
+    return loadUnsafe<T>(buffer, index);
   }
 
   @operator("[]=")
   private __set(index: i32, value: T): void {
-    if (index < 0) throw new Error("Index out of bounds");
-    var capacity = this.__capacity;
-    if (index >= capacity) this.__grow(max(index + 1, capacity << 1));
-    store<T>(this.__memory + <usize>index * sizeof<T>(), value);
+    var buffer = this.buffer_;
+    var capacity = buffer.byteLength >>> alignof<T>();
+    if (<u32>index >= <u32>capacity) {
+      const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
+      if (<u32>index >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
+      buffer = reallocUnsafe(buffer, (index + 1) << alignof<T>());
+      this.buffer_ = buffer;
+      this.length_ = index + 1;
+    }
+    // store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE_AB);
+    storeUnsafe<T>(buffer, index, value);
   }
 
   includes(searchElement: T, fromIndex: i32 = 0): bool {
-    var length = this.__length;
+    var length = this.length_;
     if (length == 0 || fromIndex >= length) return false;
-    if (fromIndex < 0) {
-      fromIndex = length + fromIndex;
-      if (fromIndex < 0) {
-        fromIndex = 0;
-      }
-    }
+    if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
+    var buffer = this.buffer_;
     while (fromIndex < length) {
-      if (load<T>(this.__memory + <usize>fromIndex * sizeof<T>()) == searchElement) return true;
+      if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return true;
       ++fromIndex;
     }
     return false;
   }
 
   indexOf(searchElement: T, fromIndex: i32 = 0): i32 {
-    var length = this.__length;
-    if (length == 0 || fromIndex >= length) {
-      return -1;
-    }
-    if (fromIndex < 0) {
-      fromIndex = length + fromIndex;
-      if (fromIndex < 0) {
-        fromIndex = 0;
-      }
-    }
-    var memory = this.__memory;
+    var length = this.length_;
+    if (length == 0 || fromIndex >= length) return -1;
+    if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
+    var buffer = this.buffer_;
     while (fromIndex < length) {
-      if (load<T>(memory + <usize>fromIndex * sizeof<T>()) == searchElement) return fromIndex;
+      if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
       ++fromIndex;
     }
     return -1;
   }
 
-  lastIndexOf(searchElement: T, fromIndex: i32 = this.__length): i32 {
-    var length = this.__length;
+  lastIndexOf(searchElement: T, fromIndex: i32 = this.length_): i32 {
+    var length = this.length_;
     if (length == 0) return -1;
-    if (fromIndex < 0) {
-      fromIndex = length + fromIndex;
-    } else if (fromIndex >= length) {
-      fromIndex = length - 1;
-    }
-    var memory = this.__memory;
-    while (fromIndex >= 0) {
-      if (load<T>(memory + <usize>fromIndex * sizeof<T>()) == searchElement) return fromIndex;
+    if (fromIndex < 0) fromIndex = length + fromIndex; // no need to clamp
+    else if (fromIndex >= length) fromIndex = length - 1;
+    var buffer = this.buffer_;
+    while (fromIndex >= 0) {                           // ^
+      if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
       --fromIndex;
     }
     return -1;
   }
 
   push(element: T): i32 {
-    var capacity = this.__capacity;
-    var length = this.__length;
-    if (length == capacity) {
-      this.__grow(capacity ? capacity << 1 : 1);
+    var length = this.length_;
+    var buffer = this.buffer_;
+    var capacity = buffer.byteLength >>> alignof<T>();
+    var newLength = length + 1; // safe only if length is checked
+    if (<u32>length >= <u32>capacity) {
+      const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
+      if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
+      buffer = reallocUnsafe(buffer, newLength << alignof<T>());
+      this.buffer_ = buffer;
     }
-    store<T>(this.__memory + <usize>length * sizeof<T>(), element);
-    this.__length = ++length;
-    return length;
+    this.length_ = newLength;
+    storeUnsafe<T>(buffer, length, element);
+    return newLength;
   }
 
   pop(): T {
-    var length = this.__length;
+    var length = this.length_;
     if (length < 1) throw new RangeError("Array is empty");
-    var element = load<T>(this.__memory + <usize>--length * sizeof<T>());
-    this.__length = length;
+    var element = loadUnsafe<T>(this.buffer_, --length);
+    this.length_ = length;
     return element;
   }
 
@@ -154,158 +146,119 @@ export class Array<T> {
     callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
     initialValue: U
   ): U {
-    var accumulator: U = initialValue;
-    var toIndex: i32 = this.__length;
-    var i: i32 = 0;
-    while (i < toIndex && i < /* might change */ this.__length) {
-      accumulator = callbackfn(accumulator, load<T>(this.__memory + <usize>i * sizeof<T>()), i, this);
-      i += 1;
+    var accum = initialValue;
+    var buffer = this.buffer_;
+    for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
+      accum = callbackfn(accum, loadUnsafe<T>(buffer, index), index, this);
     }
-    return accumulator;
+    return accum;
   }
 
   shift(): T {
-    var length = this.__length;
+    var length = this.length_;
     if (length < 1) throw new RangeError("Array is empty");
-    var memory = this.__memory;
-    var capacity = this.__capacity;
-    var element = load<T>(memory);
+    var buffer = this.buffer_;
+    var element = loadUnsafe<T>(buffer, 0);
+    var lastIndex = length - 1;
     move_memory(
-      memory,
-      memory + sizeof<T>(),
-      <usize>(capacity - 1) * sizeof<T>()
+      changetype<usize>(buffer) + HEADER_SIZE_AB,
+      changetype<usize>(buffer) + HEADER_SIZE_AB + sizeof<T>(),
+      <usize>lastIndex << alignof<T>()
     );
-    set_memory(
-      memory + <usize>(capacity - 1) * sizeof<T>(),
-      0,
-      sizeof<T>()
-    );
-    this.__length = length - 1;
+    storeUnsafe<T>(buffer, lastIndex, isReference<T>() ? null : <T>0);
+    this.length_ = lastIndex;
     return element;
   }
 
   some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
-    var toIndex: i32 = this.__length;
-    var i: i32 = 0;
-    while (i < toIndex && i < /* might change */ this.__length) {
-      if (callbackfn(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) return true;
-      i += 1;
+    var buffer = this.buffer_;
+    for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
+      if (callbackfn(loadUnsafe<T>(buffer, index), index, this)) return true;
     }
     return false;
   }
 
   unshift(element: T): i32 {
-    var memory = this.__memory;
-    var capacity = this.__capacity;
-    var length = this.__length;
-    if (this.__length == capacity) {
-      // inlined __grow (avoids moving twice)
-      let newCapacity: i32 = capacity ? capacity << 1 : 1;
-      assert(newCapacity > capacity);
-      let newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
-      if (memory) {
-        move_memory(
-          newMemory + sizeof<T>(),
-          memory,
-          <usize>capacity * sizeof<T>()
-        );
-        free_memory(memory);
-      }
-      this.__memory = newMemory;
-      this.__capacity = newCapacity;
-      memory = newMemory;
-    } else {
-      move_memory(
-        memory + sizeof<T>(),
-        memory,
-        <usize>capacity * sizeof<T>()
-      );
+    var buffer = this.buffer_;
+    var capacity = buffer.byteLength >>> alignof<T>();
+    var length = this.length_;
+    var newLength = length + 1; // safe only if length is checked
+    if (<u32>length >= <u32>capacity) {
+      const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
+      if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
+      buffer = reallocUnsafe(buffer, newLength << alignof<T>());
+      capacity = buffer.byteLength >>> alignof<T>();
+      this.buffer_ = buffer;
     }
-    store<T>(memory, element);
-    this.__length = ++length;
-    return length;
+    move_memory(
+      changetype<usize>(buffer) + HEADER_SIZE_AB + sizeof<T>(),
+      changetype<usize>(buffer) + HEADER_SIZE_AB,
+      <usize>(capacity - 1) << alignof<T>()
+    );
+    storeUnsafe<T>(buffer, 0, element);
+    this.length_ = newLength;
+    return newLength;
   }
 
   slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {
-    var length = this.__length;
-    if (begin < 0) {
-      begin = length + begin;
-      if (begin < 0) {
-        begin = 0;
-      }
-    } else if (begin > length) {
-      begin = length;
-    }
-    if (end < 0) {
-      end = length + end;
-    } else if (end > length) {
-      end = length;
-    }
-    if (end < begin) {
-      end = begin;
-    }
-    var capacity = end - begin;
-    assert(capacity >= 0);
-    var sliced = new Array<T>(capacity);
-    if (capacity) {
+    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) {
       move_memory(
-        sliced.__memory,
-        this.__memory + <usize>begin * sizeof<T>(),
-        <usize>capacity * sizeof<T>()
+        changetype<usize>(sliced.buffer_) + HEADER_SIZE_AB,
+        changetype<usize>(this.buffer_) + HEADER_SIZE_AB + (<usize>begin << alignof<T>()),
+        <usize>newLength << alignof<T>()
       );
     }
     return sliced;
   }
 
   splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): void {
-    if (deleteCount < 1) {
-      return;
-    }
-    var length = this.__length;
-    if (start < 0) {
-      start = length + start;
-      if (start < 0) {
-        start = 0;
-      } else if (start >= length) {
-        return;
-      }
-    } else if (start >= length) {
-      return;
-    }
+    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 memory = this.__memory;
+    var buffer = this.buffer_;
     move_memory(
-      memory + <usize>start * sizeof<T>(),
-      memory + <usize>(start + deleteCount) * sizeof<T>(),
-      <usize>deleteCount * sizeof<T>()
+      changetype<usize>(buffer) + HEADER_SIZE_AB + (<usize>start << alignof<T>()),
+      changetype<usize>(buffer) + HEADER_SIZE_AB + (<usize>(start + deleteCount) << alignof<T>()),
+      <usize>deleteCount << alignof<T>()
     );
-    this.__length = length - deleteCount;
+    this.length_ = length - deleteCount;
   }
 
   reverse(): Array<T> {
-    var memory = this.__memory;
-    for (let front: usize = 0, back: usize = <usize>this.__length - 1; front < back; ++front, --back) {
-      let temp = load<T>(memory + front * sizeof<T>());
-      store<T>(memory + front * sizeof<T>(), load<T>(memory + back * sizeof<T>()));
-      store<T>(memory + back * sizeof<T>(), temp);
+    var buffer = this.buffer_;
+    for (let front = 0, back = this.length_ - 1; front < back; ++front, --back) {
+      let temp = loadUnsafe<T>(buffer, front);
+      storeUnsafe<T>(buffer, front, loadUnsafe<T>(buffer, back));
+      storeUnsafe<T>(buffer, back, temp);
     }
     return this;
   }
 
   sort(comparator: (a: T, b: T) => i32 = defaultComparator<T>()): Array<T> {
-    var len = this.length;
-    if (len <= 1) return this;
-    if (len == 2) {
-      let memory = this.__memory;
-      let a = load<T>(memory, sizeof<T>()); // var a = <T>arr[1];
-      let b = load<T>(memory, 0);           // var b = <T>arr[0];
+    var length = this.length_;
+    if (length <= 1) return this;
+    var buffer = this.buffer_;
+    if (length == 2) {
+      let a = loadUnsafe<T>(buffer, 1); // a = arr[1]
+      let b = loadUnsafe<T>(buffer, 0); // b = arr[0]
       if (comparator(a, b) < 0) {
-        store<T>(memory, b, sizeof<T>()); // arr[1] = b;
-        store<T>(memory, a, 0);           // arr[0] = a;
+        storeUnsafe<T>(buffer, 1, b);   // arr[1] = b;
+        storeUnsafe<T>(buffer, 0, a);   // arr[0] = a;
       }
       return this;
     }
-    return len <= 256
+    return length < 256
       ? insertionSort<T>(this, comparator)
       : weakHeapSort<T>(this, comparator);
   }

std/assembly/arraybuffer.ts

@@ -28,3 +28,12 @@ export class ArrayBuffer {
     return buffer;
   }
 }
+
+export declare interface FastArray<T> {}
+
+export declare interface ArrayBufferView<T> {
+  readonly buffer: ArrayBuffer;
+  readonly byteOffset: i32;
+  readonly byteLength: i32;
+  readonly length: i32;
+}

std/assembly/internal/array.ts

@@ -1,4 +1,11 @@
-import { Array } from "../array";
+import {
+  loadUnsafe,
+  storeUnsafe
+} from "./arraybuffer";
+
+import {
+  Array
+} from "../array";
 
 /** Obtains the default comparator for the specified type. */
 export function defaultComparator<T>(): (a: T, b: T) => i32 {
@@ -7,26 +14,23 @@ export function defaultComparator<T>(): (a: T, b: T) => i32 {
 
 /** Sorts an Array with the 'Insertion Sort' algorithm. */
 export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
-  const shiftT = alignof<T>();
-
-  var memory = arr.__memory;
-  for (let i: i32 = 0, len: i32 = arr.length; i < len; i++) {
-    let a = load<T>(memory + (i << shiftT));              // a = arr[i]
+  var buffer = arr.buffer_;
+  for (let i: i32 = 0, length: i32 = arr.length; i < length; i++) {
+    let a = loadUnsafe<T>(buffer, i);                     // a = arr[i]
     let j = i - 1;
     while (j >= 0) {
-      let b = load<T>(memory + (j << shiftT));            // b = arr[j]
+      let b = loadUnsafe<T>(buffer, j);                   // b = arr[j]
       if (comparator(a, b) < 0) {
-        store<T>(memory + ((j-- + 1) << shiftT), b);      // arr[j + 1] = b
+        storeUnsafe<T>(buffer, j-- + 1, b);               // arr[j + 1] = b
       } else break;
     }
-    store<T>(memory + ((j + 1) << shiftT), a);            // arr[j + 1] = a
+    storeUnsafe<T>(buffer, j + 1, a);                     // arr[j + 1] = a
   }
   return arr;
 }
 
 /** Sorts an Array with the 'Weak Heap Sort' algorithm. */
 export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
-  const shiftT  = alignof<T>();
   const shift32 = alignof<i32>();
 
   var length = arr.length;
@@ -36,43 +40,43 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
 
   // see: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.1863&rep=rep1&type=pdf
 
-  var memory = arr.__memory;
+  var buffer = arr.buffer_;
   for (let i = length - 1; i > 0; i--) {
     let j = i;
     while ((j & 1) == (load<i32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
 
     let p = j >> 1;
-    let a = load<T>(memory + (p << shiftT));              // a = arr[p]
-    let b = load<T>(memory + (i << shiftT));              // b = arr[i]
+    let a = loadUnsafe<T>(buffer, p);                     // a = arr[p]
+    let b = loadUnsafe<T>(buffer, i);                     // b = arr[i]
     if (comparator(a, b) < 0) {
       store<i32>(
         bitset + (i >> 5 << shift32),
         load<i32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
       );
-      store<T>(memory + (i << shiftT), a);                // arr[i] = a
-      store<T>(memory + (p << shiftT), b);                // arr[p] = b
+      storeUnsafe<T>(buffer, i, a);                       // arr[i] = a
+      storeUnsafe<T>(buffer, p, b);                       // arr[p] = b
     }
   }
 
   for (let i = length - 1; i >= 2; i--) {
-    let a = load<T>(memory, 0);                           // a = arr[0]
-    store<T>(memory, load<T>(memory + (i << shiftT)), 0); // arr[0] = arr[1]
-    store<T>(memory + (i << shiftT), a);                  // arr[1] = a
+    let a = loadUnsafe<T>(buffer, 0);                     // a = arr[0]
+    storeUnsafe<T>(buffer, 0, loadUnsafe<T>(buffer, i));  // arr[0] = arr[i]
+    storeUnsafe<T>(buffer, i, a);                         // arr[i] = a
 
     let x = 1, y: i32;
     while ((y = (x << 1) + ((load<i32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
 
     while (x > 0) {
-      a = load<T>(memory, 0);                             // a = arr[0]
-      let b = load<T>(memory + (x << shiftT));            // b = arr[x]
+      a = loadUnsafe<T>(buffer, 0);                       // a = arr[0]
+      let b = loadUnsafe<T>(buffer, x);                   // b = arr[x]
 
       if (comparator(a, b) < 0) {
         store<i32>(
           bitset + (x >> 5 << shift32),
           load<i32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
         );
-        store<T>(memory + (x << shiftT), a);              // arr[x] = a
-        store<T>(memory, b, 0);                           // arr[0] = b
+        storeUnsafe<T>(buffer, x, a);                     // arr[x] = a
+        storeUnsafe<T>(buffer, 0, b);                     // arr[0] = b
       }
       x >>= 1;
     }
@@ -80,8 +84,8 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
 
   free_memory(bitset);
 
-  var t = load<T>(memory, sizeof<T>());                   // t = arr[1]
-  store<T>(memory, load<T>(memory, 0), sizeof<T>());      // arr[1] = arr[0]
-  store<T>(memory, t, 0);                                 // arr[0] = t
+  var t = loadUnsafe<T>(buffer, 1);                       // t = arr[1]
+  storeUnsafe<T>(buffer, 1, loadUnsafe<T>(buffer, 0));    // arr[1] = arr[0]
+  storeUnsafe<T>(buffer, 0, t);                           // arr[0] = t
   return arr;
 }

std/assembly/internal/arraybuffer.ts

@@ -30,11 +30,10 @@ export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuf
   var oldByteLength = buffer.byteLength;
   if (newByteLength > oldByteLength) {
     assert(newByteLength <= MAX_BLENGTH);
-    let oldSize = computeSize(oldByteLength);
-    if (<i32>(oldSize - HEADER_SIZE) <= newByteLength) { // fast path: zero out additional space
+    if (newByteLength <= <i32>(computeSize(oldByteLength) - HEADER_SIZE)) { // fast path: zero out additional space
       store<i32>(changetype<usize>(buffer), newByteLength, offsetof<ArrayBuffer>("byteLength"));
       set_memory(
-        changetype<usize>(buffer) + HEADER_SIZE + oldByteLength,
+        changetype<usize>(buffer) + HEADER_SIZE + <usize>oldByteLength,
         0,
         <usize>(newByteLength - oldByteLength)
       );
@@ -43,7 +42,12 @@ export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuf
       move_memory(
         changetype<usize>(newBuffer) + HEADER_SIZE,
         changetype<usize>(buffer) + HEADER_SIZE,
-        <usize>newByteLength
+        <usize>oldByteLength
+      );
+      set_memory(
+        changetype<usize>(newBuffer) + HEADER_SIZE + <usize>oldByteLength,
+        0,
+        <usize>(newByteLength - oldByteLength)
       );
       return newBuffer;
     }
@@ -55,10 +59,22 @@ export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuf
   return buffer;
 }
 
-/** Common typed array interface. Not a global object. */
-// export declare interface ArrayBufferView<T> {
-//   readonly buffer: ArrayBuffer;
-//   readonly byteOffset: i32;
-//   readonly byteLength: i32;
-//   readonly length: i32;
-// }
+@inline
+export function loadUnsafe<T>(buffer: ArrayBuffer, index: i32): T {
+  return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE);
+}
+
+@inline
+export function storeUnsafe<T>(buffer: ArrayBuffer, index: i32, value: T): void {
+  store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE);
+}
+
+@inline
+export function loadUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, byteOffset: i32): T {
+  return load<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), HEADER_SIZE);
+}
+
+@inline
+export function storeUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, value: T, byteOffset: i32): void {
+  store<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), value, HEADER_SIZE);
+}

std/assembly/internal/typedarray.ts

@@ -1,12 +1,17 @@
 import {
-  HEADER_SIZE,
+  HEADER_SIZE as HEADER_SIZE_AB,
   MAX_BLENGTH,
-  allocUnsafe
-  // ArrayBufferView
+  allocUnsafe,
+  loadUnsafeWithOffset,
+  storeUnsafeWithOffset
 } from "./arraybuffer";
 
+import {
+  ArrayBufferView
+} from "../arraybuffer";
+
 /** Typed array base class. Not a global object. */
-export abstract class TypedArray<T> /* implements ArrayBufferView<T> */ {
+export abstract class TypedArray<T> implements ArrayBufferView<T> {
 
   readonly buffer: ArrayBuffer;
   readonly byteOffset: i32;
@@ -17,21 +22,45 @@ export abstract class TypedArray<T> /* implements ArrayBufferView<T> */ {
     if (<u32>length > MAX_LENGTH) throw new RangeError("Invalid typed array length");
     var byteLength = length << alignof<T>();
     var buffer = allocUnsafe(byteLength);
-    set_memory(changetype<usize>(buffer) + HEADER_SIZE, 0, <usize>byteLength);
+    set_memory(changetype<usize>(buffer) + HEADER_SIZE_AB, 0, <usize>byteLength);
     this.buffer = buffer;
     this.byteOffset = 0;
     this.byteLength = byteLength;
   }
 
   get length(): i32 {
-    return this.byteLength >> alignof<T>();
+    return (this.byteLength - this.byteOffset) >> alignof<T>();
   }
 
-  // @operator("[]") - maybe injected through ArrayBufferView?
+  @operator("[]")
+  private __get(index: i32): T {
+    var byteOffset = this.byteOffset;
+    var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
+    if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
+    return loadUnsafeWithOffset<T>(this.buffer, index, byteOffset);
+  }
 
-  // @operator("[]=") - maybe injected through ArrayBufferView?
+  @operator("[]=")
+  private __set(index: i32, value: T): void {
+    var byteOffset = this.byteOffset;
+    var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
+    if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
+    storeUnsafeWithOffset<T>(this.buffer, index, value, byteOffset);
+  }
 
-  // copyWithin(target: i32, start: i32, end: i32 = 0x7fffffff): TypedArray<T>
+  // copyWithin(target: i32, start: i32, end: i32 = this.length): this
 
-  // subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T>
+  @inline
+  subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T> {
+    var length = this.length;
+    if (begin < 0) begin = max(length + begin, 0);
+    else begin = min(begin, length);
+    if (end < 0) end = max(length + end, begin);
+    else end = max(min(end, length), begin);
+    var slice = allocate_memory(offsetof<this>());
+    store<usize>(slice, this.buffer, offsetof<this>("buffer"));
+    store<i32>(slice, begin << alignof<T>(), offsetof<this>("byteOffset"));
+    store<i32>(slice, end << alignof<T>(), offsetof<this>("byteLength"));
+    return changetype<this>(slice);
+  }
 }

std/assembly/typedarray.ts

@@ -4,40 +4,80 @@ import {
 
 export class Int8Array extends TypedArray<i8> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<i8>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Int8Array {
+    return changetype<Int8Array>(super.subarray(begin, end));
+  }
 }
 
 export class Uint8Array extends TypedArray<u8> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Uint8Array {
+    return changetype<Uint8Array>(super.subarray(begin, end));
+  }
 }
 
 export class Int16Array extends TypedArray<i16> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<i16>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Int16Array {
+    return changetype<Int16Array>(super.subarray(begin, end));
+  }
 }
 
 export class Uint16Array extends TypedArray<u16> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<u16>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Uint16Array {
+    return changetype<Uint16Array>(super.subarray(begin, end));
+  }
 }
 
 export class Int32Array extends TypedArray<i32> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<i32>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Int32Array {
+    return changetype<Int32Array>(super.subarray(begin, end));
+  }
 }
 
 export class Uint32Array extends TypedArray<u32> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<u32>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Uint32Array {
+    return changetype<Uint32Array>(super.subarray(begin, end));
+  }
 }
 
 export class Int64Array extends TypedArray<i64> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<i64>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Int64Array {
+    return changetype<Int64Array>(super.subarray(begin, end));
+  }
 }
 
 export class Uint64Array extends TypedArray<u64> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<u64>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Uint64Array {
+    return changetype<Uint64Array>(super.subarray(begin, end));
+  }
 }
 
 export class Float32Array extends TypedArray<f32> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<f32>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Float32Array {
+    return changetype<Float32Array>(super.subarray(begin, end));
+  }
 }
 
 export class Float64Array extends TypedArray<f64> {
   static readonly BYTES_PER_ELEMENT: usize = sizeof<f64>();
+
+  subarray(begin: i32 = 0, end: i32 = this.length): Float64Array {
+    return changetype<Float64Array>(super.subarray(begin, end));
+  }
 }