toilscript 0.0.1 → 0.1.1

package/std/assembly/object.ts

@@ -1,36 +1,36 @@
-export abstract class Object {
-  static is<T>(x: T, y: T): bool {
-    if (isFloat<T>()) {
-      // Float pointing is special we shoulr presere following identities:
-      // 0.0 !=-0.0
-      // NaN == NaN
-      if (sizeof<T>() == 8) {
-        return (
-          bool(u32(x != x) & u32(y != y) |
-          u32(reinterpret<u64>(f64(x)) == reinterpret<u64>(f64(y))))
-        );
-      } else {
-        return (
-          bool(u32(x != x) & u32(y != y) |
-          u32(reinterpret<u32>(f32(x)) == reinterpret<u32>(f32(y))))
-        );
-      }
-    }
-    // For references, strings, integers and booleans
-    return x == y;
-  }
-
-  // TODO: Wrapper classes like `Function<T>` override the `this` type of
-  // `toString`, which is covariant and hence fails to overload. Wrapper classes
-  // might need a different mechanism to indicate such special `this` types.
-  // toString(): string {
-  //   return "[object Object]";
-  // }
-}
-
-// TODO: The types `Object` and `object` differ in TypeScript, in that the
-// latter indicates any non-primitive type, not including `string` for example.
-// The `object` type hence remains reserved for now, also to potentially address
-// the above `toString` TODO in alternative ways.
-// @ts-ignore: nolib
-// export type object = Object;
+export abstract class Object {
+  static is<T>(x: T, y: T): bool {
+    if (isFloat<T>()) {
+      // Float pointing is special we shoulr presere following identities:
+      // 0.0 !=-0.0
+      // NaN == NaN
+      if (sizeof<T>() == 8) {
+        return (
+          bool(u32(x != x) & u32(y != y) |
+          u32(reinterpret<u64>(f64(x)) == reinterpret<u64>(f64(y))))
+        );
+      } else {
+        return (
+          bool(u32(x != x) & u32(y != y) |
+          u32(reinterpret<u32>(f32(x)) == reinterpret<u32>(f32(y))))
+        );
+      }
+    }
+    // For references, strings, integers and booleans
+    return x == y;
+  }
+
+  // TODO: Wrapper classes like `Function<T>` override the `this` type of
+  // `toString`, which is covariant and hence fails to overload. Wrapper classes
+  // might need a different mechanism to indicate such special `this` types.
+  // toString(): string {
+  //   return "[object Object]";
+  // }
+}
+
+// TODO: The types `Object` and `object` differ in TypeScript, in that the
+// latter indicates any non-primitive type, not including `string` for example.
+// The `object` type hence remains reserved for now, also to potentially address
+// the above `toString` TODO in alternative ways.
+// @ts-ignore: nolib
+// export type object = Object;

package/std/assembly/performance.ts

@@ -1,9 +1,9 @@
-import {
-  performance as performance_binding
-} from "bindings/dom";
-
-export namespace performance {
-  export function now(): f64 {
-    return performance_binding.now();
-  }
-}
+import {
+  performance as performance_binding
+} from "bindings/dom";
+
+export namespace performance {
+  export function now(): f64 {
+    return performance_binding.now();
+  }
+}

package/std/assembly/pointer.ts

