fix: return the assigned value in assignments (#2773)

Fixes #2770.

Author: HerrCai0907

src/compiler.ts

@@ -5703,10 +5703,11 @@ export class Compiler extends DiagnosticEmitter {
     assert(targetType != Type.void);
     let valueExpr = this.compileExpression(valueExpression, targetType);
     let valueType = this.currentType;
+    if (targetType.isNullableReference && this.currentFlow.isNonnull(valueExpr, valueType)) targetType = targetType.nonNullableType;
     return this.makeAssignment(
       target,
       this.convertExpression(valueExpr, valueType, targetType, false, valueExpression),
-      valueType,
+      targetType,
       valueExpression,
       thisExpression,
       elementExpression,
@@ -5799,6 +5800,7 @@ export class Compiler extends DiagnosticEmitter {
           return module.unreachable();
         }
         assert(setterInstance.signature.parameterTypes.length == 1);
+        assert(setterInstance.signature.returnType == Type.void);
         if (propertyInstance.is(CommonFlags.Instance)) {
           let thisType = assert(setterInstance.signature.thisType);
           let thisExpr = this.compileExpression(
@@ -5807,28 +5809,29 @@ export class Compiler extends DiagnosticEmitter {
             Constraints.ConvImplicit | Constraints.IsThis
           );
           if (!tee) return this.makeCallDirect(setterInstance, [ thisExpr, valueExpr ], valueExpression);
-          let getterInstance = assert((<Property>target).getterInstance);
-          assert(getterInstance.signature.thisType == thisType);
-          let returnType = getterInstance.signature.returnType;
-          let returnTypeRef = returnType.toRef();
-          let tempThis = flow.getTempLocal(thisType);
+          let tempLocal = flow.getTempLocal(valueType);
+          let valueTypeRef = valueType.toRef();
           let ret = module.block(null, [
             this.makeCallDirect(setterInstance, [
-              module.local_tee(tempThis.index, thisExpr, /* isManaged=*/false, thisType.toRef()), // thisType is managed but here it must be alive
-              valueExpr
+              thisExpr,
+              module.local_tee(tempLocal.index, valueExpr, valueType.isManaged, valueTypeRef)
             ], valueExpression),
-            this.makeCallDirect(getterInstance, [
-              module.local_get(tempThis.index, thisType.toRef())
-            ], valueExpression)
-          ], returnTypeRef);
+            module.local_get(tempLocal.index, valueTypeRef),
+          ], valueTypeRef);
+          this.currentType = valueType;
           return ret;
         } else {
           if (!tee) return this.makeCallDirect(setterInstance, [ valueExpr ], valueExpression);
-          let getterInstance = assert((<Property>target).getterInstance);
-          return module.block(null, [
-            this.makeCallDirect(setterInstance, [ valueExpr ], valueExpression),
-            this.makeCallDirect(getterInstance, null, valueExpression)
-          ], getterInstance.signature.returnType.toRef());
+          let tempLocal = flow.getTempLocal(valueType);
+          let valueTypeRef = valueType.toRef();
+          let ret = module.block(null, [
+            this.makeCallDirect(setterInstance, [
+              module.local_tee(tempLocal.index, valueExpr, valueType.isManaged, valueTypeRef),
+            ], valueExpression),
+            module.local_get(tempLocal.index, valueTypeRef),
+          ], valueTypeRef);
+          this.currentType = valueType;
+          return ret;
         }
       }
       case ElementKind.IndexSignature: {

tests/compiler/assignment-chain.debug.wat

@@ -3,6 +3,45 @@ class A {
   y: i64 = 0;
 }
 
-export function foo(a: A): void {
-  a.x = a.y = 1;
+export function normal_assignment_chain(): void {
+  let x = new A();
+  let cnt = 0;
+  x.x = x.y = cnt++;
+  assert(cnt == 1); // `cnt++` should be executed only once
 }
+normal_assignment_chain();
+
+class B {
+  _setter_cnt: i32 = 0;
+  _getter_cnt: i32 = 0;
+  _y: f64 = 0.0;
+  set y(z: f64) {
+    this._setter_cnt += 1;
+    this._y = z;
+  }
+  get y(): f64 {
+    this._getter_cnt += 1;
+    return this._y;
+  }
+}
+export function setter_assignment_chain(): void {
+  let x = new B();
+  x.y = x.y = 1;
+  assert(x._setter_cnt == 2);
+  assert(x._getter_cnt == 0); // should not use getter method
+}
+setter_assignment_chain();
+
+class C {
+  static _setter_cnt: i32 = 0;
+  static _y: f64 = 0.0;
+  static set y(z: f64) {
+    C._setter_cnt += 1;
+    C._y = z;
+  }
+}
+export function static_setter_assignment_chain(): void {
+  C.y = C.y = 1;
+  assert(C._setter_cnt == 2);
+}
+static_setter_assignment_chain();

tests/compiler/assignment-chain.release.wat

@@ -23,6 +23,7 @@
   global.set $getter-setter/Foo._bar
  )
  (func $start:getter-setter
+  (local $0 i32)
   call $getter-setter/Foo.get:bar
   i32.const 0
   i32.eq
@@ -50,8 +51,9 @@
    unreachable
   end
   i32.const 2
+  local.tee $0
   call $getter-setter/Foo.set:bar
-  call $getter-setter/Foo.get:bar
+  local.get $0
   i32.const 2
   i32.eq
   i32.eqz