simplify

std/assembly/array.ts

@@ -1,4 +1,5 @@
 import { runtime, ArrayBufferView } from "./runtime";
+import { gc } from "./gc";
 import { ArrayBuffer } from "./arraybuffer";
 import { COMPARATOR, SORT } from "./util/sort";
 import { itoa, dtoa, itoa_stream, dtoa_stream, MAX_DOUBLE_LENGTH } from "./util/number";
@@ -76,7 +77,7 @@ export class Array<T> extends ArrayBufferView {
   private __set(index: i32, value: T): void {
     this.resize(index + 1);
     store<T>(this.dataStart + (<usize>index << alignof<T>()), value);
-    if (isManaged<T>()) runtime.link(changetype<usize>(value), changetype<usize>(this));
+    if (isManaged<T>()) gc.link(value, this);
     if (index >= this.length_) this.length_ = index + 1;
   }
 
@@ -141,7 +142,7 @@ export class Array<T> extends ArrayBufferView {
     this.resize(newLength);
     this.length_ = newLength;
     store<T>(this.dataStart + (<usize>(newLength - 1) << alignof<T>()), element);
-    if (isManaged<T>()) runtime.link(changetype<usize>(element), changetype<usize>(this));
+    if (isManaged<T>()) gc.link(element, this);
     return newLength;
   }
 
@@ -156,14 +157,14 @@ export class Array<T> extends ArrayBufferView {
       for (let offset: usize = 0; offset < thisSize; offset += sizeof<T>()) {
         let element = load<T>(thisStart + offset);
         store<T>(outStart + offset, element);
-        runtime.link(changetype<usize>(element), changetype<usize>(out));
+        gc.link(element, out);
       }
       let otherStart = other.dataStart;
       let otherSize = <usize>otherLen << alignof<T>();
       for (let offset: usize = 0; offset < otherSize; offset += sizeof<T>()) {
         let element = load<T>(otherStart + offset);
         store<T>(outStart + thisSize + offset, element);
-        runtime.link(changetype<usize>(element), changetype<usize>(out));
+        gc.link(element, out);
       }
     } else {
       memory.copy(outStart, this.dataStart, thisSize);
@@ -221,7 +222,7 @@ export class Array<T> extends ArrayBufferView {
       let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));
       let result = callbackfn(value, index, this);
       store<U>(outStart + (<usize>index << alignof<U>()), result);
-      if (isManaged<U>()) runtime.link(changetype<usize>(result), changetype<usize>(out));
+      if (isManaged<U>()) gc.link(result, out);
     }
     return out;
   }
@@ -293,7 +294,7 @@ export class Array<T> extends ArrayBufferView {
       <usize>(newLength - 1) << alignof<T>()
     );
     store<T>(base, element);
-    if (isManaged<T>()) runtime.link(changetype<usize>(element), changetype<usize>(this));
+    if (isManaged<T>()) gc.link(element, this);
     this.length_ = newLength;
     return newLength;
   }
@@ -310,7 +311,7 @@ export class Array<T> extends ArrayBufferView {
       let offset = <usize>i << alignof<T>();
       let element = load<T>(thisBase + offset);
       store<T>(sliceBase + offset, element);
-      if (isManaged<T>()) runtime.link(changetype<usize>(element), changetype<usize>(slice));
+      if (isManaged<T>()) gc.link(element, slice);
     }
     return slice;
   }
@@ -326,7 +327,7 @@ export class Array<T> extends ArrayBufferView {
     for (let i = 0; i < deleteCount; ++i) {
       let element = load<T>(thisBase + (<usize>i << alignof<T>()));
       store<T>(spliceStart + (<usize>i << alignof<T>()), element);
-      if (isManaged<T>()) runtime.link(changetype<usize>(element), changetype<usize>(splice));
+      if (isManaged<T>()) gc.link(element, splice);
     }
     memory.copy(
       splice.dataStart,
@@ -428,16 +429,17 @@ export class Array<T> extends ArrayBufferView {
 
     if (estLen > offset) {
       let trimmed = changetype<string>(result).substring(0, offset);
-      runtime.free(result);
+      runtime.freeUnregistered(result);
       return trimmed; // registered in .substring
     }
-    return runtime.register<string>(result);
+    return gc.register<string>(result);
   }
 
   private join_int(separator: string = ","): string {
     var lastIndex = this.length_ - 1;
     if (lastIndex < 0) return "";
     var dataStart = this.dataStart;
+    // @ts-ignore: type
     if (!lastIndex) return changetype<string>(itoa<T>(load<T>(dataStart)));
 
     var sepLen = separator.length;
@@ -448,6 +450,7 @@ export class Array<T> extends ArrayBufferView {
     var value: T;
     for (let i = 0; i < lastIndex; ++i) {
       value = load<T>(dataStart + (<usize>i << alignof<T>()));
+      // @ts-ignore: type
       offset += itoa_stream<T>(result, offset, value);
       if (sepLen) {
         memory.copy(
@@ -459,13 +462,14 @@ export class Array<T> extends ArrayBufferView {
       }
     }
     value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));
+    // @ts-ignore: type
     offset += itoa_stream<T>(result, offset, value);
     if (estLen > offset) {
       let trimmed = changetype<string>(result).substring(0, offset);
-      runtime.free(result);
+      runtime.freeUnregistered(result);
       return trimmed; // registered in .substring
     }
-    return runtime.register<string>(result);
+    return gc.register<string>(result);
   }
 
   private join_flt(separator: string = ","): string {
@@ -507,10 +511,10 @@ export class Array<T> extends ArrayBufferView {
     );
     if (estLen > offset) {
       let trimmed = changetype<string>(result).substring(0, offset);
-      runtime.free(result);
+      runtime.freeUnregistered(result);
       return trimmed; // registered in .substring
     }
-    return runtime.register<string>(result);
+    return gc.register<string>(result);
   }
 
   private join_str(separator: string = ","): string {
@@ -556,7 +560,7 @@ export class Array<T> extends ArrayBufferView {
         <usize>valueLen << 1
       );
     }
-    return runtime.register<string>(result);
+    return gc.register<string>(result);
   }
 
   private join_arr(separator: string = ","): string {
@@ -625,10 +629,10 @@ export class Array<T> extends ArrayBufferView {
     }
     if (estLen > offset) {
       let out = changetype<string>(result).substring(0, offset);
-      runtime.free(result);
+      runtime.freeUnregistered(result);
       return out; // registered in .substring
     }
-    return runtime.register<string>(result);
+    return gc.register<string>(result);
   }
 
   @inline

std/assembly/arraybuffer.ts

@@ -1,4 +1,5 @@
 import { runtime, ArrayBufferView } from "./runtime";
+import { gc } from "./gc";
 
 @sealed export class ArrayBuffer {
 
@@ -22,7 +23,9 @@ import { runtime, ArrayBufferView } from "./runtime";
 
   constructor(length: i32) {
     if (<u32>length > <u32>ArrayBufferView.MAX_BYTELENGTH) throw new RangeError("Invalid array buffer length");
-    return runtime.register<ArrayBuffer>(runtime.alloc(<usize>length));
+    var buffer = runtime.alloc(<usize>length);
+    memory.fill(changetype<usize>(buffer), 0, <usize>length);
+    return gc.register<ArrayBuffer>(buffer);
   }
 
   get byteLength(): i32 {
@@ -34,9 +37,9 @@ import { runtime, ArrayBufferView } from "./runtime";
     begin = begin < 0 ? max(length + begin, 0) : min(begin, length);
     end   = end   < 0 ? max(length + end  , 0) : min(end  , length);
     var outSize = <usize>max(end - begin, 0);
-    var out = runtime.allocRaw(outSize);
+    var out = runtime.alloc(outSize);
     memory.copy(out, changetype<usize>(this) + <usize>begin, outSize);
-    return runtime.register<ArrayBuffer>(out);
+    return gc.register<ArrayBuffer>(out);
   }
 
   toString(): string {

std/assembly/gc.ts

@@ -1,3 +1,5 @@
+import { runtime } from "./runtime";
+
 /** Garbage collector interface. */
 export namespace gc {
 
@@ -21,20 +23,23 @@ export namespace gc {
 
   /** Registers a managed object to be tracked by the garbage collector. */
   // @ts-ignore: decorator
-  @unsafe
-  export function register(ref: usize): void {
+  @unsafe @inline
+  export function register<T>(ref: usize): T {
+    runtime.unrefUnregistered(ref).classId = classId<T>();
     // @ts-ignore: stub
     if (isDefined(__gc_register)) __gc_register(ref);
-    else ERROR("missing implementation: gc.register");
+    return changetype<T>(ref);
   }
 
   /** Links a registered object with the registered object now referencing it. */
   // @ts-ignore: decorator
-  @unsafe
-  export function link(ref: usize, parentRef: usize): void {
+  @unsafe @inline
+  export function link<T, TParent>(ref: T, parentRef: TParent): void {
+    assert(changetype<usize>(ref) >= HEAP_BASE + runtime.Header.SIZE); // must be a heap object
+    var header = changetype<runtime.Header>(changetype<usize>(ref) - runtime.Header.SIZE);
+    assert(header.classId != runtime.Header.MAGIC && header.gc1 != 0 && header.gc2 != 0); // must be registered
     // @ts-ignore: stub
     if (isDefined(__gc_link)) __gc_link(ref, parentRef);
-    else ERROR("missing implementation: gc.link");
   }
 
   /** Marks an object as being reachable. */

std/assembly/map.ts

@@ -1,4 +1,4 @@
-import { runtime } from "./runtime";
+import { gc } from "./gc";
 import { HASH } from "./util/hash";
 
 // A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
@@ -124,8 +124,8 @@ export class Map<K,V> {
       let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
       entry.taggedNext = load<usize>(bucketPtrBase);
       store<usize>(bucketPtrBase, changetype<usize>(entry));
-      if (isManaged<K>()) runtime.link(changetype<usize>(key), changetype<usize>(this));
-      if (isManaged<V>()) runtime.link(changetype<usize>(value), changetype<usize>(this));
+      if (isManaged<K>()) gc.link(key, this);
+      if (isManaged<V>()) gc.link(value, this);
     }
   }
 

std/assembly/runtime.ts

@@ -48,7 +48,7 @@ export namespace runtime {
   /** Allocates a new object and returns a pointer to its payload. Does not fill. */
   // @ts-ignore: decorator
   @unsafe
-  export function allocRaw(payloadSize: u32): usize {
+  export function alloc(payloadSize: u32): usize {
     var header = changetype<Header>(memory.allocate(adjust(payloadSize)));
     header.classId = Header.MAGIC;
     header.payloadSize = payloadSize;
@@ -59,15 +59,6 @@ export namespace runtime {
     return changetype<usize>(header) + Header.SIZE;
   }
 
-  /** Allocates a new object and returns a pointer to its payload. Fills with zeroes.*/
-  // @ts-ignore: decorator
-  @unsafe
-  export function alloc(payloadSize: u32): usize {
-    var ref = allocRaw(payloadSize);
-    memory.fill(ref, 0, payloadSize);
-    return ref;
-  }
-
   /** Reallocates an object if necessary. Returns a pointer to its (moved) payload. */
   // @ts-ignore: decorator
   @unsafe
@@ -83,7 +74,7 @@ export namespace runtime {
       if (select(adjust(payloadSize), 0, ref > HEAP_BASE) < newAdjustedSize) {
         // move if the allocation isn't large enough or not a heap object
         let newHeader = changetype<Header>(memory.allocate(newAdjustedSize));
-        newHeader.classId = Header.MAGIC;
+        newHeader.classId = header.classId;
         if (gc.implemented) {
           newHeader.gc1 = 0;
           newHeader.gc2 = 0;
@@ -97,7 +88,8 @@ export namespace runtime {
           memory.free(changetype<usize>(header));
         } else if (gc.implemented) {
           // if previously registered, register again
-          gc.register(ref);
+          // @ts-ignore: stub
+          __gc_register(ref);
         }
         header = newHeader;
         ref = newRef;
@@ -113,40 +105,20 @@ export namespace runtime {
     return ref;
   }
 
-  function unref(ref: usize): Header {
+  // @ts-ignore: decorator
+  @unsafe
+  export function unrefUnregistered(ref: usize): Header {
     assert(ref >= HEAP_BASE + Header.SIZE); // must be a heap object
     var header = changetype<Header>(ref - Header.SIZE);
     assert(header.classId == Header.MAGIC); // must be unregistered
     return header;
   }
 
-  /** Frees an object. Must not have been registered with GC yet. */
-  // @ts-ignore: decorator
-  @unsafe @inline
-  export function free<T>(ref: T): void {
-    memory.free(changetype<usize>(unref(changetype<usize>(ref))));
-  }
-
-  /** Registers a managed object. Cannot be free'd anymore afterwards. */
-  // @ts-ignore: decorator
-  @unsafe @inline
-  export function register<T>(ref: usize): T {
-    if (!isReference<T>()) ERROR("reference expected");
-    // see comment in REALLOC why this is useful. also inline this because
-    // it's generic so we don't get a bunch of functions.
-    unref(ref).classId = gc.classId<T>();
-    if (gc.implemented) gc.register(ref);
-    return changetype<T>(ref);
-  }
-
-  /** Links a managed object with its managed parent. */
+  /** Frees an unregistered object that turned out to be unnecessary. */
   // @ts-ignore: decorator
   @unsafe @inline
-  export function link<T, TParent>(ref: T, parentRef: TParent): void {
-    assert(changetype<usize>(ref) >= HEAP_BASE + Header.SIZE); // must be a heap object
-    var header = changetype<Header>(changetype<usize>(ref) - Header.SIZE);
-    assert(header.classId != Header.MAGIC && header.gc1 != 0 && header.gc2 != 0); // must be registered
-    if (gc.implemented) gc.link(changetype<usize>(ref), changetype<usize>(parentRef)); // tslint:disable-line
+  export function freeUnregistered<T>(ref: T): void {
+    memory.free(changetype<usize>(unrefUnregistered(changetype<usize>(ref))));
   }
 }
 

std/assembly/set.ts

@@ -1,4 +1,4 @@
-import { runtime } from "./runtime";
+import { gc } from "./gc";
 import { HASH } from "./util/hash";
 
 // A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
@@ -70,7 +70,7 @@ export class Set<K> {
     this.buckets = new ArrayBuffer(bucketsSize);
     this.bucketsMask = INITIAL_CAPACITY - 1;
     const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<K>();
-    this.entries = new ArrayBuffer(entriesSize, true);
+    this.entries = new ArrayBuffer(entriesSize);
     this.entriesCapacity = INITIAL_CAPACITY;
     this.entriesOffset = 0;
     this.entriesCount = 0;
@@ -114,7 +114,7 @@ export class Set<K> {
       let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
       entry.taggedNext = load<usize>(bucketPtrBase);
       store<usize>(bucketPtrBase, changetype<usize>(entry));
-      if (isManaged<K>()) runtime.link(changetype<usize>(key), changetype<usize>(this)); // tslint:disable-line
+      if (isManaged<K>()) gc.link(key, this);
     }
   }
 
@@ -136,7 +136,7 @@ export class Set<K> {
     var newBucketsCapacity = <i32>(newBucketsMask + 1);
     var newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
     var newEntriesCapacity = <i32>(newBucketsCapacity * FILL_FACTOR);
-    var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K>(), true);
+    var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K>());
 
     // copy old entries to new entries
     var oldPtr = changetype<usize>(this.entries);