@@ -1,80 +1,80 @@
-// Zero-overhead typed pointer. @unmanaged + changetype = no allocation, no GC.
-// Promoted from tests/compiler/std/pointer.ts experiment.
-
-@final @unmanaged
-export class Pointer<T> {
-
-  @inline constructor(offset: usize = 0) {
-    return changetype<Pointer<T>>(offset);
-  }
-
-  @inline get offset(): usize {
-    return changetype<usize>(this);
-  }
-
-  @inline get value(): T {
-    if (isReference<T>()) {
-      return changetype<T>(changetype<usize>(this));
-    } else {
-      return load<T>(changetype<usize>(this));
-    }
-  }
-
-  @inline set value(value: T) {
-    if (isReference<T>()) {
-      if (isManaged<T>()) ERROR("Unsafe unmanaged set of a managed object");
-      if (value == null) {
-        memory.fill(changetype<usize>(this), 0, offsetof<T>());
-      } else {
-        memory.copy(changetype<usize>(this), changetype<usize>(value), offsetof<T>());
-      }
-    } else {
-      store<T>(changetype<usize>(this), value);
-    }
-  }
-
-  @inline @operator("+") add(other: Pointer<T>): Pointer<T> {
-    return changetype<Pointer<T>>(changetype<usize>(this) + changetype<usize>(other));
-  }
-
-  @inline @operator("-") sub(other: Pointer<T>): Pointer<T> {
-    return changetype<Pointer<T>>(changetype<usize>(this) - changetype<usize>(other));
-  }
-
-  @inline @operator.prefix("++") inc(): Pointer<T> {
-    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
-    return changetype<Pointer<T>>(changetype<usize>(this) + size);
-  }
-
-  @inline @operator.prefix("--") dec(): Pointer<T> {
-    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
-    return changetype<Pointer<T>>(changetype<usize>(this) - size);
-  }
-
-  @inline @operator("[]") get(index: i32): T {
-    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
-    return load<T>(changetype<usize>(this) + (<usize>index * size));
-  }
-
-  @inline @operator("[]=") set(index: i32, value: T): void {
-    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
-    store<T>(changetype<usize>(this) + (<usize>index * size), value);
-  }
-
-  @inline isNull(): bool {
-    return changetype<usize>(this) == 0;
-  }
-
-  @inline equals(other: Pointer<T>): bool {
-    return changetype<usize>(this) == changetype<usize>(other);
-  }
-
-  @inline copyTo(dst: Pointer<T>, count: i32): void {
-    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
-    memory.copy(changetype<usize>(dst), changetype<usize>(this), <usize>count * size);
-  }
-
-  @inline static null<T>(): Pointer<T> {
-    return changetype<Pointer<T>>(0);
-  }
-}
+// Zero-overhead typed pointer. @unmanaged + changetype = no allocation, no GC.
+// Promoted from tests/compiler/std/pointer.ts experiment.
+
+@final @unmanaged
+export class Pointer<T> {
+
+  @inline constructor(offset: usize = 0) {
+    return changetype<Pointer<T>>(offset);
+  }
+
+  @inline get offset(): usize {
+    return changetype<usize>(this);
+  }
+
+  @inline get value(): T {
+    if (isReference<T>()) {
+      return changetype<T>(changetype<usize>(this));
+    } else {
+      return load<T>(changetype<usize>(this));
+    }
+  }
+
+  @inline set value(value: T) {
+    if (isReference<T>()) {
+      if (isManaged<T>()) ERROR("Unsafe unmanaged set of a managed object");
+      if (value == null) {
+        memory.fill(changetype<usize>(this), 0, offsetof<T>());
+      } else {
+        memory.copy(changetype<usize>(this), changetype<usize>(value), offsetof<T>());
+      }
+    } else {
+      store<T>(changetype<usize>(this), value);
+    }
+  }
+
+  @inline @operator("+") add(other: Pointer<T>): Pointer<T> {
+    return changetype<Pointer<T>>(changetype<usize>(this) + changetype<usize>(other));
+  }
+
+  @inline @operator("-") sub(other: Pointer<T>): Pointer<T> {
+    return changetype<Pointer<T>>(changetype<usize>(this) - changetype<usize>(other));
+  }
+
+  @inline @operator.prefix("++") inc(): Pointer<T> {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return changetype<Pointer<T>>(changetype<usize>(this) + size);
+  }
+
+  @inline @operator.prefix("--") dec(): Pointer<T> {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return changetype<Pointer<T>>(changetype<usize>(this) - size);
+  }
+
+  @inline @operator("[]") get(index: i32): T {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return load<T>(changetype<usize>(this) + (<usize>index * size));
+  }
+
+  @inline @operator("[]=") set(index: i32, value: T): void {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    store<T>(changetype<usize>(this) + (<usize>index * size), value);
+  }
+
+  @inline isNull(): bool {
+    return changetype<usize>(this) == 0;
+  }
+
+  @inline equals(other: Pointer<T>): bool {
+    return changetype<usize>(this) == changetype<usize>(other);
+  }
+
+  @inline copyTo(dst: Pointer<T>, count: i32): void {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    memory.copy(changetype<usize>(dst), changetype<usize>(this), <usize>count * size);
+  }
+
+  @inline static null<T>(): Pointer<T> {
+    return changetype<Pointer<T>>(0);
+  }
+}

package/std/assembly/polyfills.ts

