toilscript 0.0.1

package/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/std/assembly/regexp.ts

@@ -0,0 +1,12 @@
+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/std/assembly/rt/README.md

@@ -0,0 +1,83 @@
+The AssemblyScript Runtime
+==========================
+
+The runtime provides the functionality necessary to dynamically allocate and deallocate memory of objects, arrays and buffers, as well as collect garbage that is no longer used. The current implementation is either a Two-Color Mark & Sweep (TCMS) garbage collector that must be called manually when the execution stack is unwound or an Incremental Tri-Color Mark & Sweep (ITCMS) garbage collector that is fully automated with a shadow stack, implemented on top of a Two-Level Segregate Fit (TLSF) memory manager. It's not designed to be the fastest of its kind, but intentionally focuses on simplicity and ease of integration until we can replace it with the real deal, i.e. Wasm GC.
+
+Interface
+---------
+
+### Garbage collector / `--exportRuntime`
+
+* **__new**(size: `usize`, id: `u32` = 0): `usize`<br />
+  Dynamically allocates a GC object of at least the specified size and returns its address.
+  Alignment is guaranteed to be 16 bytes to fit up to v128 values naturally.
+  GC-allocated objects cannot be used with `__realloc` and `__free`.
+
+* **__pin**(ptr: `usize`): `usize`<br />
+  Pins the object pointed to by `ptr` externally so it and its directly reachable members and indirectly reachable objects do not become garbage collected.
+
+* **__unpin**(ptr: `usize`): `void`<br />
+  Unpins the object pointed to by `ptr` externally so it can become garbage collected.
+
+* **__collect**(): `void`<br />
+  Performs a full garbage collection.
+
+### Internals
+
+* **__alloc**(size: `usize`): `usize`<br />
+  Dynamically allocates a chunk of memory of at least the specified size and returns its address.
+  Alignment is guaranteed to be 16 bytes to fit up to v128 values naturally.
+
+* **__realloc**(ptr: `usize`, size: `usize`): `usize`<br />
+  Dynamically changes the size of a chunk of memory, possibly moving it to a new address.
+
+* **__free**(ptr: `usize`): `void`<br />
+  Frees a dynamically allocated chunk of memory by its address.
+
+* **__renew**(ptr: `usize`, size: `usize`): `usize`<br />
+  Like `__realloc`, but for `__new`ed GC objects.
+
+* **__link**(parentPtr: `usize`, childPtr: `usize`, expectMultiple: `bool`): `void`<br />
+  Introduces a link from a parent object to a child object, i.e. upon `parent.field = child`.
+
+* **__visit**(ptr: `usize`, cookie: `u32`): `void`<br />
+  Concrete visitor implementation called during traversal. Cookie can be used to indicate one of multiple operations.
+
+* **__visit_globals**(cookie: `u32`): `void`<br />
+  Calls `__visit` on each global that is of a managed type.
+
+* **__visit_members**(ptr: `usize`, cookie: `u32`): `void`<br />
+  Calls `__visit` on each member of the object pointed to by `ptr`.
+
+* **__typeinfo**(id: `u32`): `RTTIFlags`<br />
+  Obtains the runtime type information for objects with the specified runtime id. Runtime type information is a set of flags indicating whether a type is managed, an array or similar, and what the relevant alignments when creating an instance externally are etc.
+
+ITCMS / `--runtime incremental`
+-----
+
+The Incremental Tri-Color Mark & Sweep garbage collector maintains a separate shadow stack of managed values in the background to achieve full automation. Maintaining another stack introduces some overhead compared to the simpler Two-Color Mark & Sweep garbage collector, but makes it independent of whether the execution stack is unwound or not when it is invoked, so the garbage collector can run interleaved with the program.
+
+There are several constants one can experiment with to tweak ITCMS's automation:
+
+* `--use ASC_GC_GRANULARITY=1024`<br />
+  How often to interrupt. The default of 1024 means "interrupt each 1024 bytes allocated".
+* `--use ASC_GC_STEPFACTOR=200`<br />
+  How long to interrupt. The default of 200% means "run at double the speed of allocations".
+* `--use ASC_GC_IDLEFACTOR=200`<br />
+  How long to idle. The default of 200% means "wait for memory to double before kicking in again".
+* `--use ASC_GC_MARKCOST=1`<br />
+  How costly it is to mark one object. Budget per interrupt is `GRANULARITY * STEPFACTOR / 100`.
+* `--use ASC_GC_SWEEPCOST=10`<br />
+  How costly it is to sweep one object. Budget per interrupt is `GRANULARITY * STEPFACTOR / 100`.
+
+TCMS / `--runtime minimal`
+----
+
+If automation and low pause times aren't strictly necessary, using the Two-Color Mark & Sweep garbage collector instead by invoking collection manually at appropriate times when the execution stack is unwound may be more performant as it simpler and has less overhead. The execution stack is typically unwound when invoking the collector externally, at a place that is not indirectly called from Wasm.
+
+STUB / `--runtime stub`
+----
+
+The stub is a maximally minimal runtime substitute, consisting of a simple and fast bump allocator with no means of freeing up memory again, except when freeing the respective most recently allocated object on top of the bump. Useful where memory is not a concern, and/or where it is sufficient to destroy the whole module including any potential garbage after execution.
+
+See also: [Garbage collection](https://www.assemblyscript.org/garbage-collection.html)

package/std/assembly/rt/common.ts

@@ -0,0 +1,81 @@
+// 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);
+// @ts-ignore: decorator
+@inline export const PROFILE = isDefined(ASC_PROFILE);
+
+// 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 {
+  /** 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 {
+  /** Garbage collector info. */
+  gcInfo: u32;
+  /** Garbage collector info. */
+  gcInfo2: u32;
+  /** Runtime class id. */
+  rtId: u32;
+  /** 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/std/assembly/rt/index-incremental.ts

@@ -0,0 +1,2 @@
+import "./tlsf";
+import "./itcms";

package/std/assembly/rt/index-memory.ts

@@ -0,0 +1 @@
+import "./memory-runtime";

package/std/assembly/rt/index-minimal.ts

@@ -0,0 +1,2 @@
+import "./tlsf";
+import "./tcms";

package/std/assembly/rt/index-stub.ts

@@ -0,0 +1 @@
+import "./stub";

package/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;
+
+// Finalization
+declare function __finalize(ptr: usize): void;
+
+// Debugging
+declare const ASC_RTRACE: bool;
+declare const ASC_PROFILE: 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;