warpo 3.2.0 → 3.2.2

package/assemblyscript/std/assembly/symbol.ts

@@ -0,0 +1,61 @@
+import { Map } from "./map";
+
+// @ts-ignore: decorator
+@lazy
+const stringToId: Map<string, usize> = new Map();
+
+// @ts-ignore: decorator
+@lazy
+const idToString: Map<usize, string> = new Map();
+
+// @ts-ignore: decorator
+@lazy
+const idToDesc: Map<usize, string | null> = new Map();
+
+function ensureToMap(id: i32, key: string): symbol {
+  stringToId.set(key, id);
+  idToString.set(id, key);
+  return changetype<symbol>(id);
+}
+
+
+@unmanaged @final
+// @ts-ignore: class name
+export abstract class symbol {
+  toString(): string {
+    const id = changetype<usize>(this);
+    const str: string | null = idToString.has(id) ? idToString.get(id) : idToDesc.get(id);
+    if (str == null) return "Symbol()";
+    return `Symbol(${str})`;
+  }
+}
+
+export function Symbol(description: string | null = null): symbol {
+  let id = Symbol.nextId++;
+  if (!id) unreachable(); // out of ids
+  idToDesc.set(id, description);
+  return changetype<symbol>(id);
+}
+
+export namespace Symbol {
+  // @ts-ignore: decorator
+  @lazy
+  export let nextId: usize = 2;
+
+  // @ts-ignore: decorator
+  @lazy
+  export const iterator: symbol = ensureToMap(1, "iterator");
+
+  // @ts-ignore: decorator
+  @__warpo_rename_for
+  export function __warpo_for(key: string): symbol {
+    if (stringToId.has(key)) return changetype<symbol>(stringToId.get(key));
+    let id = Symbol.nextId++;
+    if (!id) unreachable(); // out of ids
+    return ensureToMap(id, key);
+  }
+
+  export function keyFor(sym: symbol): string | null {
+    return idToString.has(changetype<usize>(sym)) ? idToString.get(changetype<usize>(sym)) : null;
+  }
+}

package/assemblyscript/std/assembly/table.ts

@@ -0,0 +1,15 @@
+import { E_NOTIMPLEMENTED } from "./util/error";
+
+export namespace table {
+  export function copy(dst: u32, src: u32, n: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  export function init(elementIndex: u32, srcOffset: u32, dstOffset: u32, n: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  export function drop(elementIndex: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+}

package/assemblyscript/std/assembly/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../types/tsconfig-std.json",
+  "include": ["./**/*.ts"]
+}

package/assemblyscript/std/assembly/tuple.ts

@@ -0,0 +1,36 @@
+/// <reference path="./rt/index.d.ts" />
+
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+
+// @ts-ignore: decorator
+@final export class SmallTuple {
+  // | element 0 | element 1 | ... | element n | bitmap (u64) |
+  // each element use 1 bit in bitmap to indicate its type:
+  // 0 = non-reference
+  // 1 = reference
+
+  private __get<T>(offset: usize): T {
+    const elementPtr = changetype<usize>(this) + offset;
+    return load<T>(elementPtr);
+  }
+
+  private __set<T>(offset: usize, value: T): void {
+    const elementPtr = changetype<usize>(this) + offset;
+    store<T>(elementPtr, value);
+    if (isReference<T>()) {
+      __link(changetype<usize>(this), changetype<usize>(value), false);
+    }
+  }
+
+  // RT integration
+  private __visit(cookie: u32): void {
+    const rtSize = <usize>changetype<OBJECT>(changetype<usize>(this) - TOTAL_OVERHEAD).rtSize;
+    let remaining = load<u64>(changetype<usize>(this) + rtSize - sizeof<u64>());
+    while (remaining != 0) {
+      const index = <usize>ctz(remaining);
+      const elementPtr = changetype<usize>(this) + (index << alignof<usize>());
+      __visit(changetype<usize>(load<usize>(elementPtr)), cookie);
+      remaining &= remaining - 1; // Equals to remaining &= ~((<u64>1) << index)
+    }
+  }
+}