@@ -1,27 +1,27 @@
-export function bswap<T extends number>(value: T): T {
-  if (isInteger<T>()) {
-    if (sizeof<T>() == 1) {
-      return value;
-    }
-    if (sizeof<T>() == 2) {
-      return <T>(<u16>value << 8 | (<u16>value >> 8));
-    }
-    if (sizeof<T>() == 4) {
-      return <T>(
-        rotl(<u32>value & 0xFF00FF00, 8) |
-        rotr(<u32>value & 0x00FF00FF, 8)
-      );
-    }
-    if (sizeof<T>() == 8) {
-      let a = (<u64>value >> 8) & 0x00FF00FF00FF00FF;
-      let b = (<u64>value & 0x00FF00FF00FF00FF) << 8;
-      let v = a | b;
-
-      a = (v >>> 16) & 0x0000FFFF0000FFFF;
-      b = (v & 0x0000FFFF0000FFFF) << 16;
-
-      return <T>rotr(a | b, 32);
-    }
-  }
-  ERROR("Unsupported generic type");
-}
+export function bswap<T extends number>(value: T): T {
+  if (isInteger<T>()) {
+    if (sizeof<T>() == 1) {
+      return value;
+    }
+    if (sizeof<T>() == 2) {
+      return <T>(<u16>value << 8 | (<u16>value >> 8));
+    }
+    if (sizeof<T>() == 4) {
+      return <T>(
+        rotl(<u32>value & 0xFF00FF00, 8) |
+        rotr(<u32>value & 0x00FF00FF, 8)
+      );
+    }
+    if (sizeof<T>() == 8) {
+      let a = (<u64>value >> 8) & 0x00FF00FF00FF00FF;
+      let b = (<u64>value & 0x00FF00FF00FF00FF) << 8;
+      let v = a | b;
+
+      a = (v >>> 16) & 0x0000FFFF0000FFFF;
+      b = (v & 0x0000FFFF0000FFFF) << 16;
+
+      return <T>rotr(a | b, 32);
+    }
+  }
+  ERROR("Unsupported generic type");
+}

package/std/assembly/process.ts

@@ -1,50 +1,50 @@
-import {
-  Date as Date_binding,
-  performance as performance_binding
-} from "bindings/dom";
-
-import {
-  process as process_binding
-} from "bindings/node";
-
-export namespace process {
-
-  // @ts-ignore: decorator
-  @lazy export const arch = sizeof<usize>() == 4 ? "wasm32" : "wasm64";
-
-  // @ts-ignore: decorator
-  @lazy export const platform = "wasm";
-
-  // @ts-ignore: decorator
-  @lazy export const argv = lazyArgv();
-
-  // @ts-ignore: decorator
-  @lazy export const env = lazyEnv();
-
-  // @ts-ignore: decorator
-  @lazy export let exitCode = 0;
-
-  export function exit(code: i32 = exitCode): void {
-    process_binding.exit(code);
-  }
-
-  export function time(): i64 {
-    return <i64>Date_binding.now();
-  }
-
-  export function hrtime(): u64 {
-    let now = performance_binding.now();
-    let millis = <u64>now;
-    let fraction = now - <f64>millis;
-    return millis * 1000000 + <u64>(fraction * 1000000);
-  }
-}
-
-function lazyArgv(): string[] {
-  return process_binding.argv;
-}
-
-function lazyEnv(): Map<string,string> {
-  // TODO: What about Node?
-  return new Map();
-}
+import {
+  Date as Date_binding,
+  performance as performance_binding
+} from "bindings/dom";
+
+import {
+  process as process_binding
+} from "bindings/node";
+
+export namespace process {
+
+  // @ts-ignore: decorator
+  @lazy export const arch = sizeof<usize>() == 4 ? "wasm32" : "wasm64";
+
+  // @ts-ignore: decorator
+  @lazy export const platform = "wasm";
+
+  // @ts-ignore: decorator
+  @lazy export const argv = lazyArgv();
+
+  // @ts-ignore: decorator
+  @lazy export const env = lazyEnv();
+
+  // @ts-ignore: decorator
+  @lazy export let exitCode = 0;
+
+  export function exit(code: i32 = exitCode): void {
+    process_binding.exit(code);
+  }
+
+  export function time(): i64 {
+    return <i64>Date_binding.now();
+  }
+
+  export function hrtime(): u64 {
+    let now = performance_binding.now();
+    let millis = <u64>now;
+    let fraction = now - <f64>millis;
+    return millis * 1000000 + <u64>(fraction * 1000000);
+  }
+}
+
+function lazyArgv(): string[] {
+  return process_binding.argv;
+}
+
+function lazyEnv(): Map<string,string> {
+  // TODO: What about Node?
+  return new Map();
+}

package/std/assembly/reference.ts

@@ -1,48 +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 {
-}
+// 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

@@ -1,12 +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"); }
-
-}
+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"); }
+
+}