WIP

src/patch_promise.js

@@ -7,42 +7,32 @@ export const patch_promise = window => {
 
   class PromiseWithStatus extends Promise {
     constructor(fn) {
-      let status 
+      const p = new Promise.Original((resolve, reject) => {
-      let is_constructor_finished = false
+        fn(
-      super(
+          (value) => {
-        (resolve, reject) => {
+            if(value instanceof window.Promise) {
-          fn(
+              value
-            (value) => {
+                .then(v => {
-              if(value instanceof window.Promise.Original) {
+                  p.status = {ok: true, value: v}
-                value
+                  resolve(v)
-                  .then(v => {
+                })
-                    this.status = {ok: true, value: v}
+                .catch(e => {
-                    resolve(v)
+                  p.status = {ok: false, error: e}
-                  })
+                  reject(e)
-                  .catch(e => {
+                })
-                    this.status = {ok: false, error: e}
+            } else {
-                    reject(e)
+              p.status = {ok: true, value}
-                  })
+              resolve(value)
-              } else {
+            }
-                status = {ok: true, value}
+          },
-                if(is_constructor_finished) {
+          (error) => {
-                  this.status = status
+            p.status = {ok: false, error}
-                }
+            reject(error)
-                resolve(value)
+          },
-              }
+        )
-            },
+      })
-            (error) => {
+
-              status = {ok: false, error}
+      return p
-              if(is_constructor_finished) {
-                this.status = status
-              }
-              reject(error)
-            },
-          )
-        }
-      )
-      is_constructor_finished = true
-      this.status = status
     }
   }
 

test/test.js

@@ -2612,6 +2612,15 @@ const y = x()`
     )
   }),
 
+  test('async/await await Promise resolved immediately', async () => {
+    await assert_code_evals_to_async(
+      `
+        await new Promise(resolve => resolve(1))
+      `,
+      1
+    )
+  }),
+
   test('async/await return from async function', async () => {
     await assert_code_evals_to_async(
       `
@@ -2746,6 +2755,20 @@ const y = x()`
     assert_equal(logs, [1, 2])
   }),
 
+
+  /* TODO
+  test('p', async () => {
+    const i = await assert_code_evals_to_async(`
+      const res = Promise.resolve(1)
+      Object.assign(res, {mark: 'resolved'})
+      await Object.assign(new Promise(resolve => resolve()), {mark: 'w'})
+    `,
+    1
+    )
+
+  }),
+  */
+
   test('async/await logs out of order', async () => {
     const i = await test_initial_state_async(`
       // Init promises p1 and p2 that are resolved in different order (p2 then