warpo 3.2.0 → 3.2.2

package/assemblyscript/std/assembly/promise.ts

@@ -0,0 +1,172 @@
+enum _AsPromiseState {
+  Pending,
+  Fulfilled,
+  Rejected,
+}
+
+export class _AsPromiseBase {
+  private onThen: ((value: Object | null) => void) | null = null;
+  private onCatch: ((reason: Object | null) => void) | null = null;
+  private state: _AsPromiseState = _AsPromiseState.Pending;
+  private fulfilledValue: Object | null = null;
+  private rejectedReason: Object | null = null;
+  constructor(executor: (resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => void) {
+    const handleResolve = (value: Object | null): void => {
+      if (this.state == _AsPromiseState.Pending) {
+        this.state = _AsPromiseState.Fulfilled;
+        this.fulfilledValue = value;
+        if (this.onThen) {
+          this.onThen(value);
+        }
+      }
+    };
+
+    const handleReject = (reason: Object | null): void => {
+      if (this.state == _AsPromiseState.Pending) {
+        this.state = _AsPromiseState.Rejected;
+        this.rejectedReason = reason;
+        if (this.onCatch) {
+          this.onCatch(reason);
+        }
+      }
+    };
+
+    executor(handleResolve, handleReject);
+  }
+
+  thenBase(
+    onFulfilled: ((value: Object | null) => Object | null) | null,
+    onRejected: ((reason: Object | null) => Object | null) | null = null
+  ): _AsPromiseBase {
+    return new _AsPromiseBase((resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+      this.onThen = (value: Object | null) => {
+        if (onFulfilled) {
+          const result = onFulfilled(value);
+          if (result instanceof _AsPromiseBase) {
+            (result as _AsPromiseBase).thenBase(
+              (v: Object | null): Object | null => {
+                resolve(v);
+                return null;
+              },
+              (reason: Object | null): Object | null => {
+                reject(reason);
+                return null;
+              }
+            );
+          } else {
+            //returns a value, resolve it
+            resolve(result);
+          }
+        } else {
+          resolve(value);
+        }
+      };
+
+      this.onCatch = (reason: Object | null) => {
+        if (onRejected) {
+          const result = onRejected(reason);
+          if (result instanceof _AsPromiseBase) {
+            (result as _AsPromiseBase).thenBase(
+              (v: Object | null): Object | null => {
+                resolve(v);
+                return null;
+              },
+              (newReason: Object | null): Object | null => {
+                reject(newReason);
+                return null;
+              }
+            );
+          } else {
+            resolve(result);
+          }
+        } else {
+          reject(reason);
+        }
+      };
+
+      if (this.state === _AsPromiseState.Fulfilled) {
+        this.onThen(this.fulfilledValue);
+      } else if (this.state === _AsPromiseState.Rejected) {
+        this.onCatch(this.rejectedReason);
+      }
+    });
+  }
+}
+
+export class Promise<T> extends _AsPromiseBase {
+  then<U>(
+    onFulfilled: ((value: T | null) => Object | null) | null,
+    onRejected: ((reason: Object | null) => Object | null) | null = null
+  ): Promise<U> {
+    const onFulfilledWrapper = (value: Object | null): Object | null => {
+      return onFulfilled ? onFulfilled(value as T | null) : value;
+    };
+    const p: _AsPromiseBase = super.thenBase(onFulfilledWrapper, onRejected);
+    return new Promise<U>((resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+      p.thenBase(
+        (value: Object | null): Object | null => {
+          resolve(value);
+          return null;
+        },
+        (reason: Object | null): Object | null => {
+          reject(reason);
+          return null;
+        }
+      );
+    });
+  }
+
+  catch<U>(onRejected: (reason: Object | null) => Object | null): Promise<U> {
+    return this.then<U>(null, onRejected);
+  }
+
+  static all(promiseArr: _AsPromiseBase[]): Promise<(Object | null)[]> {
+    return new Promise<(Object | null)[]>(
+      (resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+        let counter = 0;
+        const length = promiseArr.length;
+        const values: (Object | null)[] = new Array<Object | null>(length);
+        for (let i = 0; i < length; i++) {
+          const index = i;
+          promiseArr[i].thenBase((value: Object | null): Object | null => {
+            values[index] = value;
+            counter++;
+            if (counter == length) {
+              resolve(values);
+            }
+            return null;
+          });
+        }
+      }
+    );
+  }
+
+  static any(promiseArr: _AsPromiseBase[]): Promise<Object | null> {
+    let resolved = false;
+    return new Promise<Object | null>(
+      (resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+        for (let i = 0; i < promiseArr.length; i++) {
+          promiseArr[i].thenBase((value: Object | null): Object | null => {
+            if (!resolved) {
+              resolved = true;
+              resolve(value);
+            }
+            return null;
+          });
+        }
+      }
+    );
+  }
+
+  static resolve<U>(value: U | null): Promise<U> {
+    return new Promise<U>((resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+      resolve(value);
+    });
+  }
+
+  static reject<U>(reason: Object | null): Promise<U> {
+    return new Promise<U>((resolve: (value: Object | null) => void, reject: (reason: Object | null) => void) => {
+      reject(reason);
+    });
+  }
+}

package/assemblyscript/std/assembly/reference.ts

@@ -0,0 +1,48 @@
+// Canonical aliases
+export type funcref = ref_func | null;
+export type externref = ref_extern | null;
+export type anyref = ref_any | null;
+export type eqref = ref_eq | null;
+export type i31ref = ref_i31 | null;
+export type structref = ref_struct | null;
+export type arrayref = ref_array | null;
+export type stringref = ref_string | null;
+export type stringview_wtf8 = ref_stringview_wtf8 | null;
+export type stringview_wtf16 = ref_stringview_wtf16 | null;
+export type stringview_iter = ref_stringview_iter | null;
+
+
+@unmanaged
+abstract class Ref {}
+
+
+@final @unmanaged
+export abstract class RefFunc extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefExtern extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefAny extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefEq extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefI31 extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefStruct extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefArray extends Ref {}
+
+
+@final @unmanaged
+export abstract class RefString extends Ref {}

package/assemblyscript/std/assembly/regexp.ts

@@ -0,0 +1,16 @@
+export class RegExp {
+  // @binding(CALL_NEW, [ STRING, STRING], OBJECT_HANDLE)
+  constructor(pattern: string, flags: string = "") {
+    throw new Error("unreachable");
+  }
+
+  // @binding(CALL_THIS, [ STRING ], PASS_THRU)
+  test(search: string): bool {
+    throw new Error("unreachable");
+  }
+
+  // @binding(CALL_THIS, [], STRING)
+  toString(): string {
+    throw new Error("unreachable");
+  }
+}

package/assemblyscript/std/assembly/rt/common.ts

@@ -0,0 +1,79 @@
+// Alignment guarantees
+
+// @ts-ignore: decorator
+@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128
+// @ts-ignore: decorator
+@inline export const AL_SIZE: usize = 1 << (<usize>AL_BITS);
+// @ts-ignore: decorator
+@inline export const AL_MASK: usize = AL_SIZE - 1;
+
+// Extra debugging
+
+// @ts-ignore: decorator
+@inline export const DEBUG = true;
+// @ts-ignore: decorator
+@inline export const TRACE = false;
+// @ts-ignore: decorator
+@inline export const RTRACE = isDefined(ASC_RTRACE);
+
+// Memory manager
+
+// ╒════════════ Memory manager block layout (32-bit) ═════════════╕
+//    3                   2                   1
+//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
+// │                           MM info                             │ -4
+// ╞>ptr═══════════════════════════════════════════════════════════╡
+// │                              ...                              │
+@unmanaged export class BLOCK {
+  /** @ts-ignore:no initializer. Memory manager info. */
+  mmInfo: usize;
+}
+
+/** Overhead of a memory manager block. */
+// @ts-ignore: decorator
+@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();
+
+/** Maximum size of a memory manager block's payload. */
+// @ts-ignore: decorator
+@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;
+
+// Garbage collector
+
+// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕
+//    3                   2                   1
+//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
+// │                     Memory manager block                      │ -20
+// ╞═══════════════════════════════════════════════════════════════╡
+// │                            GC info                            │ -16
+// ├───────────────────────────────────────────────────────────────┤
+// │                            GC info                            │ -12
+// ├───────────────────────────────────────────────────────────────┤
+// │                            RT id                              │ -8
+// ├───────────────────────────────────────────────────────────────┤
+// │                            RT size                            │ -4
+// ╞>ptr═══════════════════════════════════════════════════════════╡
+// │                              ...                              │
+@unmanaged export class OBJECT extends BLOCK {
+  /** @ts-ignore:no initializer. Garbage collector info. */
+  gcInfo: u32;
+  /** @ts-ignore:no initializer. Garbage collector info. */
+  gcInfo2: u32;
+  /** @ts-ignore:no initializer. Runtime class id. */
+  rtId: u32;
+  /** @ts-ignore:no initializer. Runtime object size. */
+  rtSize: u32;
+}
+
+/** Overhead of a garbage collector object. Excludes memory manager block overhead. */
+// @ts-ignore: decorator
+@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;
+
+/** Maximum size of a garbage collector object's payload. */
+// @ts-ignore: decorator
+@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;
+
+/** Total of memory manager and garbage collector overhead. */
+// @ts-ignore: decorator
+@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;

package/assemblyscript/std/assembly/rt/index-incremental.ts

@@ -0,0 +1,4 @@
+import "./tlsf";
+import "./itcms";
+
+export { __collect, __pin, __unpin, __new, __renew, __link } from "./itcms";

package/assemblyscript/std/assembly/rt/index-radical.ts

@@ -0,0 +1,4 @@
+import "./tlsf";
+import "./tcms";
+
+export { __collect, __pin, __unpin, __new, __renew, __link } from "./tcms";

package/assemblyscript/std/assembly/rt/index.d.ts

@@ -0,0 +1,37 @@
+// Memory manager
+declare function __alloc(size: usize): usize;
+declare function __realloc(ptr: usize, size: usize): usize;
+declare function __free(ptr: usize): void;
+declare function __reset(): void;
+
+// Garbage collector
+declare function __new(size: usize, id: u32): usize;
+declare function __renew(ptr: usize, size: usize): usize;
+declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;
+declare function __collect(): void;
+
+// Runtime type info
+declare function __typeinfo(id: u32): u32;
+
+// Visitors
+declare function __visit(ptr: usize, cookie: i32): void;
+declare function __visit_globals(cookie: u32): void;
+declare function __visit_members(ptr: usize, cookie: u32): void;
+
+// Allocation helpers
+declare function __newBuffer(size: usize, id: u32, data?: usize): usize;
+declare function __newArray(length: i32, alignLog2: usize, id: u32, data?: usize): usize;
+declare function __newTuple(elementSize: usize, bitmap: u64): usize;
+
+// Finalization
+declare function __finalize(ptr: usize): void;
+
+// Debugging
+declare const ASC_GC_TESTING: bool;
+
+// Incremental GC constants
+declare const ASC_GC_GRANULARITY: i32;
+declare const ASC_GC_SWEEPFACTOR: i32;
+declare const ASC_GC_IDLEFACTOR: i32;
+declare const ASC_GC_MARKCOST: i32;
+declare const ASC_GC_SWEEPCOST: i32;