Add webpack; Setup instructions

.gitignore

@@ -1,4 +1,5 @@
 node_modules/
 npm-debug.*
+dist/
 out/
 raw/

README.md

@@ -25,3 +25,32 @@ Side effects:
 - Good fire test for the compiler
 - Good benchmark when comparing both versions
 - Benefits standard library design ideas
+
+Getting started
+---------------
+
+If you'd like to try out NEXT today or even plan to contribute, this is how you do it:
+
+```
+$> git clone https://github.com/AssemblyScript/next.git
+$> cd next
+$> npm install
+$> node bin\asc yourModule.ts
+```
+
+Building a browser bundle to `dist/assemblyscript.js` (requires [binaryen.js](https://github.com/AssemblyScript/binaryen.js)):
+
+```
+$> npm run build
+```
+
+Running the [tests](./tests):
+
+```
+$> npm test
+```
+
+Development status
+------------------
+
+For now, see the [compiler tests](https://github.com/AssemblyScript/next/tree/master/tests/compiler) for an overview of what's supposed to be working already.

package.json

@@ -17,14 +17,16 @@
     "diff": "^3.4.0",
     "glob": "^7.1.2",
     "long": "^3.2.0",
+    "ts-loader": "^3.2.0",
     "ts-node": "^3.3.0",
-    "typescript": "^2.6.2"
+    "typescript": "^2.6.2",
+    "webpack": "^3.10.0"
   },
   "bin": {
     "asc": "bin/asc.js"
   },
   "scripts": {
-    "build": "tsc -P src",
+    "build": "webpack",
     "test:parser": "ts-node -P src tests/parser",
     "test:compiler": "ts-node -P src tests/compiler",
     "test": "npm run test:parser && npm run test:compiler"

src/builtins.ts

@@ -5,7 +5,7 @@ import { Type } from "./types";
 import { ExpressionRef, UnaryOp, BinaryOp, HostOp, NativeType } from "./module";
 import { Program, FunctionPrototype, Local } from "./program";
 
-/** Initializes the specified program with builtin functions. */
+/** Initializes the specified program with built-in functions. */
 export function initialize(program: Program): void {
   addFunction(program, "clz", true);
   addFunction(program, "ctz", true);
@@ -34,15 +34,15 @@ export function initialize(program: Program): void {
   addFunction(program, "assert");
 }
 
-/** Adds a builtin function to the specified program. */
+/** Adds a built-in function to the specified program. */
 function addFunction(program: Program, name: string, isGeneric: bool = false): void {
   let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
   prototype.isGeneric = isGeneric;
-  prototype.isBuiltin = true;
+  prototype.isBuiltIn = true;
   program.elements.set(name, prototype);
 }
 
-/** Compiles a call to a builtin function. */
+/** Compiles a call to a built-in function. */
 export function compileCall(compiler: Compiler, internalName: string, typeArguments: Type[], operands: Expression[], reportNode: Node): ExpressionRef {
   const usizeType: Type = select<Type>(Type.usize64, Type.usize32, compiler.options.target == Target.WASM64);
 
@@ -417,7 +417,7 @@ export function compileCall(compiler: Compiler, internalName: string, typeArgume
   return 0;
 }
 
-/** Validates a call to a builtin function. */
+/** Validates a call to a built-in function. */
 function validateCall(compiler: Compiler, typeArguments: Type[], expectedTypeArguments: i32, operands: Expression[], expectedOperands: i32, reportNode: Node): bool {
   if (typeArguments.length != expectedTypeArguments) {
     compiler.error(DiagnosticCode.Expected_0_type_arguments_but_got_1, reportNode.range, expectedTypeArguments.toString(10), typeArguments.length.toString(10));

src/compiler.ts

@@ -153,7 +153,7 @@ export class Compiler extends DiagnosticEmitter {
   compile(): Module {
     const program: Program = this.program;
 
-    // initialize lookup maps, builtins, imports, exports, etc.
+    // initialize lookup maps, built-ins, imports, exports, etc.
     program.initialize(this.options.target);
 
     // compile entry file (exactly one, usually)
@@ -1459,7 +1459,7 @@ export class Compiler extends DiagnosticEmitter {
     if (element.kind == ElementKind.FUNCTION_PROTOTYPE) {
       const functionPrototype: FunctionPrototype = <FunctionPrototype>element;
       let functionInstance: Function | null = null;
-      if (functionPrototype.isBuiltin) {
+      if (functionPrototype.isBuiltIn) {
         const k: i32 = expression.typeArguments.length;
         const resolvedTypeArguments: Type[] = new Array(k);
         sb.length = 0;

src/glue/js.ts

@@ -12,7 +12,12 @@ globalScope["select"] = function select<T>(ifTrue: T, ifFalse: T, condition: boo
   return condition ? ifTrue : ifFalse;
 };
 
-const binaryen = require("binaryen");
+let binaryen: any;
+try {
+  binaryen = require("binaryen");
+} catch (e) {
+  binaryen = globalScope["Binaryen"];
+}
 for (const key in binaryen)
   if (/^_(?:Binaryen|Relooper|malloc$|free$)/.test(key))
     globalScope[key] = binaryen[key];

src/program.ts

@@ -625,8 +625,6 @@ export class Program extends DiagnosticEmitter {
       return null;
     }
 
-    let ret: Element;
-
     // local or global name
     if (expression.kind == NodeKind.IDENTIFIER) {
       const name: string = (<IdentifierExpression>expression).name;
@@ -708,7 +706,7 @@ export abstract class Element {
   internalName: string;
   isCompiled: bool = false;
   isImport: bool = false;
-  isBuiltin: bool = false;
+  isBuiltIn: bool = false;
   isDeclare: bool = false;
 
   constructor(program: Program, internalName: string) {
@@ -825,7 +823,7 @@ export class FunctionPrototype extends Element {
     super(program, internalName);
     this.declaration = declaration;
     this.classPrototype = classPrototype;
-    this.isGeneric = declaration ? declaration.typeParameters.length > 0 : false; // builtins set this
+    this.isGeneric = declaration ? declaration.typeParameters.length > 0 : false; // built-ins set this
   }
 
   get isExport(): bool { return this.declaration ? hasModifier(ModifierKind.EXPORT, this.declaration.modifiers) : /* internals aren't file-level exports */ false; }
@@ -942,7 +940,7 @@ export class Function extends Element {
     this.parameters = parameters;
     this.returnType = returnType;
     this.instanceMethodOf = instanceMethodOf;
-    this.isBuiltin = prototype.isBuiltin;
+    this.isBuiltIn = prototype.isBuiltIn;
     this.isDeclare = prototype.isDeclare;
     let localIndex: i32 = 0;
     if (instanceMethodOf) {
@@ -1053,7 +1051,7 @@ export class ClassPrototype extends Namespace {
     let resolvedTypeArguments: Type[] | null;
     if (this.isGeneric) {
       if (!this.declaration)
-        throw new Error("not implemented"); // generic builtin
+        throw new Error("not implemented"); // generic built-in
       resolvedTypeArguments = this.program.resolveTypeArguments(this.declaration.typeParameters, typeArgumentNodes, contextualTypeArguments, alternativeReportNode);
       if (!resolvedTypeArguments)
         return null;
@@ -1091,7 +1089,7 @@ export class Class extends Namespace {
 
     // apply instance-specific contextual type arguments
     const declaration: ClassDeclaration | null = this.template.declaration;
-    if (declaration) { // irrelevant for builtins
+    if (declaration) { // irrelevant for built-ins
       const typeParameters: TypeParameter[] = declaration.typeParameters;
       if (typeParameters.length != typeArguments.length)
         throw new Error("unexpected type argument count mismatch");

src/tsconfig.json

@@ -16,10 +16,13 @@
     "noImplicitReturns": true,
     "noImplicitAny": true,
     "noImplicitThis": true,
-    "outDir": "../out"
+    "preserveConstEnums": true,
+    "outDir": "../out",
+    "sourceMap": true
   },
   "files": [
     "ast.ts",
+    "builtins.ts",
     "compiler.ts",
     "diagnosticMessages.generated.ts",
     "diagnostics.ts",

webpack.config.js

@@ -0,0 +1,34 @@
+var path = require("path");
+var webpack = require("webpack");
+
+module.exports = {
+  entry: [ "./src/glue/js.ts", "./src/index.ts" ],
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: "ts-loader",
+        exclude: /node_modules/
+      }
+    ]
+  },
+  externals: [ "binaryen" ],
+  resolve: {
+    extensions: [ ".ts", ".js" ]
+  },
+  output: {
+    filename: "assemblyscript.js",
+    path: path.resolve(__dirname, "dist"),
+    library: "assemblyscript",
+    libraryTarget: "umd"
+  },
+  plugins: [
+    new webpack.optimize.UglifyJsPlugin({
+      minimize: true,
+      sourceMap: true
+    }),
+    new webpack.SourceMapDevToolPlugin({
+      filename: "assemblyscript.js.map"
+    })
+  ]
+}