Some thoughts on an initial stdlib to get things going

Author: dcodeIO

README.md

@@ -26,6 +26,11 @@ Side effects:
 - Good benchmark when comparing both versions
 - Benefits standard library design ideas
 
+How does it work?
+-----------------
+
+AssemblyScript NEXT compiles a subset (or variant) of TypeScript to Binaryen IR. The resulting module can then be optimized, emitted in text or binary format, or even be converted to asm.js as a polyfill.
+
 Getting started
 ---------------
 
@@ -38,7 +43,7 @@ $> npm install
 $> node bin\asc yourModule.ts
 ```
 
-Building an UMD bundle to `dist/assemblyscript.js` (does not bundle [binaryen.js](https://github.com/AssemblyScript/binaryen.js):
+Building an UMD bundle to `dist/assemblyscript.js` (does not bundle [binaryen.js](https://github.com/AssemblyScript/binaryen.js)):
 
 ```
 $> npm run build

assembly.d.ts

@@ -87,17 +87,10 @@ declare function assert(isTrue: bool): void;
 
 // internal decorators
 
-declare function global(name?: string): any;
-declare function struct(): any
+declare function global(): any;
 declare function inline(): any;
-declare function allocates(): any;
-declare function operator(token: string, fn: any): any;
 
 // standard library
 
-/// <reference path="./std/array.d.ts" />
-/// <reference path="./std/map.d.ts" />
-/// <reference path="./std/math.d.ts" />
-/// <reference path="./std/memory.d.ts" />
-/// <reference path="./std/set.d.ts" />
-/// <reference path="./std/string.d.ts" />
+/// <reference path="./std/carray.d.ts" />
+/// <reference path="./std/cstring.d.ts" />

src/compiler.ts

@@ -1624,59 +1624,54 @@ export class Compiler extends DiagnosticEmitter {
   }
 
   compileIdentifierExpression(expression: IdentifierExpression, contextualType: Type): ExpressionRef {
+    switch (expression.kind) {
 
-    // null
-    if (expression.kind == NodeKind.NULL) {
-      if (contextualType.classType) // keep contextualType
-        return this.options.target == Target.WASM64 ? this.module.createI64(0, 0) : this.module.createI32(0);
-      if (this.options.target == Target.WASM64) {
-        this.currentType = Type.u64;
-        return this.module.createI64(0, 0);
-      } else {
-        this.currentType = Type.u32;
+      case NodeKind.NULL:
+        if (this.options.target == Target.WASM64) {
+          if (!contextualType.classType) {
+            assert(contextualType.kind == TypeKind.USIZE);
+            this.currentType = Type.usize64;
+          }
+          return this.module.createI64(0, 0);
+        }
+        if (!contextualType.classType) {
+          assert(contextualType.kind == TypeKind.USIZE);
+          this.currentType = Type.usize32;
+        }
         return this.module.createI32(0);
-      }
 
-    // true
-    } else if (expression.kind == NodeKind.TRUE) {
-      this.currentType = Type.bool;
-      return this.module.createI32(1);
-
-    // false
-    } else if (expression.kind == NodeKind.FALSE) {
-      this.currentType = Type.bool;
-      return this.module.createI32(0);
-
-    // this
-    } else if (expression.kind == NodeKind.THIS) {
-      if (this.currentFunction.instanceMethodOf) {
-        this.currentType = this.currentFunction.instanceMethodOf.type;
-        return this.module.createGetLocal(0, this.options.target == Target.WASM64 ? NativeType.I64 : NativeType.I32);
-      }
-      this.error(DiagnosticCode._this_cannot_be_referenced_in_current_location, expression.range);
-      this.currentType = this.options.target == Target.WASM64 ? Type.u64 : Type.u32;
-      return this.module.createUnreachable();
-    }
+      case NodeKind.TRUE:
+        this.currentType = Type.bool;
+        return this.module.createI32(1);
 
-    if (expression.kind == NodeKind.IDENTIFIER) {
+      case NodeKind.FALSE:
+        this.currentType = Type.bool;
+        return this.module.createI32(0);
 
-      // NaN
-      if ((<IdentifierExpression>expression).name == "NaN")
-        if (this.currentType.kind == TypeKind.F32)
-          return this.module.createF32(NaN);
-        else {
+      case NodeKind.THIS:
+        if (this.currentFunction.instanceMethodOf) {
+          this.currentType = this.currentFunction.instanceMethodOf.type;
+          return this.module.createGetLocal(0, this.options.target == Target.WASM64 ? NativeType.I64 : NativeType.I32);
+        }
+        this.error(DiagnosticCode._this_cannot_be_referenced_in_current_location, expression.range);
+        this.currentType = this.options.target == Target.WASM64 ? Type.u64 : Type.u32;
+        return this.module.createUnreachable();
+
+      case NodeKind.IDENTIFIER:
+        // TODO: some sort of resolveIdentifier maybe
+        if ((<IdentifierExpression>expression).name == "NaN") {
+          if (this.currentType == Type.f32)
+            return this.module.createF32(NaN);
           this.currentType = Type.f64;
           return this.module.createF64(NaN);
         }
-
-      // Infinity
-      if ((<IdentifierExpression>expression).name == "Infinity")
-        if (this.currentType.kind == TypeKind.F32)
-          return this.module.createF32(Infinity);
-        else {
+        if ((<IdentifierExpression>expression).name == "Infinity") {
+          if (this.currentType == Type.f32)
+            return this.module.createF32(Infinity);
           this.currentType = Type.f64;
           return this.module.createF64(Infinity);
         }
+        break;
     }
 
     const element: Element | null = this.program.resolveElement(expression, this.currentFunction); // reports

src/glue/js.d.ts

@@ -14,6 +14,7 @@ declare type bool = boolean;
 // Raw memory access (here: Binaryen memory)
 declare function store<T = u8>(ptr: usize, val: T): void;
 declare function load<T = u8>(ptr: usize): T;
+declare function assert(isTrue: bool): void;
 
 // Other things that might or might not be useful
 declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;

std/array.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../assembly.d.ts" />
+
+declare class CArray<T> {
+  [key: number]: T;
+  constructor(capacity: usize);
+}

std/carray.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../assembly.d.ts" />
+
+declare class CString extends CArray<u8> {
+  constructor(text: string);
+}

std/cstring.d.ts

@@ -0,0 +1,29 @@
+/// <reference path="../../assembly.d.ts" />
+
+/** A C-compatible Array class. */
+@global()
+class CArray<T> {
+
+  /** Constructs a new C-Array of the specified capacity. */
+  constructor(capacity: usize) {
+    return unsafe_cast<usize,this>(Memory.allocate(capacity * sizeof<T>()));
+  }
+
+  /** Gets the element at the specified index using bracket notation. */
+  @inline()
+  "[]"(index: usize): T {
+    return load<T>(unsafe_cast<this,usize>(this) + index * sizeof<T>());
+  }
+
+  /** Sets the element at the specified index using bracket notation. */
+  @inline()
+  "[]="(index: usize, value: T): T {
+    store<T>(unsafe_cast<this,usize>(this) + index * sizeof<T>(), value);
+    return value;
+  }
+
+  /** Disposes this instance and the memory associated with it. */
+  dispose(): void {
+    Memory.dispose(unsafe_cast<this,usize>(this));
+  }
+}