Correctly handle resolving promises with other promises (#1190)

Perryvw · web-flow · commit 4bd18722e048 · 2021-12-21T22:46:00.000+01:00
* Correctly handle resolving promises with other promises

* Additional test
diff --git a/src/lualib/Promise.ts b/src/lualib/Promise.ts
@@ -128,6 +128,14 @@ class __TS__Promise<T> implements Promise<T> {
     }
 
     private resolve(data: T): void {
+        if (data instanceof __TS__Promise) {
+            data.then(
+                v => this.resolve(v),
+                err => this.reject(err)
+            );
+            return;
+        }
+
         // Resolve this promise, if it is still pending. This function is passed to the constructor function.
         if (this.state === __TS__PromiseState.Pending) {
             this.state = __TS__PromiseState.Fulfilled;
diff --git a/test/unit/builtins/async-await.spec.ts b/test/unit/builtins/async-await.spec.ts
@@ -384,6 +384,63 @@ test("async function can forward varargs", () => {
         .expectToEqual(["resolved", "A", "B", "C"]);
 });
 
+test("async function adopts pending promise", () => {
+    util.testFunction`
+        let resolve: (v: string) => void = () => {};
+        async function receive(): Promise<string> {
+            return new Promise(res => {
+                resolve = res;
+            });
+        }
+
+        receive().then(v => {
+            log(v);
+        });
+
+        resolve("delayed resolve");
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["delayed resolve"]);
+});
+
+test("async function adopts resolved promise", () => {
+    util.testFunction`
+        async function receive(): Promise<string> {
+            return new Promise(resolve => {
+                resolve("resolved!");
+            });
+        }
+
+        receive().then(v => {
+            log(v);
+        });
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["resolved!"]);
+});
+
+test("async function adopts rejected promise", () => {
+    util.testFunction`
+        async function receive(): Promise<string> {
+            return new Promise((_, reject) => {
+                reject("rejected");
+            });
+        }
+
+        receive().catch(err => {
+            log(err);
+        });
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["rejected"]);
+});
+
 test.each(["async function abc() {", "const abc = async () => {"])(
     "can throw error after await in async function (%p)",
     functionHeader => {
diff --git a/test/unit/builtins/promise.spec.ts b/test/unit/builtins/promise.spec.ts
@@ -751,6 +751,66 @@ test("catch after then catches rejected promise", () => {
         .expectToEqual(["catch", "test error"]);
 });
 
+test("promise unwraps resolved promise result", () => {
+    util.testFunction`
+        const { promise, resolve } = defer<string>();
+        promise.then(v => log(v));
+
+        resolve(Promise.resolve("result"));
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["result"]);
+});
+
+test("resolving promise with rejected promise rejects the promise", () => {
+    util.testFunction`
+        const { promise, resolve } = defer<string>();
+        promise.catch(err => log(err));
+
+        resolve(Promise.reject("reject"));
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["reject"]);
+});
+
+test("resolving promise with pending promise will keep pending until promise2 resolved", () => {
+    util.testFunction`
+        const { promise, resolve } = defer<string>();
+        promise.then(v => log("promise 1", v));
+
+        const { promise: promise2, resolve: resolve2 } = defer<string>();
+        promise2.then(v => log("promise 2", v));
+
+        resolve(promise2);
+        resolve2("result");
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["promise 2", "result", "promise 1", "result"]);
+});
+
+test("resolving promise with pending promise will keep pending until promise2 rejects", () => {
+    util.testFunction`
+        const { promise, resolve } = defer<string>();
+        promise.catch(v => log("promise 1", v));
+
+        const { promise: promise2, reject: reject2 } = defer<string>();
+        promise2.catch(v => log("promise 2", v));
+
+        resolve(promise2);
+        reject2("rejection");
+
+        return allLogs;
+    `
+        .setTsHeader(promiseTestLib)
+        .expectToEqual(["promise 2", "rejection", "promise 1", "rejection"]);
+});
+
 describe("Promise.all", () => {
     test("resolves once all arguments are resolved", () => {
         util.testFunction`
