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

Author: actions-user

bin/asinit

@@ -249,8 +249,8 @@ function ensureGitignore() {
 function ensurePackageJson() {
   console.log("- Making sure that 'package.json' contains the build commands...")
   const entryPath = path.relative(projectDir, entryFile).replace(/\\/g, "/");
-  const buildUntouched = "asc " + entryPath + " -b build/untouched.wasm -t build/untouched.wat --validate --sourceMap --debug";
-  const buildOptimized = "asc " + entryPath + " -b build/optimized.wasm -t build/optimized.wat --validate --sourceMap --optimize";
+  const buildUntouched = "asc " + entryPath + " -b build/untouched.wasm -t build/untouched.wat --sourceMap --debug";
+  const buildOptimized = "asc " + entryPath + " -b build/optimized.wasm -t build/optimized.wat --sourceMap --optimize";
   const buildAll = "npm run asbuild:untouched && npm run asbuild:optimized";
   if (!fs.existsSync(packageFile)) {
     fs.writeFileSync(packageFile, JSON.stringify({

cli/asc.d.ts

@@ -69,8 +69,6 @@ interface CompilerOptions {
   shrinkLevel?: number;
   /** Re-optimizes until no further improvements can be made. */
   converge?: boolean;
-  /** Validates the module using Binaryen. Exits if invalid. */
-  validate?: boolean;
   /** Specifies the base directory of input and output files. */
   baseDir?: string;
   /** Specifies the output file. File extension indicates format. */
@@ -119,6 +117,8 @@ interface CompilerOptions {
   trapMode?: "allow" | "clamp" | "js";
   /** Specifies additional Binaryen passes to run. */
   runPasses?: string | string[];
+  /** Skips validating the module using Binaryen. */
+  noValidate?: boolean;
   /** Enables WebAssembly features that are disabled by default. */
   enable?: string | string[];
   /** Disables WebAssembly features that are enabled by default. */

cli/asc.js

@@ -638,7 +638,7 @@ exports.main = function main(argv, options, callback) {
   }
 
   // Validate the module if requested
-  if (args.validate) {
+  if (!args.noValidate) {
     stats.validateCount++;
     stats.validateTime += measure(() => {
       if (!module.validate()) {

cli/asc.json

@@ -218,13 +218,6 @@
     "type": "S"
   },
 
-  "validate": {
-    "category": "Binaryen",
-    "description": "Validates the module using Binaryen. Exits if invalid.",
-    "type": "b",
-    "alias": "c",
-    "default": false
-  },
   "trapMode": {
     "category": "Binaryen",
     "description": [
@@ -246,6 +239,13 @@
     ],
     "type": "s"
   },
+  "noValidate": {
+    "category": "Binaryen",
+    "description": "Skips validating the module using Binaryen.",
+    "type": "b",
+    "alias": "c",
+    "default": false
+  },
 
   "baseDir": {
     "description": "Specifies the base directory of input and output files.",

lib/parse/package.json

@@ -5,7 +5,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "asbuild": "asc assembly/index.ts -O3 -b build/index.wasm -t build/index.wat --importMemory --runtime none --sourceMap --validate",
+    "asbuild": "asc assembly/index.ts -O3 -b build/index.wasm -t build/index.wat --importMemory --runtime none --sourceMap",
     "build": "npm run asbuild && webpack --mode production --display-modules",
     "test": "ts-node tests/"
   },

lib/webpack/index.js

@@ -23,7 +23,6 @@ function compile() {
     "--baseDir", path.dirname(this.resourcePath),
     "--binaryFile", basePath + ".wasm",
     "--textFile", basePath + ".wat",
-    "--validate",
     "--optimize"
   ];
   if (this.sourceMap)

package.json

@@ -66,8 +66,8 @@
     "prepublishOnly": "node scripts/prepublish",
     "postpublish": "node scripts/postpublish",
     "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
-    "asbuild:untouched": "node bin/asc src/glue/wasm/index.ts src/index.ts -t out/assemblyscript.untouched.wat -b out/assemblyscript.untouched.wasm -d out/assemblyscript.d.ts --validate --debug --measure --runtime stub",
-    "asbuild:optimized": "node bin/asc src/glue/wasm/index.ts src/index.ts -t out/assemblyscript.optimized.wat -b out/assemblyscript.optimized.wasm -O3 --validate --measure --runtime stub",
+    "asbuild:untouched": "node bin/asc src/glue/wasm/index.ts src/index.ts -t out/assemblyscript.untouched.wat -b out/assemblyscript.untouched.wasm -d out/assemblyscript.d.ts --debug --measure --runtime stub",
+    "asbuild:optimized": "node bin/asc src/glue/wasm/index.ts src/index.ts -t out/assemblyscript.optimized.wat -b out/assemblyscript.optimized.wasm -O3 --measure --runtime stub",
     "astest": "ts-node tests/bootstrap"
   },
   "releaseFiles": [

src/ast.ts

@@ -1304,7 +1304,7 @@ export enum DecoratorKind {
   OPERATOR_PREFIX,
   OPERATOR_POSTFIX,
   UNMANAGED,
-  SEALED,
+  FINAL,
   INLINE,
   EXTERNAL,
   BUILTIN,
@@ -1316,7 +1316,6 @@ export namespace DecoratorKind {
 
   /** Returns the kind of the specified decorator name node. Defaults to {@link DecoratorKind.CUSTOM}. */
   export function fromNode(nameNode: Expression): DecoratorKind {
-    // @global, @inline, @operator, @sealed, @unmanaged
     if (nameNode.kind == NodeKind.IDENTIFIER) {
       let nameStr = (<IdentifierExpression>nameNode).text;
       assert(nameStr.length);
@@ -1329,6 +1328,10 @@ export namespace DecoratorKind {
           if (nameStr == "external") return DecoratorKind.EXTERNAL;
           break;
         }
+        case CharCode.f: {
+          if (nameStr == "final") return DecoratorKind.FINAL;
+          break;
+        }
         case CharCode.g: {
           if (nameStr == "global") return DecoratorKind.GLOBAL;
           break;
@@ -1345,10 +1348,6 @@ export namespace DecoratorKind {
           if (nameStr == "operator") return DecoratorKind.OPERATOR;
           break;
         }
-        case CharCode.s: {
-          if (nameStr == "sealed") return DecoratorKind.SEALED;
-          break;
-        }
         case CharCode.u: {
           if (nameStr == "unmanaged") return DecoratorKind.UNMANAGED;
           if (nameStr == "unsafe") return DecoratorKind.UNSAFE;
@@ -1363,7 +1362,6 @@ export namespace DecoratorKind {
         assert(nameStr.length);
         let propStr = propertyAccessNode.property.text;
         assert(propStr.length);
-        // @operator.binary, @operator.prefix, @operator.postfix
         if (nameStr == "operator") {
           switch (propStr.charCodeAt(0)) {
             case CharCode.b: {

src/compiler.ts

@@ -1307,7 +1307,13 @@ export class Compiler extends DiagnosticEmitter {
       let index = 0;
       let thisType = signature.thisType;
       if (thisType) {
-        // No need to retain `this` as it can't be reassigned and thus can't become prematurely released
+        // In normal instance functions, `this` is effectively a constant
+        // retained elsewhere so does not need to be retained.
+        if (instance.is(CommonFlags.CONSTRUCTOR)) {
+          // Constructors, however, can allocate their own memory, and as such
+          // must refcount the allocation in case something else is `return`ed.
+          flow.setLocalFlag(index, LocalFlags.RETAINED);
+        }
         ++index;
       }
       let parameterTypes = signature.parameterTypes;
@@ -1343,7 +1349,7 @@ export class Compiler extends DiagnosticEmitter {
         signature.nativeParams,
         signature.nativeResults,
         typesToNativeTypes(instance.additionalLocals),
-        module.flatten(stmts, instance.signature.returnType.toNativeType())
+        body
       );
 
     // imported function
@@ -1392,6 +1398,9 @@ export class Compiler extends DiagnosticEmitter {
     var bodyNode = assert(instance.prototype.bodyNode);
     var returnType = instance.signature.returnType;
     var flow = this.currentFlow;
+    var thisLocal = instance.is(CommonFlags.INSTANCE)
+      ? assert(flow.lookupLocal(CommonNames.this_))
+      : null;
 
     // compile statements
     if (bodyNode.kind == NodeKind.BLOCK) {
@@ -1432,39 +1441,66 @@ export class Compiler extends DiagnosticEmitter {
       }
     }
 
-    // make constructors return their instance pointer
+    // Make constructors return their instance pointer, and prepend a conditional
+    // allocation if any code path accesses `this`.
     if (instance.is(CommonFlags.CONSTRUCTOR)) {
       let nativeSizeType = this.options.nativeSizeType;
       assert(instance.is(CommonFlags.INSTANCE));
+      thisLocal = assert(thisLocal);
       let parent = assert(instance.parent);
       assert(parent.kind == ElementKind.CLASS);
       let classInstance = <Class>parent;
 
-      if (!flow.is(FlowFlags.TERMINATES)) {
-        let thisLocal = assert(flow.lookupLocal(CommonNames.this_));
-
-        // if `this` wasn't accessed before, allocate if necessary and initialize `this`
-        if (!flow.is(FlowFlags.ALLOCATES)) {
-          // {
-          //   if (!this) this = <ALLOC>
-          //   this.a = X
-          //   this.b = Y
-          // }
-          stmts.push(
-            module.if(
-              module.unary(nativeSizeType == NativeType.I64 ? UnaryOp.EqzI64 : UnaryOp.EqzI32,
-                module.local_get(thisLocal.index, nativeSizeType)
-              ),
-              module.local_set(thisLocal.index,
-                this.makeRetain(
-                  this.makeAllocation(classInstance)
-                ),
+      if (flow.isAny(FlowFlags.ACCESSES_THIS | FlowFlags.CONDITIONALLY_ACCESSES_THIS) || !flow.is(FlowFlags.TERMINATES)) {
+        // Allocate `this` if not a super call, and initialize fields
+        let allocStmts = new Array<ExpressionRef>();
+        allocStmts.push(
+          module.if(
+            module.unary(nativeSizeType == NativeType.I64 ? UnaryOp.EqzI64 : UnaryOp.EqzI32,
+              module.local_get(thisLocal.index, nativeSizeType)
+            ),
+            module.local_set(thisLocal.index,
+              this.makeRetain(
+                this.makeAllocation(classInstance)
               )
             )
+          )
+        );
+        this.makeFieldInitializationInConstructor(classInstance, allocStmts);
+        if (flow.isInline) {
+          let firstStmt = stmts[0]; // `this` alias assignment
+          assert(getExpressionId(firstStmt) == ExpressionId.LocalSet);
+          assert(getLocalSetIndex(firstStmt) == thisLocal.index);
+          allocStmts.unshift(firstStmt);
+          stmts[0] = module.flatten(allocStmts, NativeType.None);
+        } else {
+          stmts.unshift(
+            module.flatten(allocStmts, NativeType.None)
           );
-          this.makeFieldInitializationInConstructor(classInstance, stmts);
         }
-        this.performAutoreleases(flow, stmts); // `this` is excluded anyway
+
+        // Just prepended allocation is dropped when returning non-'this'
+        if (flow.is(FlowFlags.MAY_RETURN_NONTHIS)) {
+          this.pedantic(
+            DiagnosticCode.Explicitly_returning_constructor_drops_this_allocation,
+            instance.identifierNode.range
+          );
+        }
+      }
+
+      // Returning something else than 'this' would break 'super()' calls
+      if (flow.is(FlowFlags.MAY_RETURN_NONTHIS) && !classInstance.hasDecorator(DecoratorFlags.FINAL)) {
+        this.error(
+          DiagnosticCode.A_class_with_a_constructor_explicitly_returning_something_else_than_this_must_be_final,
+          classInstance.identifierNode.range
+        );
+      }
+
+      // Implicitly return `this` if the flow falls through
+      if (!flow.is(FlowFlags.TERMINATES)) {
+        assert(flow.isAnyLocalFlag(thisLocal.index, LocalFlags.ANY_RETAINED));
+        flow.unsetLocalFlag(thisLocal.index, LocalFlags.ANY_RETAINED); // undo
+        this.performAutoreleases(flow, stmts);
         this.finishAutoreleases(flow, stmts);
         stmts.push(module.local_get(thisLocal.index, this.options.nativeSizeType));
         flow.set(FlowFlags.RETURNS | FlowFlags.RETURNS_NONNULL | FlowFlags.TERMINATES);
@@ -2623,6 +2659,9 @@ export class Compiler extends DiagnosticEmitter {
 
       // take special care of properly retaining the returned value
       expr = this.compileReturnedExpression(valueExpression, returnType, constraints);
+      if (flow.actualFunction.is(CommonFlags.CONSTRUCTOR) && valueExpression.kind != NodeKind.THIS) {
+        flow.set(FlowFlags.MAY_RETURN_NONTHIS);
+      }
     } else if (returnType != Type.void) {
       this.error(
         DiagnosticCode.Type_0_is_not_assignable_to_type_1,
@@ -6322,44 +6361,29 @@ export class Compiler extends DiagnosticEmitter {
       let thisLocal = assert(flow.lookupLocal(CommonNames.this_));
       let nativeSizeType = this.options.nativeSizeType;
 
-      // {
-      //   this = super(this || <ALLOC>, ...args)
-      //   this.a = X
-      //   this.b = Y
-      // }
-      let theCall = this.compileCallDirect(
+      let superCall = this.compileCallDirect(
         this.ensureConstructor(baseClassInstance, expression),
         expression.arguments,
         expression,
-        module.if(
-          module.local_get(thisLocal.index, nativeSizeType),
-          module.local_get(thisLocal.index, nativeSizeType),
-          this.makeRetain(
-            this.makeAllocation(classInstance)
-          )
-        ),
+        module.local_get(thisLocal.index, nativeSizeType),
         Constraints.WILL_RETAIN
       );
-      assert(baseClassInstance.type.isUnmanaged || this.skippedAutoreleases.has(theCall)); // guaranteed
-      let stmts: ExpressionRef[] = [
-        module.local_set(thisLocal.index, theCall)
-      ];
-      this.makeFieldInitializationInConstructor(classInstance, stmts);
+      assert(baseClassInstance.type.isUnmanaged || this.skippedAutoreleases.has(superCall)); // guaranteed
 
       // check that super had been called before accessing `this`
       if (flow.isAny(
-        FlowFlags.ALLOCATES |
-        FlowFlags.CONDITIONALLY_ALLOCATES
+        FlowFlags.ACCESSES_THIS |
+        FlowFlags.CONDITIONALLY_ACCESSES_THIS
       )) {
         this.error(
           DiagnosticCode._super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class,
           expression.range
         );
         return module.unreachable();
       }
-      flow.set(FlowFlags.ALLOCATES | FlowFlags.CALLS_SUPER);
+      flow.set(FlowFlags.ACCESSES_THIS | FlowFlags.CALLS_SUPER);
       this.currentType = Type.void;
-      return module.flatten(stmts);
+      return module.local_set(thisLocal.index, superCall);
     }
 
     // otherwise resolve normally
@@ -6774,7 +6798,13 @@ export class Compiler extends DiagnosticEmitter {
       let classInstance = <Class>parent;
       let thisType = assert(instance.signature.thisType);
       let thisLocal = flow.addScopedLocal(CommonNames.this_, thisType, usedLocals);
-      // No need to retain `this` as it can't be reassigned and thus can't become prematurely released
+      // In normal instance functions, `this` is effectively a constant
+      // retained elsewhere so does not need to be retained.
+      if (instance.is(CommonFlags.CONSTRUCTOR)) {
+        // Constructors, however, can allocate their own memory, and as such
+        // must refcount the allocation in case something else is `return`ed.
+        flow.setLocalFlag(thisLocal.index, LocalFlags.RETAINED);
+      }
       body.unshift(
         module.local_set(thisLocal.index, thisArg)
       );
@@ -7986,41 +8016,10 @@ export class Compiler extends DiagnosticEmitter {
       case NodeKind.THIS: {
         if (actualFunction.is(CommonFlags.INSTANCE)) {
           let thisLocal = assert(flow.lookupLocal(CommonNames.this_));
+          let thisType = assert(actualFunction.signature.thisType);
           let parent = assert(actualFunction.parent);
           assert(parent.kind == ElementKind.CLASS);
-          let classInstance = <Class>parent;
-          let nativeSizeType = this.options.nativeSizeType;
-          if (actualFunction.is(CommonFlags.CONSTRUCTOR)) {
-            if (!flow.is(FlowFlags.ALLOCATES)) {
-              flow.set(FlowFlags.ALLOCATES);
-              // {
-              //   if (!this) this = <ALLOC>
-              //   this.a = X
-              //   this.b = Y
-              //   return this
-              // }
-              let stmts: ExpressionRef[] = [
-                module.if(
-                  module.unary(nativeSizeType == NativeType.I64 ? UnaryOp.EqzI64 : UnaryOp.EqzI32,
-                    module.local_get(thisLocal.index, nativeSizeType)
-                  ),
-                  module.local_set(thisLocal.index,
-                    this.makeRetain(
-                      this.makeAllocation(classInstance)
-                    )
-                  )
-                )
-              ];
-              this.makeFieldInitializationInConstructor(classInstance, stmts);
-              stmts.push(
-                module.local_get(thisLocal.index, nativeSizeType)
-              );
-              this.currentType = thisLocal.type;
-              return module.flatten(stmts, nativeSizeType);
-            }
-          }
-          // if not a constructor, `this` type can differ
-          let thisType = assert(actualFunction.signature.thisType);
+          flow.set(FlowFlags.ACCESSES_THIS);
           this.currentType = thisType;
           return module.local_get(thisLocal.index, thisType.toNativeType());
         }