[MERGE #4670 @sethbrenith] Return correct value from super(). Fixes #4663

Merge pull request #4670 from sethbrenith:user/sethb/super-return

Return correct value from super(). Fixes #4663

Author: sethbrenith

lib/Runtime/ByteCode/ByteCodeEmitter.cpp

@@ -2214,6 +2214,7 @@ void ByteCodeGenerator::LoadSuperObject(FuncInfo *funcInfo)
 void ByteCodeGenerator::EmitSuperCall(FuncInfo* funcInfo, ParseNode* pnode, BOOL fReturnValue)
 {
     FuncInfo* nonLambdaFunc = funcInfo;
+    bool isResultUsed = pnode->isUsed;
 
     if (funcInfo->IsLambda())
     {
@@ -2226,11 +2227,11 @@ void ByteCodeGenerator::EmitSuperCall(FuncInfo* funcInfo, ParseNode* pnode, BOOL
         this->Writer()->W1(Js::OpCode::RuntimeReferenceError, SCODE_CODE(JSERR_ClassSuperInBaseClass));
         return;
     }
-    else
-    {
-        pnode->isUsed = true;
-    }
 
+    pnode->isUsed = true;
+
+    // pnode->location refers to two things: the result of the inner function call (`temp` in the pseudocode below),
+    // and the result of the super() expression itself
     funcInfo->AcquireLoc(pnode);
 
     // We need to emit 'this' directly so we can skip throwing a reference error if 'this' is currently undecl (we want to get undecl if 'this' is undecl)
@@ -2302,6 +2303,12 @@ void ByteCodeGenerator::EmitSuperCall(FuncInfo* funcInfo, ParseNode* pnode, BOOL
     this->Writer()->W1(Js::OpCode::RuntimeReferenceError, SCODE_CODE(JSERR_ClassThisAlreadyAssigned));
     this->Writer()->MarkLabel(skipLabel);
 
+    // If calling code cares about the return value, then move the selected `this` value into the result register.
+    if (isResultUsed)
+    {
+        this->Writer()->Reg2(Js::OpCode::Ld_A, pnode->location, valueForThis);
+    }
+
     Symbol* thisSym = pnode->sxSuperCall.pnodeThis->sxPid.sym;
     this->Writer()->Reg2(Js::OpCode::StrictLdThis, pnode->sxSuperCall.pnodeThis->location, valueForThis);
 

test/es6/ES6Super.js

@@ -204,6 +204,85 @@ var tests = [
         assert.areEqual(6, count, "Side effects expected without SyntaxError");
     }
   },
+  {
+    name: "return value of super() should be this when super is plain function",
+    body: function () {
+        function A() { }
+
+        let s;
+        class B extends A {
+            constructor() {
+                s = super();
+            }
+        }
+
+        const b = new B();
+        assert.areEqual(b, s);
+    }
+  },
+  {
+    name: "return value of super() should be this when super is class",
+    body: function () {
+        class A { }
+
+        let s;
+        class B extends A {
+            constructor() {
+                s = super();
+            }
+        }
+
+        const b = new B();
+        assert.areEqual(b, s);
+    }
+  },
+  {
+    name: "return value of super() should be this when super is function with non-object return value",
+    body: function () {
+        function A() { return 4; }
+
+        let s;
+        class B extends A {
+            constructor() {
+                s = super();
+            }
+        }
+
+        const b = new B();
+        assert.areEqual(b, s);
+    }
+  },
+  {
+    name: "return value of super() should be this when super is function that returns an object",
+    body: function () {
+        function A() { return { a: 1 }; }
+
+        let s;
+        class B extends A {
+            constructor() {
+                s = super();
+            }
+        }
+
+        const b = new B();
+        assert.areEqual(b, s);
+        assert.areEqual(1, b.a);
+    }
+  },
+  {
+    name: "return value of super() should be this when super is built-in type",
+    body: function () {
+        let s;
+        class B extends Uint32Array {
+            constructor() {
+                s = super();
+            }
+        }
+
+        const b = new B();
+        assert.areEqual(b, s);
+    }
+  },
 ];
 
 testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });