toilscript 0.0.1 → 0.1.1

package/std/assembly/fixedset.ts

@@ -1,275 +1,275 @@
-/// <reference path="./rt/index.d.ts" />
-
-import { HASH } from "./util/hash";
-import { Runtime } from "shared/runtime";
-
-// Open-addressing hash set with linear probing.
-// Single contiguous buffer, cache-friendly, zero GC overhead under runtime=memory.
-
-// @ts-ignore: decorator
-@inline const SLOT_EMPTY: u8 = 0;
-// @ts-ignore: decorator
-@inline const SLOT_OCCUPIED: u8 = 1;
-// @ts-ignore: decorator
-@inline const SLOT_DELETED: u8 = 2;
-
-// @ts-ignore: decorator
-@inline const FS_INITIAL_CAPACITY: i32 = 16;
-
-// Max load factor 75% = 3/4
-// @ts-ignore: decorator
-@inline const FS_LOAD_N: i32 = 3;
-// @ts-ignore: decorator
-@inline const FS_LOAD_D: i32 = 4;
-
-/** Structure of a FixedSet slot. */
-@unmanaged class FixedSetSlot<T> {
-  hash: u32;
-  state: u8;
-  key: T;
-}
-
-/** Computes the alignment of a slot. */
-// @ts-ignore: decorator
-@inline
-function FS_SLOT_ALIGN<T>(): usize {
-  const maxAll = sizeof<T>() > sizeof<u32>() ? sizeof<T>() : sizeof<u32>();
-  return maxAll - 1;
-}
-
-/** Computes the aligned size of a slot. */
-// @ts-ignore: decorator
-@inline
-function FS_SLOT_SIZE<T>(): usize {
-  const align = FS_SLOT_ALIGN<T>();
-  return (offsetof<FixedSetSlot<T>>() + align) & ~align;
-}
-
-@final
-export class FixedSet<T> {
-
-  private dataPtr: usize = 0;
-  private _capacity: i32 = 0;
-  private capacityMask: u32 = 0;
-  private _count: i32 = 0;
-  private _entriesUsed: i32 = 0;
-
-  constructor(initialCapacity: i32 = FS_INITIAL_CAPACITY) {
-    if (initialCapacity < 4) initialCapacity = 4;
-    let cap: i32 = 4;
-    while (cap < initialCapacity) cap <<= 1;
-
-    let bufferSize = <usize>cap * FS_SLOT_SIZE<T>();
-    let ptr: usize;
-    if (ASC_RUNTIME == Runtime.Memory) {
-      ptr = __alloc(bufferSize);
-    } else {
-      ptr = __new(bufferSize, idof<ArrayBuffer>());
-    }
-    memory.fill(ptr, 0, bufferSize);
-    this.dataPtr = ptr;
-    this._capacity = cap;
-    this.capacityMask = <u32>(cap - 1);
-    if (ASC_RUNTIME != Runtime.Memory) {
-      __link(changetype<usize>(this), ptr, false);
-    }
-  }
-
-  get size(): i32 {
-    return this._count;
-  }
-
-  @operator("[]")
-  has(key: T): bool {
-    return this.findSlot(key, HASH<T>(key)) != -1;
-  }
-
-  add(key: T): this {
-    // Check load factor before insert
-    if (this._entriesUsed * FS_LOAD_D >= this._capacity * FS_LOAD_N) {
-      this.rehash(
-        this._count * 2 > this._capacity
-          ? this._capacity << 1
-          : this._capacity
-      );
-    }
-
-    let hashCode = HASH<T>(key);
-    let mask = this.capacityMask;
-    let start = hashCode & mask;
-    let i = start;
-    let data = this.dataPtr;
-    let slotSize = FS_SLOT_SIZE<T>();
-    let firstDeleted: i32 = -1;
-
-    do {
-      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
-      let state = slot.state;
-
-      if (state == SLOT_OCCUPIED) {
-        if (slot.hash == hashCode && slot.key == key) {
-          return this; // already exists
-        }
-      } else if (state == SLOT_EMPTY) {
-        let insertIdx: u32 = firstDeleted != -1 ? <u32>firstDeleted : i;
-        let insertSlot = changetype<FixedSetSlot<T>>(data + <usize>insertIdx * slotSize);
-        insertSlot.hash = hashCode;
-        insertSlot.state = SLOT_OCCUPIED;
-        insertSlot.key = key;
-        ++this._count;
-        if (firstDeleted == -1) ++this._entriesUsed;
-        if (isManaged<T>()) {
-          if (ASC_RUNTIME != Runtime.Memory) {
-            __link(changetype<usize>(this), changetype<usize>(key), true);
-          }
-        }
-        return this;
-      } else { // DELETED
-        if (firstDeleted == -1) firstDeleted = <i32>i;
-      }
-
-      i = (i + 1) & mask;
-    } while (i != start);
-
-    // Fallback: insert at firstDeleted
-    if (firstDeleted != -1) {
-      let insertSlot = changetype<FixedSetSlot<T>>(data + <usize>firstDeleted * slotSize);
-      insertSlot.hash = hashCode;
-      insertSlot.state = SLOT_OCCUPIED;
-      insertSlot.key = key;
-      ++this._count;
-      if (isManaged<T>()) {
-        if (ASC_RUNTIME != Runtime.Memory) {
-          __link(changetype<usize>(this), changetype<usize>(key), true);
-        }
-      }
-    }
-    return this;
-  }
-
-  @operator("[]=")
-  private __set(key: T, value: bool): void {
-    if (value) this.add(key);
-    else this.delete(key);
-  }
-
-  delete(key: T): bool {
-    let idx = this.findSlot(key, HASH<T>(key));
-    if (idx == -1) return false;
-    let slot = changetype<FixedSetSlot<T>>(
-      this.dataPtr + <usize>idx * FS_SLOT_SIZE<T>()
-    );
-    slot.state = SLOT_DELETED;
-    --this._count;
-    return true;
-  }
-
-  clear(): void {
-    memory.fill(this.dataPtr, 0, <usize>this._capacity * FS_SLOT_SIZE<T>());
-    this._count = 0;
-    this._entriesUsed = 0;
-  }
-
-  values(): T[] {
-    let data = this.dataPtr;
-    let cap = this._capacity;
-    let slotSize = FS_SLOT_SIZE<T>();
-    let values = new Array<T>(this._count);
-    let length = 0;
-    for (let i = 0; i < cap; ++i) {
-      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
-      if (slot.state == SLOT_OCCUPIED) {
-        unchecked(values[length++] = slot.key);
-      }
-    }
-    values.length = length;
-    return values;
-  }
-
-  toString(): string {
-    return "[object FixedSet]";
-  }
-
-  @inline
-  private findSlot(key: T, hashCode: u32): i32 {
-    let mask = this.capacityMask;
-    let start = hashCode & mask;
-    let i = start;
-    let data = this.dataPtr;
-    let slotSize = FS_SLOT_SIZE<T>();
-    do {
-      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
-      let state = slot.state;
-      if (state == SLOT_EMPTY) return -1;
-      if (state == SLOT_OCCUPIED && slot.hash == hashCode && slot.key == key) {
-        return <i32>i;
-      }
-      i = (i + 1) & mask;
-    } while (i != start);
-    return -1;
-  }
-
-  private rehash(newCapacity: i32): void {
-    let oldData = this.dataPtr;
-    let oldCapacity = this._capacity;
-    let slotSize = FS_SLOT_SIZE<T>();
-    let newMask = <u32>(newCapacity - 1);
-    let bufferSize = <usize>newCapacity * slotSize;
-
-    let newData: usize;
-    if (ASC_RUNTIME == Runtime.Memory) {
-      newData = __alloc(bufferSize);
-    } else {
-      newData = __new(bufferSize, idof<ArrayBuffer>());
-    }
-    memory.fill(newData, 0, bufferSize);
-
-    for (let i = 0; i < oldCapacity; ++i) {
-      let oldSlot = changetype<FixedSetSlot<T>>(oldData + <usize>i * slotSize);
-      if (oldSlot.state == SLOT_OCCUPIED) {
-        let h = oldSlot.hash;
-        let j = h & newMask;
-        while (changetype<FixedSetSlot<T>>(newData + <usize>j * slotSize).state != SLOT_EMPTY) {
-          j = (j + 1) & newMask;
-        }
-        let newSlot = changetype<FixedSetSlot<T>>(newData + <usize>j * slotSize);
-        newSlot.hash = h;
-        newSlot.state = SLOT_OCCUPIED;
-        newSlot.key = oldSlot.key;
-      }
-    }
-
-    this.dataPtr = newData;
-    this._capacity = newCapacity;
-    this.capacityMask = newMask;
-    this._entriesUsed = this._count;
-
-    if (ASC_RUNTIME != Runtime.Memory) {
-      __link(changetype<usize>(this), newData, false);
-    }
-  }
-
-  // RT integration
-
-  @unsafe private __visit(cookie: u32): void {
-    if (ASC_RUNTIME != Runtime.Memory) {
-      let data = this.dataPtr;
-      if (data) {
-        if (isManaged<T>()) {
-          let cap = this._capacity;
-          let slotSize = FS_SLOT_SIZE<T>();
-          for (let i = 0; i < cap; ++i) {
-            let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
-            if (slot.state == SLOT_OCCUPIED) {
-              let val = changetype<usize>(slot.key);
-              if (isNullable<T>()) {
-                if (val) __visit(val, cookie);
-              } else __visit(val, cookie);
-            }
-          }
-        }
-        __visit(data, cookie);
-      }
-    }
-  }
-}
+/// <reference path="./rt/index.d.ts" />
+
+import { HASH } from "./util/hash";
+import { Runtime } from "shared/runtime";
+
+// Open-addressing hash set with linear probing.
+// Single contiguous buffer, cache-friendly, zero GC overhead under runtime=memory.
+
+// @ts-ignore: decorator
+@inline const SLOT_EMPTY: u8 = 0;
+// @ts-ignore: decorator
+@inline const SLOT_OCCUPIED: u8 = 1;
+// @ts-ignore: decorator
+@inline const SLOT_DELETED: u8 = 2;
+
+// @ts-ignore: decorator
+@inline const FS_INITIAL_CAPACITY: i32 = 16;
+
+// Max load factor 75% = 3/4
+// @ts-ignore: decorator
+@inline const FS_LOAD_N: i32 = 3;
+// @ts-ignore: decorator
+@inline const FS_LOAD_D: i32 = 4;
+
+/** Structure of a FixedSet slot. */
+@unmanaged class FixedSetSlot<T> {
+  hash: u32;
+  state: u8;
+  key: T;
+}
+
+/** Computes the alignment of a slot. */
+// @ts-ignore: decorator
+@inline
+function FS_SLOT_ALIGN<T>(): usize {
+  const maxAll = sizeof<T>() > sizeof<u32>() ? sizeof<T>() : sizeof<u32>();
+  return maxAll - 1;
+}
+
+/** Computes the aligned size of a slot. */
+// @ts-ignore: decorator
+@inline
+function FS_SLOT_SIZE<T>(): usize {
+  const align = FS_SLOT_ALIGN<T>();
+  return (offsetof<FixedSetSlot<T>>() + align) & ~align;
+}
+
+@final
+export class FixedSet<T> {
+
+  private dataPtr: usize = 0;
+  private _capacity: i32 = 0;
+  private capacityMask: u32 = 0;
+  private _count: i32 = 0;
+  private _entriesUsed: i32 = 0;
+
+  constructor(initialCapacity: i32 = FS_INITIAL_CAPACITY) {
+    if (initialCapacity < 4) initialCapacity = 4;
+    let cap: i32 = 4;
+    while (cap < initialCapacity) cap <<= 1;
+
+    let bufferSize = <usize>cap * FS_SLOT_SIZE<T>();
+    let ptr: usize;
+    if (ASC_RUNTIME == Runtime.Memory) {
+      ptr = __alloc(bufferSize);
+    } else {
+      ptr = __new(bufferSize, idof<ArrayBuffer>());
+    }
+    memory.fill(ptr, 0, bufferSize);
+    this.dataPtr = ptr;
+    this._capacity = cap;
+    this.capacityMask = <u32>(cap - 1);
+    if (ASC_RUNTIME != Runtime.Memory) {
+      __link(changetype<usize>(this), ptr, false);
+    }
+  }
+
+  get size(): i32 {
+    return this._count;
+  }
+
+  @operator("[]")
+  has(key: T): bool {
+    return this.findSlot(key, HASH<T>(key)) != -1;
+  }
+
+  add(key: T): this {
+    // Check load factor before insert
+    if (this._entriesUsed * FS_LOAD_D >= this._capacity * FS_LOAD_N) {
+      this.rehash(
+        this._count * 2 > this._capacity
+          ? this._capacity << 1
+          : this._capacity
+      );
+    }
+
+    let hashCode = HASH<T>(key);
+    let mask = this.capacityMask;
+    let start = hashCode & mask;
+    let i = start;
+    let data = this.dataPtr;
+    let slotSize = FS_SLOT_SIZE<T>();
+    let firstDeleted: i32 = -1;
+
+    do {
+      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
+      let state = slot.state;
+
+      if (state == SLOT_OCCUPIED) {
+        if (slot.hash == hashCode && slot.key == key) {
+          return this; // already exists
+        }
+      } else if (state == SLOT_EMPTY) {
+        let insertIdx: u32 = firstDeleted != -1 ? <u32>firstDeleted : i;
+        let insertSlot = changetype<FixedSetSlot<T>>(data + <usize>insertIdx * slotSize);
+        insertSlot.hash = hashCode;
+        insertSlot.state = SLOT_OCCUPIED;
+        insertSlot.key = key;
+        ++this._count;
+        if (firstDeleted == -1) ++this._entriesUsed;
+        if (isManaged<T>()) {
+          if (ASC_RUNTIME != Runtime.Memory) {
+            __link(changetype<usize>(this), changetype<usize>(key), true);
+          }
+        }
+        return this;
+      } else { // DELETED
+        if (firstDeleted == -1) firstDeleted = <i32>i;
+      }
+
+      i = (i + 1) & mask;
+    } while (i != start);
+
+    // Fallback: insert at firstDeleted
+    if (firstDeleted != -1) {
+      let insertSlot = changetype<FixedSetSlot<T>>(data + <usize>firstDeleted * slotSize);
+      insertSlot.hash = hashCode;
+      insertSlot.state = SLOT_OCCUPIED;
+      insertSlot.key = key;
+      ++this._count;
+      if (isManaged<T>()) {
+        if (ASC_RUNTIME != Runtime.Memory) {
+          __link(changetype<usize>(this), changetype<usize>(key), true);
+        }
+      }
+    }
+    return this;
+  }
+
+  @operator("[]=")
+  private __set(key: T, value: bool): void {
+    if (value) this.add(key);
+    else this.delete(key);
+  }
+
+  delete(key: T): bool {
+    let idx = this.findSlot(key, HASH<T>(key));
+    if (idx == -1) return false;
+    let slot = changetype<FixedSetSlot<T>>(
+      this.dataPtr + <usize>idx * FS_SLOT_SIZE<T>()
+    );
+    slot.state = SLOT_DELETED;
+    --this._count;
+    return true;
+  }
+
+  clear(): void {
+    memory.fill(this.dataPtr, 0, <usize>this._capacity * FS_SLOT_SIZE<T>());
+    this._count = 0;
+    this._entriesUsed = 0;
+  }
+
+  values(): T[] {
+    let data = this.dataPtr;
+    let cap = this._capacity;
+    let slotSize = FS_SLOT_SIZE<T>();
+    let values = new Array<T>(this._count);
+    let length = 0;
+    for (let i = 0; i < cap; ++i) {
+      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
+      if (slot.state == SLOT_OCCUPIED) {
+        unchecked(values[length++] = slot.key);
+      }
+    }
+    values.length = length;
+    return values;
+  }
+
+  toString(): string {
+    return "[object FixedSet]";
+  }
+
+  @inline
+  private findSlot(key: T, hashCode: u32): i32 {
+    let mask = this.capacityMask;
+    let start = hashCode & mask;
+    let i = start;
+    let data = this.dataPtr;
+    let slotSize = FS_SLOT_SIZE<T>();
+    do {
+      let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
+      let state = slot.state;
+      if (state == SLOT_EMPTY) return -1;
+      if (state == SLOT_OCCUPIED && slot.hash == hashCode && slot.key == key) {
+        return <i32>i;
+      }
+      i = (i + 1) & mask;
+    } while (i != start);
+    return -1;
+  }
+
+  private rehash(newCapacity: i32): void {
+    let oldData = this.dataPtr;
+    let oldCapacity = this._capacity;
+    let slotSize = FS_SLOT_SIZE<T>();
+    let newMask = <u32>(newCapacity - 1);
+    let bufferSize = <usize>newCapacity * slotSize;
+
+    let newData: usize;
+    if (ASC_RUNTIME == Runtime.Memory) {
+      newData = __alloc(bufferSize);
+    } else {
+      newData = __new(bufferSize, idof<ArrayBuffer>());
+    }
+    memory.fill(newData, 0, bufferSize);
+
+    for (let i = 0; i < oldCapacity; ++i) {
+      let oldSlot = changetype<FixedSetSlot<T>>(oldData + <usize>i * slotSize);
+      if (oldSlot.state == SLOT_OCCUPIED) {
+        let h = oldSlot.hash;
+        let j = h & newMask;
+        while (changetype<FixedSetSlot<T>>(newData + <usize>j * slotSize).state != SLOT_EMPTY) {
+          j = (j + 1) & newMask;
+        }
+        let newSlot = changetype<FixedSetSlot<T>>(newData + <usize>j * slotSize);
+        newSlot.hash = h;
+        newSlot.state = SLOT_OCCUPIED;
+        newSlot.key = oldSlot.key;
+      }
+    }
+
+    this.dataPtr = newData;
+    this._capacity = newCapacity;
+    this.capacityMask = newMask;
+    this._entriesUsed = this._count;
+
+    if (ASC_RUNTIME != Runtime.Memory) {
+      __link(changetype<usize>(this), newData, false);
+    }
+  }
+
+  // RT integration
+
+  @unsafe private __visit(cookie: u32): void {
+    if (ASC_RUNTIME != Runtime.Memory) {
+      let data = this.dataPtr;
+      if (data) {
+        if (isManaged<T>()) {
+          let cap = this._capacity;
+          let slotSize = FS_SLOT_SIZE<T>();
+          for (let i = 0; i < cap; ++i) {
+            let slot = changetype<FixedSetSlot<T>>(data + <usize>i * slotSize);
+            if (slot.state == SLOT_OCCUPIED) {
+              let val = changetype<usize>(slot.key);
+              if (isNullable<T>()) {
+                if (val) __visit(val, cookie);
+              } else __visit(val, cookie);
+            }
+          }
+        }
+        __visit(data, cookie);
+      }
+    }
+  }
+}

