Misc refactorings (#974)

Author: dcodeIO

cli/asc.js

@@ -181,6 +181,7 @@ exports.main = function main(argv, options, callback) {
     stdout.write("Version " + exports.version + (isDev ? "-dev" : "") + EOL);
     return callback(null);
   }
+
   // Print the help message if requested or no source files are provided
   if (args.help || !argv.length) {
     var out = args.help ? stdout : stderr;
@@ -211,6 +212,77 @@ exports.main = function main(argv, options, callback) {
   // Set up base directory
   const baseDir = args.baseDir ? path.resolve(args.baseDir) : ".";
 
+  // Set up options
+  const compilerOptions = assemblyscript.newOptions();
+  assemblyscript.setTarget(compilerOptions, 0);
+  assemblyscript.setNoAssert(compilerOptions, args.noAssert);
+  assemblyscript.setImportMemory(compilerOptions, args.importMemory);
+  assemblyscript.setSharedMemory(compilerOptions, args.sharedMemory);
+  assemblyscript.setImportTable(compilerOptions, args.importTable);
+  assemblyscript.setExplicitStart(compilerOptions, args.explicitStart);
+  assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0);
+  assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null);
+  assemblyscript.setNoUnsafe(compilerOptions, args.noUnsafe);
+
+  // Initialize default aliases
+  assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath");
+  assemblyscript.setGlobalAlias(compilerOptions, "Mathf", "NativeMathf");
+  assemblyscript.setGlobalAlias(compilerOptions, "abort", "~lib/builtins/abort");
+  assemblyscript.setGlobalAlias(compilerOptions, "trace", "~lib/builtins/trace");
+
+  // Add or override aliases if specified
+  if (args.use) {
+    let aliases = args.use;
+    for (let i = 0, k = aliases.length; i < k; ++i) {
+      let part = aliases[i];
+      let p = part.indexOf("=");
+      if (p < 0) return callback(Error("Global alias '" + part + "' is invalid."));
+      let alias = part.substring(0, p).trim();
+      let name = part.substring(p + 1).trim();
+      if (!alias.length) return callback(Error("Global alias '" + part + "' is invalid."));
+      assemblyscript.setGlobalAlias(compilerOptions, alias, name);
+    }
+  }
+
+  // Disable default features if specified
+  var features;
+  if ((features = args.disable) != null) {
+    if (typeof features === "string") features = features.split(",");
+    for (let i = 0, k = features.length; i < k; ++i) {
+      let name = features[i].trim();
+      let flag = assemblyscript["FEATURE_" + name.replace(/\-/g, "_").toUpperCase()];
+      if (!flag) return callback(Error("Feature '" + name + "' is unknown."));
+      assemblyscript.disableFeature(compilerOptions, flag);
+    }
+  }
+
+  // Enable experimental features if specified
+  if ((features = args.enable) != null) {
+    if (typeof features === "string") features = features.split(",");
+    for (let i = 0, k = features.length; i < k; ++i) {
+      let name = features[i].trim();
+      let flag = assemblyscript["FEATURE_" + name.replace(/\-/g, "_").toUpperCase()];
+      if (!flag) return callback(Error("Feature '" + name + "' is unknown."));
+      assemblyscript.enableFeature(compilerOptions, flag);
+    }
+  }
+
+  // Set up optimization levels
+  var optimizeLevel = 0;
+  var shrinkLevel = 0;
+  if (args.optimize) {
+    optimizeLevel = exports.defaultOptimizeLevel;
+    shrinkLevel = exports.defaultShrinkLevel;
+  }
+  if (typeof args.optimizeLevel === "number") optimizeLevel = args.optimizeLevel;
+  if (typeof args.shrinkLevel === "number") shrinkLevel = args.shrinkLevel;
+  optimizeLevel = Math.min(Math.max(optimizeLevel, 0), 3);
+  shrinkLevel = Math.min(Math.max(shrinkLevel, 0), 2);
+  assemblyscript.setOptimizeLevelHints(compilerOptions, optimizeLevel, shrinkLevel);
+
+  // Initialize the program
+  const program = assemblyscript.newProgram(compilerOptions);
+
   // Set up transforms
   const transforms = [];
   if (args.transform) {
@@ -222,6 +294,7 @@ exports.main = function main(argv, options, callback) {
         const classOrModule = require(require.resolve(filename, { paths: [baseDir, process.cwd()] }));
         if (typeof classOrModule === "function") {
           Object.assign(classOrModule.prototype, {
+            program,
             baseDir,
             stdout,
             stderr,
@@ -252,15 +325,12 @@ exports.main = function main(argv, options, callback) {
     }
   }
 
-  // Begin parsing
-  var parser = null;
-
-  // Include library files
+  // Parse library files
   Object.keys(exports.libraryFiles).forEach(libPath => {
     if (libPath.indexOf("/") >= 0) return; // in sub-directory: imported on demand
     stats.parseCount++;
     stats.parseTime += measure(() => {
-      parser = assemblyscript.parseFile(exports.libraryFiles[libPath], exports.libraryPrefix + libPath + ".ts", false, parser);
+      assemblyscript.parse(program, exports.libraryFiles[libPath], exports.libraryPrefix + libPath + ".ts", false);
     });
   });
   const customLibDirs = [];
@@ -284,7 +354,7 @@ exports.main = function main(argv, options, callback) {
         stats.parseCount++;
         exports.libraryFiles[libPath.replace(/\.ts$/, "")] = libText;
         stats.parseTime += measure(() => {
-          parser = assemblyscript.parseFile(libText, exports.libraryPrefix + libPath, false, parser);
+          assemblyscript.parse(program, libText, exports.libraryPrefix + libPath, false);
         });
       }
     }
@@ -393,15 +463,15 @@ exports.main = function main(argv, options, callback) {
   // Parses the backlog of imported files after including entry files
   function parseBacklog() {
     var internalPath;
-    while ((internalPath = parser.nextFile()) != null) {
-      let file = getFile(internalPath, assemblyscript.getDependee(parser, internalPath));
+    while ((internalPath = assemblyscript.nextFile(program)) != null) {
+      let file = getFile(internalPath, assemblyscript.getDependee(program, internalPath));
       if (!file) return callback(Error("Import file '" + internalPath + ".ts' not found."))
       stats.parseCount++;
       stats.parseTime += measure(() => {
-        assemblyscript.parseFile(file.sourceText, file.sourcePath, false, parser);
+        assemblyscript.parse(program, file.sourceText, file.sourcePath, false);
       });
     }
-    if (checkDiagnostics(parser, stderr)) return callback(Error("Parse error"));
+    if (checkDiagnostics(program, stderr)) return callback(Error("Parse error"));
   }
 
   // Include runtime template before entry files so its setup runs first
@@ -418,7 +488,7 @@ exports.main = function main(argv, options, callback) {
     }
     stats.parseCount++;
     stats.parseTime += measure(() => {
-      parser = assemblyscript.parseFile(runtimeText, runtimePath, true, parser);
+      assemblyscript.parse(program, runtimeText, runtimePath, true);
     });
   }
 
@@ -442,7 +512,7 @@ exports.main = function main(argv, options, callback) {
 
     stats.parseCount++;
     stats.parseTime += measure(() => {
-      parser = assemblyscript.parseFile(sourceText, sourcePath, true, parser);
+      assemblyscript.parse(program, sourceText, sourcePath, true);
     });
   }
 
@@ -454,7 +524,7 @@ exports.main = function main(argv, options, callback) {
 
   // Call afterParse transform hook
   {
-    let error = applyTransform("afterParse", parser);
+    let error = applyTransform("afterParse", program.parser);
     if (error) return callback(error);
   }
 
@@ -464,9 +534,6 @@ exports.main = function main(argv, options, callback) {
     if (code) return code;
   }
 
-  // Finish parsing
-  const program = assemblyscript.finishParsing(parser);
-
   // Print files and exit if listFiles
   if (args.listFiles) {
     // FIXME: not a proper C-like API
@@ -490,72 +557,16 @@ exports.main = function main(argv, options, callback) {
   optimizeLevel = Math.min(Math.max(optimizeLevel, 0), 3);
   shrinkLevel = Math.min(Math.max(shrinkLevel, 0), 2);
 
-  // Begin compilation
-  const compilerOptions = assemblyscript.createOptions();
-  assemblyscript.setTarget(compilerOptions, 0);
-  assemblyscript.setNoAssert(compilerOptions, args.noAssert);
-  assemblyscript.setImportMemory(compilerOptions, args.importMemory);
-  assemblyscript.setSharedMemory(compilerOptions, args.sharedMemory);
-  assemblyscript.setImportTable(compilerOptions, args.importTable);
-  assemblyscript.setExplicitStart(compilerOptions, args.explicitStart);
-  assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0);
-  assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null);
-  assemblyscript.setOptimizeLevelHints(compilerOptions, optimizeLevel, shrinkLevel);
-  assemblyscript.setNoUnsafe(compilerOptions, args.noUnsafe);
-
-  // Initialize default aliases
-  assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath");
-  assemblyscript.setGlobalAlias(compilerOptions, "Mathf", "NativeMathf");
-  assemblyscript.setGlobalAlias(compilerOptions, "abort", "~lib/builtins/abort");
-  assemblyscript.setGlobalAlias(compilerOptions, "trace", "~lib/builtins/trace");
-
-  // Add or override aliases if specified
-  if (args.use) {
-    let aliases = args.use;
-    for (let i = 0, k = aliases.length; i < k; ++i) {
-      let part = aliases[i];
-      let p = part.indexOf("=");
-      if (p < 0) return callback(Error("Global alias '" + part + "' is invalid."));
-      let alias = part.substring(0, p).trim();
-      let name = part.substring(p + 1).trim();
-      if (!alias.length) return callback(Error("Global alias '" + part + "' is invalid."));
-      assemblyscript.setGlobalAlias(compilerOptions, alias, name);
-    }
-  }
-
-  // Disable default features if specified
-  var features;
-  if ((features = args.disable) != null) {
-    if (typeof features === "string") features = features.split(",");
-    for (let i = 0, k = features.length; i < k; ++i) {
-      let name = features[i].trim();
-      let flag = assemblyscript["FEATURE_" + name.replace(/\-/g, "_").toUpperCase()];
-      if (!flag) return callback(Error("Feature '" + name + "' is unknown."));
-      assemblyscript.disableFeature(compilerOptions, flag);
-    }
-  }
-
-  // Enable experimental features if specified
-  if ((features = args.enable) != null) {
-    if (typeof features === "string") features = features.split(",");
-    for (let i = 0, k = features.length; i < k; ++i) {
-      let name = features[i].trim();
-      let flag = assemblyscript["FEATURE_" + name.replace(/\-/g, "_").toUpperCase()];
-      if (!flag) return callback(Error("Feature '" + name + "' is unknown."));
-      assemblyscript.enableFeature(compilerOptions, flag);
-    }
-  }
-
   var module;
   stats.compileCount++;
   try {
     stats.compileTime += measure(() => {
-      module = assemblyscript.compileProgram(program, compilerOptions);
+      module = assemblyscript.compile(program);
     });
   } catch (e) {
     return callback(e);
   }
-  if (checkDiagnostics(parser, stderr)) {
+  if (checkDiagnostics(program, stderr)) {
     if (module) module.dispose();
     return callback(Error("Compile error"));
   }
@@ -944,10 +955,10 @@ exports.main = function main(argv, options, callback) {
 }
 
 /** Checks diagnostics emitted so far for errors. */
-function checkDiagnostics(emitter, stderr) {
+function checkDiagnostics(program, stderr) {
   var diagnostic;
   var hasErrors = false;
-  while ((diagnostic = assemblyscript.nextDiagnostic(emitter)) != null) {
+  while ((diagnostic = assemblyscript.nextDiagnostic(program)) != null) {
     if (stderr) {
       stderr.write(
         assemblyscript.formatDiagnostic(diagnostic, stderr.isTTY, true) +

cli/transform.d.ts

@@ -3,11 +3,14 @@
  * @module cli/transform
  *//***/
 
-import { Parser, Module } from "..";
+import { Program, Parser, Module } from "..";
 import { OutputStream } from "./asc";
 
 export abstract class Transform {
 
+  /** Program reference. */
+  readonly program: Program;
+
   /** Base directory. */
   readonly baseDir: string;
 

src/builtins.ts

@@ -150,8 +150,6 @@ export namespace BuiltinSymbols {
   export const changetype = "~lib/builtins/changetype";
   export const assert = "~lib/builtins/assert";
   export const unchecked = "~lib/builtins/unchecked";
-  export const call_direct = "~lib/builtins/call_direct";
-  export const call_indirect = "~lib/builtins/call_indirect";
   export const instantiate = "~lib/builtins/instantiate";
   export const idof = "~lib/builtins/idof";
 
@@ -2309,60 +2307,6 @@ export function compileCall(
       if (!alreadyUnchecked) flow.unset(FlowFlags.UNCHECKED_CONTEXT);
       return expr;
     }
-    case BuiltinSymbols.call_direct:
-    case BuiltinSymbols.call_indirect: { // call_indirect<T?>(target: Function | u32, ...args: *[]) -> T
-      if (
-        checkTypeOptional(typeArguments, reportNode, compiler, true) |
-        checkArgsOptional(operands, 1, i32.MAX_VALUE, reportNode, compiler)
-      ) return module.unreachable();
-      let returnType = typeArguments ? typeArguments[0] : contextualType;
-      let arg0 = compiler.compileExpression(operands[0], Type.u32);
-      let arg0Type = compiler.currentType;
-      if (!(
-        arg0Type == Type.u32 ||                                      // either plain index
-        arg0Type.kind == TypeKind.U32 && arg0Type.signatureReference // or function reference
-      )) {
-        compiler.error(
-          DiagnosticCode.Type_0_is_not_a_function_index_or_function_reference,
-          operands[0].range, arg0Type.toString()
-        );
-        return module.unreachable();
-      }
-      let numOperands = operands.length - 1;
-      let operandExprs = new Array<ExpressionRef>(numOperands);
-      let nativeReturnType = returnType.toNativeType();
-      let parameterTypes = new Array<Type>(numOperands);
-      let nativeParamTypes = new Array<NativeType>(numOperands);
-      for (let i = 0; i < numOperands; ++i) {
-        operandExprs[i] = compiler.compileExpression(operands[1 + i], Type.i32);
-        let operandType = compiler.currentType;
-        parameterTypes[i] = operandType;
-        nativeParamTypes[i] = operandType.toNativeType();
-      }
-      let typeName = Signature.makeSignatureString(parameterTypes, returnType);
-      let typeRef = module.getFunctionTypeBySignature(nativeReturnType, nativeParamTypes);
-      if (!typeRef) typeRef = module.addFunctionType(typeName, nativeReturnType, nativeParamTypes);
-      compiler.currentType = returnType;
-      if (prototype.internalName == BuiltinSymbols.call_direct) {
-        // if the index expression is precomputable to a constant value, emit a direct call
-        if (getExpressionId(arg0 = module.precomputeExpression(arg0)) == ExpressionId.Const) {
-          assert(getExpressionType(arg0) == NativeType.I32);
-          let index = getConstValueI32(arg0);
-          let functionTable = compiler.functionTable;
-          if (index >= 0 && index < functionTable.length) {
-            return module.call(functionTable[index], operandExprs, nativeReturnType);
-          }
-        }
-        compiler.error(
-          DiagnosticCode.Expression_must_be_a_compile_time_constant,
-          operands[0].range
-        );
-        return module.unreachable();
-      }
-      // of course this can easily result in a 'RuntimeError: function signature mismatch' trap and
-      // thus must be used with care. it exists because it *might* be useful in specific scenarios.
-      return module.call_indirect(arg0, operandExprs, typeName);
-    }
     case BuiltinSymbols.instantiate: { // instantiate<T!>(...args: *[]) -> T
       if (
         checkTypeRequired(typeArguments, reportNode, compiler, true)

src/common.ts

@@ -70,8 +70,8 @@ export enum CommonFlags {
   TRAMPOLINE = 1 << 25,
   /** Is a virtual method. */
   VIRTUAL = 1 << 26,
-  /** Is the main function. */
-  MAIN = 1 << 27,
+  /** Is (part of) a closure. */
+  CLOSURE = 1 << 27,
 
   // Other