Merge remote-tracking branch 'origin/master' into release

Author: actions-user

cli/asc.js

@@ -224,6 +224,7 @@ exports.main = function main(argv, options, callback) {
   assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0);
   assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null);
   assemblyscript.setNoUnsafe(compilerOptions, args.noUnsafe);
+  assemblyscript.setPedantic(compilerOptions, args.pedantic);
 
   // Initialize default aliases
   assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath");

cli/asc.json

@@ -224,6 +224,11 @@
     "description": "Specifies the path to a custom transform to 'require'.",
     "type": "S"
   },
+  "pedantic": {
+    "description": "Make yourself sad for no good reason.",
+    "type": "b",
+    "default": false
+  },
   "traceResolution": {
     "description": "Enables tracing of package resolution.",
     "type": "b",

package-lock.json

@@ -8,7 +8,7 @@
     "assemblyscript",
     "wasm"
   ],
-  "version": "0.8.1",
+  "version": "0.9.0",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "contributors": [],
   "license": "Apache-2.0",
@@ -21,24 +21,23 @@
     "url": "https://github.com/AssemblyScript/assemblyscript/issues"
   },
   "dependencies": {
-    "binaryen": "90.0.0-nightly.20200101",
+    "binaryen": "90.0.0-nightly.20200111",
     "long": "^4.0.0",
     "source-map-support": "^0.5.16",
     "ts-node": "^6.2.0"
   },
   "devDependencies": {
-    "@types/node": "^12.12.17",
+    "@types/node": "^13.5.0",
     "browser-process-hrtime": "^1.0.0",
-    "diff": "^4.0.1",
+    "diff": "^4.0.2",
     "glob": "^7.1.6",
     "physical-cpu-count": "^2.0.0",
     "source-map-support": "^0.5.16",
     "ts-loader": "^6.2.1",
     "ts-node": "^6.2.0",
     "tslint": "^5.20.1",
-    "typedoc-plugin-external-module-name": "^2.1.0",
-    "typescript": "^3.7.3",
-    "webpack": "^4.41.3",
+    "typescript": "^3.7.5",
+    "webpack": "^4.41.5",
     "webpack-cli": "^3.3.10"
   },
   "main": "index.js",

package.json

@@ -63,7 +63,8 @@ import {
   Field,
   Global,
   DecoratorFlags,
-  Element
+  Element,
+  Class
 } from "./program";
 
 import {
@@ -4733,7 +4734,8 @@ export function compileVisitGlobals(compiler: Compiler): void {
   var nativeSizeType = compiler.options.nativeSizeType;
   var visitInstance = assert(compiler.program.visitInstance);
 
-  compiler.compileFunction(visitInstance);
+  // this function is @lazy: make sure it exists
+  compiler.compileFunction(visitInstance, true);
 
   for (let element of compiler.program.elementsByName.values()) {
     if (element.kind != ElementKind.GLOBAL) continue;
@@ -4794,6 +4796,9 @@ export function compileVisitMembers(compiler: Compiler): void {
   var blocks = new Array<RelooperBlockRef>();
   var relooper = Relooper.create(module);
 
+  // this function is @lazy: make sure it exists
+  compiler.compileFunction(visitInstance, true);
+
   var outer = relooper.addBlockWithSwitch(
     module.nop(),
     module.load(nativeSizeSize, false,

src/builtins.ts

@@ -210,6 +210,8 @@ export class Options {
   features: Feature = Feature.MUTABLE_GLOBALS;
   /** If true, disallows unsafe features in user code. */
   noUnsafe: bool = false;
+  /** If true, enables pedantic diagnostics. */
+  pedantic: bool = false;
 
   /** Hinted optimize level. Not applied by the compiler itself. */
   optimizeLevelHint: i32 = 0;
@@ -236,6 +238,11 @@ export class Options {
     return this.target == Target.WASM64 ? NativeType.I64 : NativeType.I32;
   }
 
+  /** Gets if any optimizations will be performed. */
+  get willOptimize(): bool {
+    return this.optimizeLevelHint > 0 || this.shrinkLevelHint > 0;
+  }
+
   /** Tests if a specific feature is activated. */
   hasFeature(feature: Feature): bool {
     return (this.features & feature) != 0;
@@ -322,6 +329,8 @@ export class Compiler extends DiagnosticEmitter {
   skippedAutoreleases: Set<ExpressionRef> = new Set();
   /** Current inline functions stack. */
   inlineStack: Function[] = [];
+  /** Lazily compiled library functions. */
+  lazyLibraryFunctions: Set<Function> = new Set();
 
   /** Compiles a {@link Program} to a {@link Module} using the specified options. */
   static compile(program: Program): Module {
@@ -387,7 +396,7 @@ export class Compiler extends DiagnosticEmitter {
       }
     }
 
-    // compile the start function if not empty or explicitly requested
+    // compile the start function if not empty or if explicitly requested
     var startIsEmpty = !startFunctionBody.length;
     var explicitStart = options.explicitStart;
     if (!startIsEmpty || explicitStart) {
@@ -414,11 +423,39 @@ export class Compiler extends DiagnosticEmitter {
       else module.addFunctionExport(startFunctionInstance.internalName, ExportNames.start);
     }
 
-    // compile runtime features
-    if (this.runtimeFeatures & RuntimeFeatures.visitGlobals) compileVisitGlobals(this);
-    if (this.runtimeFeatures & RuntimeFeatures.visitMembers) compileVisitMembers(this);
+    // check if the entire program is acyclic
+    var cyclicClasses = program.findCyclicClasses();
+    if (cyclicClasses.size) {
+      if (options.pedantic) {
+        for (let classInstance of cyclicClasses) {
+          this.info(
+            DiagnosticCode.Type_0_is_cyclic_Module_will_include_deferred_garbage_collection,
+            classInstance.identifierNode.range, classInstance.internalName
+          );
+        }
+      }
+    } else {
+      program.registerConstantInteger("__GC_ALL_ACYCLIC", Type.bool, i64_new(1, 0));
+    }
+
+    // compile lazy library functions
+    var lazyLibraryFunctions = this.lazyLibraryFunctions;
+    do {
+      let functionsToCompile = new Array<Function>();
+      for (let instance of lazyLibraryFunctions) {
+        functionsToCompile.push(instance);
+      }
+      lazyLibraryFunctions.clear();
+      for (let i = 0, k = functionsToCompile.length; i < k; ++i) {
+        this.compileFunction(unchecked(functionsToCompile[i]), true);
+      }
+    } while (lazyLibraryFunctions.size);
+
+    // finalize runtime features
     module.removeGlobal(BuiltinNames.rtti_base);
     if (this.runtimeFeatures & RuntimeFeatures.RTTI) compileRTTI(this);
+    if (this.runtimeFeatures & RuntimeFeatures.visitGlobals) compileVisitGlobals(this);
+    if (this.runtimeFeatures & RuntimeFeatures.visitMembers) compileVisitMembers(this);
 
     // update the heap base pointer
     var memoryOffset = this.memoryOffset;
@@ -464,8 +501,24 @@ export class Compiler extends DiagnosticEmitter {
     module.setFunctionTable(1 + functionTable.length, Module.UNLIMITED_TABLE, functionTable, module.i32(1));
 
     // import and/or export table if requested (default table is named '0' by Binaryen)
-    if (options.importTable) module.addTableImport("0", "env", "table");
-    if (options.exportTable) module.addTableExport("0", ExportNames.table);
+    if (options.importTable) {
+      module.addTableImport("0", "env", "table");
+      if (options.pedantic && options.willOptimize) {
+        this.warning(
+          DiagnosticCode.Importing_the_table_disables_some_indirect_call_optimizations,
+          null
+        );
+      }
+    }
+    if (options.exportTable) {
+      module.addTableExport("0", ExportNames.table);
+      if (options.pedantic && options.willOptimize) {
+        this.warning(
+          DiagnosticCode.Exporting_the_table_disables_some_indirect_call_optimizations,
+          null
+        );
+      }
+    }
 
     // set up module exports
     for (let file of this.program.filesByName.values()) {
@@ -1101,11 +1154,15 @@ export class Compiler extends DiagnosticEmitter {
     forceStdAlternative: bool = false
   ): bool {
     if (instance.is(CommonFlags.COMPILED)) return true;
-    if (instance.hasDecorator(DecoratorFlags.BUILTIN)) {
-      if (!forceStdAlternative) return true;
+    if (!forceStdAlternative) {
+      if (instance.hasDecorator(DecoratorFlags.BUILTIN)) return true;
+      if (instance.hasDecorator(DecoratorFlags.LAZY)) {
+        this.lazyLibraryFunctions.add(instance);
+        return true;
+      }
     }
 
-    var previousType = this.currentType; // remember to retain it if compiling a function lazily
+    var previousType = this.currentType;
     instance.set(CommonFlags.COMPILED);
 
     var module = this.module;

src/compiler.ts

@@ -37,6 +37,9 @@ export enum DiagnosticCode {
   _0_must_be_a_power_of_two = 223,
   _0_is_not_a_valid_operator = 224,
   Expression_cannot_be_represented_by_a_type = 225,
+  Type_0_is_cyclic_Module_will_include_deferred_garbage_collection = 900,
+  Importing_the_table_disables_some_indirect_call_optimizations = 901,
+  Exporting_the_table_disables_some_indirect_call_optimizations = 902,
   Unterminated_string_literal = 1002,
   Identifier_expected = 1003,
   _0_expected = 1005,
@@ -181,6 +184,9 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 223: return "'{0}' must be a power of two.";
     case 224: return "'{0}' is not a valid operator.";
     case 225: return "Expression cannot be represented by a type.";
+    case 900: return "Type '{0}' is cyclic. Module will include deferred garbage collection.";
+    case 901: return "Importing the table disables some indirect call optimizations.";
+    case 902: return "Exporting the table disables some indirect call optimizations.";
     case 1002: return "Unterminated string literal.";
     case 1003: return "Identifier expected.";
     case 1005: return "'{0}' expected.";

src/diagnosticMessages.generated.ts

@@ -31,6 +31,10 @@
   "'{0}' is not a valid operator.": 224,
   "Expression cannot be represented by a type.": 225,
 
+  "Type '{0}' is cyclic. Module will include deferred garbage collection.": 900,
+  "Importing the table disables some indirect call optimizations.": 901,
+  "Exporting the table disables some indirect call optimizations.": 902,
+
   "Unterminated string literal.": 1002,
   "Identifier expected.": 1003,
   "'{0}' expected.": 1005,