package/std/assembly/function.ts

@@ -1,42 +1,42 @@
-import { Runtime } from "shared/runtime";
-
-type auto = i32;
-
-@final export abstract class Function<T> {
-  private _index: u32;
-  private _env: usize;
-
-  // @ts-ignore: this on getter
-  get index(this: T): u32 {
-    return load<u32>(changetype<usize>(this), offsetof<Function<T>>("_index"));
-  }
-
-  // @ts-ignore: this on getter
-  get name(this: T): string {
-    return "";
-  }
-
-  // @ts-ignore: this on getter
-  get length(this: T): i32 {
-    // @ts-ignore: T is function
-    return lengthof<T>();
-  }
-
-  // @ts-ignore: T is function
-  @builtin call(thisArg: thisof<T> | null, ...args: auto[]): returnof<T> {
-    return unreachable();
-  }
-
-  toString(this: T): string {
-    return "function() { [native code] }";
-  }
-
-  // RT integration
-
-  @unsafe private __visit(cookie: u32): void {
-    if (ASC_RUNTIME != Runtime.Memory) {
-      // Env is either `null` (nop) or compiler-generated
-      __visit(this._env, cookie);
-    }
-  }
-}
+import { Runtime } from "shared/runtime";
+
+type auto = i32;
+
+@final export abstract class Function<T> {
+  private _index: u32;
+  private _env: usize;
+
+  // @ts-ignore: this on getter
+  get index(this: T): u32 {
+    return load<u32>(changetype<usize>(this), offsetof<Function<T>>("_index"));
+  }
+
+  // @ts-ignore: this on getter
+  get name(this: T): string {
+    return "";
+  }
+
+  // @ts-ignore: this on getter
+  get length(this: T): i32 {
+    // @ts-ignore: T is function
+    return lengthof<T>();
+  }
+
+  // @ts-ignore: T is function
+  @builtin call(thisArg: thisof<T> | null, ...args: auto[]): returnof<T> {
+    return unreachable();
+  }
+
+  toString(this: T): string {
+    return "function() { [native code] }";
+  }
+
+  // RT integration
+
+  @unsafe private __visit(cookie: u32): void {
+    if (ASC_RUNTIME != Runtime.Memory) {
+      // Env is either `null` (nop) or compiler-generated
+      __visit(this._env, cookie);
+    }
+  }
+}