LibJS: Add initial support for Promises

Almost a year after first working on this, it's finally done: an
implementation of Promises for LibJS! :^)

The core functionality is working and closely following the spec [1].
I mostly took the pseudo code and transformed it into C++ - if you read
and understand it, you will know how the spec implements Promises; and
if you read the spec first, the code will look very familiar.

Implemented functions are:

- Promise() constructor
- Promise.prototype.then()
- Promise.prototype.catch()
- Promise.prototype.finally()
- Promise.resolve()
- Promise.reject()

For the tests I added a new function to test-js's global object,
runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs().
By design, queued jobs normally only run after the script was fully
executed, making it improssible to test handlers in individual test()
calls by default [2].

Subsequent commits include integrations into LibWeb and js(1) -
pretty-printing, running queued promise jobs when necessary.

This has an unusual amount of dbgln() statements, all hidden behind the
PROMISE_DEBUG flag - I'm leaving them in for now as they've been very
useful while debugging this, things can get quite complex with so many
asynchronously executed functions.

I've not extensively explored use of these APIs for promise-based
functionality in LibWeb (fetch(), Notification.requestPermission()
etc.), but we'll get there in due time.

[1]: https://tc39.es/ecma262/#sec-promise-objects
[2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues

Userland/Libraries/LibJS/Runtime/VM.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2020-2021, Linus Groh <mail@linusgroh.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24,12 +25,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <AK/Debug.h>
 #include <AK/ScopeGuard.h>
 #include <AK/StringBuilder.h>
+#include <AK/TemporaryChange.h>
 #include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/Array.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibJS/Runtime/GlobalObject.h>
+#include <LibJS/Runtime/NativeFunction.h>
+#include <LibJS/Runtime/PromiseReaction.h>
 #include <LibJS/Runtime/Reference.h>
 #include <LibJS/Runtime/ScriptFunction.h>
 #include <LibJS/Runtime/Symbol.h>
@@ -128,6 +133,9 @@ void VM::gather_roots(HashTable<Cell*>& roots)
 
     for (auto& symbol : m_global_symbol_map)
         roots.set(symbol.value);
+
+    for (auto* job : m_promise_jobs)
+        roots.set(job);
 }
 
 Symbol* VM::get_global_symbol(const String& description)
@@ -371,4 +379,44 @@ bool VM::in_strict_mode() const
     return call_frame().is_strict_mode;
 }
 
+void VM::run_queued_promise_jobs()
+{
+    dbgln_if(PROMISE_DEBUG, "Running queued promise jobs");
+    // Temporarily get rid of the exception, if any - job functions must be called
+    // either way, and that can't happen if we already have an exception stored.
+    TemporaryChange change(m_exception, static_cast<Exception*>(nullptr));
+    while (!m_promise_jobs.is_empty()) {
+        auto* job = m_promise_jobs.take_first();
+        dbgln_if(PROMISE_DEBUG, "Calling promise job function @ {}", job);
+        [[maybe_unused]] auto result = call(*job, js_undefined());
+    }
+    // Ensure no job has created a new exception, they must clean up after themselves.
+    VERIFY(!m_exception);
+}
+
+// 9.4.4 HostEnqueuePromiseJob, https://tc39.es/ecma262/#sec-hostenqueuepromisejob
+void VM::enqueue_promise_job(NativeFunction& job)
+{
+    m_promise_jobs.append(&job);
+}
+
+// 27.2.1.9 HostPromiseRejectionTracker, https://tc39.es/ecma262/#sec-host-promise-rejection-tracker
+void VM::promise_rejection_tracker(const Promise& promise, Promise::RejectionOperation operation) const
+{
+    switch (operation) {
+    case Promise::RejectionOperation::Reject:
+        // A promise was rejected without any handlers
+        if (on_promise_unhandled_rejection)
+            on_promise_unhandled_rejection(promise);
+        break;
+    case Promise::RejectionOperation::Handle:
+        // A handler was added to an already rejected promise
+        if (on_promise_rejection_handled)
+            on_promise_rejection_handled(promise);
+        break;
+    default:
+        VERIFY_NOT_REACHED();
+    }
+}
+
 }