Fix Promise.finally() to await returned thenables per ES2018 semantics

lib/src/promise/base.ts

@@ -205,13 +205,15 @@ export function _createPromise<T>(newPromise: PromiseCreatorFn, processor: Promi
         let catchFinally: any = onFinally;
         if (isFunction(onFinally)) {
             thenFinally = function(value: TResult1 | TResult2) {
-                onFinally && onFinally();
-                return value;
+                return doAwait(onFinally && onFinally(), () => {
+                    return value;
+                });
             }
 
             catchFinally = function(reason: any) {
-                onFinally && onFinally();
-                throw reason;
+                return doAwait(onFinally && onFinally(), () => {
+                    throw reason;
+                });
             }
         }
 

lib/test/src/promise/use.await.test.ts

@@ -1413,6 +1413,63 @@ function batchTests(testKey: string, definition: TestDefinition) {
         }).finally(()=> 77), 2, "Expect the result to be 2");
     });
 
+    it("check finally waits for returned promise on resolve", async () => {
+        let finallyCalled = false;
+        let promise = createNewPromise((resolve, reject) => {
+            resolve(2);
+        }).finally(() => {
+            return createNewPromise<void>((resolve) => {
+                scheduleTimeout(() => {
+                    finallyCalled = true;
+                    resolve();
+                }, 10);
+            });
+        });
+
+        assert.equal(finallyCalled, false, "finally should not be called synchronously");
+        let result = await promise;
+        assert.equal(result, 2, "Expect the result to be 2");
+        assert.equal(finallyCalled, true, "finally promise should complete before resolve");
+    });
+
+    it("check finally waits for returned promise on reject", async () => {
+        let finallyCalled = false;
+        let finallyRejectReason = new Error("finally-reject");
+        try {
+            await createRejectedPromise<number>(new Error("main-reject")).finally(() => {
+                return createNewPromise<void>((resolve, reject) => {
+                    scheduleTimeout(() => {
+                        finallyCalled = true;
+                        reject(finallyRejectReason);
+                    }, 10);
+                });
+            });
+            assert.ok(false, "Expected the promise to reject");
+        } catch (e) {
+            assert.equal(e, finallyRejectReason, "Expected the finally rejection reason");
+            assert.equal(finallyCalled, true, "finally promise should complete before reject");
+        }
+    });
+
+    it("check finally preserves original rejection when returned promise resolves", async () => {
+        let finallyCalled = false;
+        let mainRejectReason = new Error("main-reject");
+        try {
+            await createRejectedPromise<number>(mainRejectReason).finally(() => {
+                return createNewPromise<void>((resolve) => {
+                    scheduleTimeout(() => {
+                        finallyCalled = true;
+                        resolve();
+                    }, 10);
+                });
+            });
+            assert.ok(false, "Expected the promise to reject");
+        } catch (e) {
+            assert.equal(e, mainRejectReason, "Expected the original rejection reason");
+            assert.equal(finallyCalled, true, "finally promise should complete before reject");
+        }
+    });
+
     it("check creating a resolved promise with another promise", async () => {
 
         let otherPromise = createNewPromise((resolve, reject) => {