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

Author: actions-user

src/compiler.ts

@@ -1440,17 +1440,37 @@ export class Compiler extends DiagnosticEmitter {
     var nativeThisType = this.options.nativeSizeType;
     var nativeValueType = type.toNativeType();
     var module = this.module;
-    var valueExpr = module.local_get(1, nativeValueType);
+    var valueExpr: ExpressionRef;
+    var varTypes: NativeType[] | null = null;
     if (type.isManaged) {
-      valueExpr = this.makeReplace(
-        module.load(type.byteSize, false,
-          module.local_get(0, nativeThisType),
-          nativeValueType, instance.memoryOffset
+      // Can't use makeReplace here since there's no corresponding flow, so
+      // 0: this, 1: value, 2: oldValue (temp)
+      valueExpr = module.block(null, [
+        module.if(
+          module.binary(nativeValueType == NativeType.I64 ? BinaryOp.NeI64 : BinaryOp.NeI32,
+            // value != (oldValue = this.field)
+            module.local_get(1, nativeValueType),
+            module.local_tee(2,
+              module.load(type.byteSize, false,
+                module.local_get(0, nativeThisType),
+                nativeValueType, instance.memoryOffset
+              )
+            )
+          ),
+          module.block(null, [
+            module.drop(
+              this.makeRetain(module.local_get(1, nativeValueType))
+            ),
+            this.makeRelease(module.local_get(2, nativeValueType))
+          ])
         ),
-        valueExpr
-      );
+        module.local_get(1, nativeValueType)
+      ], nativeValueType);
+      varTypes = [ nativeValueType ];
+    } else {
+      valueExpr = module.local_get(1, nativeValueType);
     }
-    instance.setterRef = module.addFunction(instance.internalSetterName, createType([ nativeThisType, nativeValueType ]), NativeType.None, null,
+    instance.setterRef = module.addFunction(instance.internalSetterName, createType([ nativeThisType, nativeValueType ]), NativeType.None, varTypes,
       module.store(type.byteSize,
         module.local_get(0, nativeThisType),
         valueExpr,
@@ -2652,7 +2672,7 @@ export class Compiler extends DiagnosticEmitter {
         type = resolver.resolveType( // reports
           declaration.type,
           flow.actualFunction,
-          flow.contextualTypeArguments
+          makeMap(flow.contextualTypeArguments)
         );
         if (!type) continue;
         if (declaration.initializer) {
@@ -3444,7 +3464,7 @@ export class Compiler extends DiagnosticEmitter {
         let toType = this.resolver.resolveType( // reports
           assert(expression.toType),
           flow.actualFunction,
-          flow.contextualTypeArguments
+          makeMap(flow.contextualTypeArguments)
         );
         if (!toType) return this.module.unreachable();
         return this.compileExpression(expression.expression, toType, inheritedConstraints | Constraints.CONV_EXPLICIT);
@@ -6702,7 +6722,14 @@ export class Compiler extends DiagnosticEmitter {
   }
 
   /** Makes a replace, retaining the new expression's value and releasing the old expression's value, in this order. */
-  makeReplace(oldExpr: ExpressionRef, newExpr: ExpressionRef, alreadyRetained: bool = false): ExpressionRef {
+  makeReplace(
+    /** Old value being replaced. */
+    oldExpr: ExpressionRef,
+    /** New value being assigned. */
+    newExpr: ExpressionRef,
+    /** Whether the new value is already retained. */
+    alreadyRetained: bool = false,
+  ): ExpressionRef {
     var module = this.module;
     var flow = this.currentFlow;
     var nativeSizeType = this.options.nativeSizeType;
@@ -7644,9 +7671,14 @@ export class Compiler extends DiagnosticEmitter {
     // time of implementation, this seemed more useful because dynamic rhs expressions are not
     // possible in AS anyway. also note that the code generated below must preserve side-effects of
     // the LHS expression even when the result is a constant, i.e. return a block dropping `expr`.
+    var flow = this.currentFlow;
     var expr = this.compileExpression(expression.expression, this.options.usizeType);
     var actualType = this.currentType;
-    var expectedType = this.resolver.resolveType(expression.isType, this.currentFlow.actualFunction);
+    var expectedType = this.resolver.resolveType(
+      expression.isType,
+      flow.actualFunction,
+      makeMap(flow.contextualTypeArguments)
+    );
     this.currentType = Type.bool;
     if (!expectedType) return module.unreachable();
 
@@ -7687,7 +7719,6 @@ export class Compiler extends DiagnosticEmitter {
       if (expectedType.isAssignableTo(actualType)) {
         let program = this.program;
         if (!(actualType.isUnmanaged || expectedType.isUnmanaged)) {
-          let flow = this.currentFlow;
           let temp = flow.getTempLocal(actualType);
           let instanceofInstance = assert(program.instanceofInstance);
           this.compileFunction(instanceofInstance);
@@ -7737,7 +7768,6 @@ export class Compiler extends DiagnosticEmitter {
           // FIXME: the temp local and the if can be removed here once flows
           // perform null checking, which would error earlier when checking
           // uninitialized (thus zero) `var a: A` to be an instance of something.
-          let flow = this.currentFlow;
           let temp = flow.getTempLocal(actualType);
           let instanceofInstance = assert(program.instanceofInstance);
           this.compileFunction(instanceofInstance);

std/assembly/index.d.ts

@@ -1535,7 +1535,7 @@ interface RegExp {}
 declare class Map<K,V> {
   readonly size: i32;
   has(key: K): bool;
-  set(key: K, value: V): void;
+  set(key: K, value: V): this;
   get(key: K): V;
   delete(key: K): bool;
   clear(): void;
@@ -1547,7 +1547,7 @@ declare class Map<K,V> {
 declare class Set<K> {
   readonly size: i32;
   has(value: K): bool;
-  add(value: K): void;
+  add(value: K): this;
   delete(value: K): bool;
   clear(): void;
   values(): K[]; // preliminary

std/assembly/map.ts

@@ -113,7 +113,7 @@ export class Map<K,V> {
   }
 
   @operator("[]=")
-  set(key: K, value: V): void {
+  set(key: K, value: V): this {
     var hashCode = HASH<K>(key);
     var entry = this.find(key, hashCode); // unmanaged!
     if (entry) {
@@ -151,6 +151,7 @@ export class Map<K,V> {
       entry.taggedNext = load<usize>(bucketPtrBase);
       store<usize>(bucketPtrBase, changetype<usize>(entry));
     }
+    return this;
   }
 
   delete(key: K): bool {

std/assembly/set.ts

@@ -101,7 +101,7 @@ export class Set<T> {
     return this.find(key, HASH<T>(key)) !== null;
   }
 
-  add(key: T): void {
+  add(key: T): this {
     var hashCode = HASH<T>(key);
     var entry = this.find(key, hashCode); // unmanaged!
     if (!entry) {
@@ -124,6 +124,7 @@ export class Set<T> {
       entry.taggedNext = load<usize>(bucketPtrBase);
       store<usize>(bucketPtrBase, changetype<usize>(entry));
     }
+    return this;
   }
 
   @operator("[]=")

tests/compiler/extends-recursive.optimized.wat

@@ -12,13 +12,11 @@
   i32.load
  )
  (func $extends-recursive/Parent#set:child (; 1 ;) (param $0 i32) (param $1 i32)
-  (local $2 i32)
   local.get $0
-  local.get $1
-  local.tee $0
   i32.load
   drop
   local.get $0
+  local.get $1
   i32.store
  )
 )

tests/compiler/extends-recursive.untouched.wat

@@ -21,21 +21,21 @@
   nop
  )
  (func $extends-recursive/Parent#set:child (; 3 ;) (param $0 i32) (param $1 i32)
+  (local $2 i32)
   local.get $0
   local.get $1
-  local.tee $0
   local.get $0
   i32.load
-  local.tee $1
+  local.tee $2
   i32.ne
   if
-   local.get $0
-   call $~lib/rt/stub/__retain
-   local.set $0
    local.get $1
+   call $~lib/rt/stub/__retain
+   drop
+   local.get $2
    call $~lib/rt/stub/__release
   end
-  local.get $0
+  local.get $1
   i32.store
  )
 )

tests/compiler/implicit-getter-setter.js

@@ -0,0 +1,41 @@
+exports.postInstantiate = function(instance) {
+  const exports = instance.exports;
+  
+  // using an integer value
+  var basic = exports["Basic#constructor"](0, 123); // retain $0
+  (() => {
+    var val = exports["Basic#get:val"](basic);
+    if (val != 123) throw Error("invalid value");
+    exports["Basic#set:val"](basic, 42);
+    val = exports["Basic#get:val"](basic);
+    if (val != 42) throw Error("invalid value");
+  })();
+
+  // using a managed value
+  var managed = exports["Managed#constructor"](0, basic); // retain $1
+  (() => {
+    var foo = exports["Managed#get:foo"](managed); // retain $2
+    if (foo != basic) throw Error("invalid value");
+    exports.__release(foo); // release $2
+  })();
+  (() => {
+    var foo = exports["Basic#constructor"](0, 321); // retain $3
+    exports["Managed#set:foo"](managed, foo);
+    exports.__release(foo); // release $3
+    var expectedFoo = foo;
+    foo = exports["Managed#get:foo"](managed); // retain $4
+    if (foo != expectedFoo) throw Error("invalid value");
+    exports.__release(foo); // releae $4
+  })();
+
+  // combining both
+  (() => {
+    var foo = exports["Managed#get:foo"](managed); // retain $5
+    var val = exports["Basic#get:val"](foo);
+    if (val != 321) throw Error("invalid value");
+    exports.__release(foo); // release $5
+  })();
+
+  exports.__release(basic); // release $0
+  exports.__release(managed); // release $1
+};

tests/compiler/implicit-getter-setter.json

@@ -0,0 +1,6 @@
+{
+  "asc_flags": [
+    "--runtime full",
+    "--use ASC_RTRACE=1"
+  ]
+}