Promise.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
  1. /*
  2. * Copyright (c) 2021, Linus Groh <linusg@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Debug.h>
  7. #include <AK/Function.h>
  8. #include <AK/Optional.h>
  9. #include <AK/TypeCasts.h>
  10. #include <LibJS/Runtime/Error.h>
  11. #include <LibJS/Runtime/GlobalObject.h>
  12. #include <LibJS/Runtime/JobCallback.h>
  13. #include <LibJS/Runtime/Promise.h>
  14. #include <LibJS/Runtime/PromiseJobs.h>
  15. #include <LibJS/Runtime/PromiseReaction.h>
  16. #include <LibJS/Runtime/PromiseResolvingFunction.h>
  17. namespace JS {
  18. // 27.2.4.7.1 PromiseResolve ( C, x ), https://tc39.es/ecma262/#sec-promise-resolve
  19. ThrowCompletionOr<Object*> promise_resolve(GlobalObject& global_object, Object& constructor, Value value)
  20. {
  21. auto& vm = global_object.vm();
  22. if (value.is_object() && is<Promise>(value.as_object())) {
  23. auto value_constructor = TRY(value.as_object().get(vm.names.constructor));
  24. if (same_value(value_constructor, &constructor))
  25. return &static_cast<Promise&>(value.as_object());
  26. }
  27. auto promise_capability = TRY(new_promise_capability(global_object, &constructor));
  28. (void)TRY(vm.call(*promise_capability.resolve, js_undefined(), value));
  29. return promise_capability.promise;
  30. }
  31. Promise* Promise::create(GlobalObject& global_object)
  32. {
  33. return global_object.heap().allocate<Promise>(global_object, *global_object.promise_prototype());
  34. }
  35. Promise::Promise(Object& prototype)
  36. : Object(prototype)
  37. {
  38. }
  39. // 27.2.1.3 CreateResolvingFunctions ( promise ), https://tc39.es/ecma262/#sec-createresolvingfunctions
  40. Promise::ResolvingFunctions Promise::create_resolving_functions()
  41. {
  42. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / create_resolving_functions()]", this);
  43. auto& vm = this->vm();
  44. auto* already_resolved = vm.heap().allocate_without_global_object<AlreadyResolved>();
  45. // 27.2.1.3.2 Promise Resolve Functions, https://tc39.es/ecma262/#sec-promise-resolve-functions
  46. auto* resolve_function = PromiseResolvingFunction::create(global_object(), *this, *already_resolved, [](auto& vm, auto& global_object, auto& promise, auto& already_resolved) {
  47. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Resolve function was called", &promise);
  48. if (already_resolved.value) {
  49. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Promise is already resolved, returning undefined", &promise);
  50. return js_undefined();
  51. }
  52. already_resolved.value = true;
  53. auto resolution = vm.argument(0);
  54. if (resolution.is_object() && &resolution.as_object() == &promise) {
  55. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Promise can't be resolved with itself, rejecting with error", &promise);
  56. auto* self_resolution_error = TypeError::create(global_object, "Cannot resolve promise with itself");
  57. return promise.reject(self_resolution_error);
  58. }
  59. if (!resolution.is_object()) {
  60. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Resolution is not an object, fulfilling with {}", &promise, resolution);
  61. return promise.fulfill(resolution);
  62. }
  63. auto then = resolution.as_object().get(vm.names.then);
  64. if (then.is_throw_completion()) {
  65. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Exception while getting 'then' property, rejecting with error", &promise);
  66. vm.clear_exception();
  67. vm.stop_unwind();
  68. return promise.reject(then.throw_completion().value());
  69. }
  70. auto then_action = then.release_value();
  71. if (!then_action.is_function()) {
  72. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Then action is not a function, fulfilling with {}", &promise, resolution);
  73. return promise.fulfill(resolution);
  74. }
  75. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Creating JobCallback for then action @ {}", &promise, &then_action.as_function());
  76. auto then_job_callback = make_job_callback(then_action.as_function());
  77. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Creating PromiseResolveThenableJob for thenable {}", &promise, resolution);
  78. auto* job = PromiseResolveThenableJob::create(global_object, promise, resolution, then_job_callback);
  79. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Enqueuing job @ {}", &promise, job);
  80. vm.enqueue_promise_job(*job);
  81. return js_undefined();
  82. });
  83. resolve_function->define_direct_property(vm.names.name, js_string(vm, String::empty()), Attribute::Configurable);
  84. // 27.2.1.3.1 Promise Reject Functions, https://tc39.es/ecma262/#sec-promise-reject-functions
  85. auto* reject_function = PromiseResolvingFunction::create(global_object(), *this, *already_resolved, [](auto& vm, auto&, auto& promise, auto& already_resolved) {
  86. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / PromiseResolvingFunction]: Reject function was called", &promise);
  87. if (already_resolved.value)
  88. return js_undefined();
  89. already_resolved.value = true;
  90. auto reason = vm.argument(0);
  91. return promise.reject(reason);
  92. });
  93. reject_function->define_direct_property(vm.names.name, js_string(vm, String::empty()), Attribute::Configurable);
  94. return { *resolve_function, *reject_function };
  95. }
  96. // 27.2.1.4 FulfillPromise ( promise, value ), https://tc39.es/ecma262/#sec-fulfillpromise
  97. Value Promise::fulfill(Value value)
  98. {
  99. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / fulfill()]: Fulfilling promise with value {}", this, value);
  100. VERIFY(m_state == State::Pending);
  101. VERIFY(!value.is_empty());
  102. m_state = State::Fulfilled;
  103. m_result = value;
  104. trigger_reactions();
  105. m_fulfill_reactions.clear();
  106. m_reject_reactions.clear();
  107. return js_undefined();
  108. }
  109. // 27.2.1.7 RejectPromise ( promise, reason ), https://tc39.es/ecma262/#sec-rejectpromise
  110. Value Promise::reject(Value reason)
  111. {
  112. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / reject()]: Rejecting promise with reason {}", this, reason);
  113. VERIFY(m_state == State::Pending);
  114. VERIFY(!reason.is_empty());
  115. auto& vm = this->vm();
  116. m_state = State::Rejected;
  117. m_result = reason;
  118. if (!m_is_handled)
  119. vm.promise_rejection_tracker(*this, RejectionOperation::Reject);
  120. trigger_reactions();
  121. m_fulfill_reactions.clear();
  122. m_reject_reactions.clear();
  123. return js_undefined();
  124. }
  125. // 27.2.1.8 TriggerPromiseReactions ( reactions, argument ), https://tc39.es/ecma262/#sec-triggerpromisereactions
  126. void Promise::trigger_reactions() const
  127. {
  128. VERIFY(is_settled());
  129. auto& vm = this->vm();
  130. auto& reactions = m_state == State::Fulfilled
  131. ? m_fulfill_reactions
  132. : m_reject_reactions;
  133. for (auto& reaction : reactions) {
  134. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / trigger_reactions()]: Creating PromiseReactionJob for PromiseReaction @ {} with argument {}", this, &reaction, m_result);
  135. auto* job = PromiseReactionJob::create(global_object(), *reaction, m_result);
  136. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / trigger_reactions()]: Enqueuing job @ {}", this, job);
  137. vm.enqueue_promise_job(*job);
  138. }
  139. if constexpr (PROMISE_DEBUG) {
  140. if (reactions.is_empty())
  141. dbgln("[Promise @ {} / trigger_reactions()]: No reactions!", this);
  142. }
  143. }
  144. // 27.2.5.4.1 PerformPromiseThen ( promise, onFulfilled, onRejected [ , resultCapability ] ), https://tc39.es/ecma262/#sec-performpromisethen
  145. Value Promise::perform_then(Value on_fulfilled, Value on_rejected, Optional<PromiseCapability> result_capability)
  146. {
  147. auto& vm = this->vm();
  148. Optional<JobCallback> on_fulfilled_job_callback;
  149. if (on_fulfilled.is_function()) {
  150. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: Creating JobCallback for on_fulfilled function @ {}", this, &on_fulfilled.as_function());
  151. on_fulfilled_job_callback = make_job_callback(on_fulfilled.as_function());
  152. }
  153. Optional<JobCallback> on_rejected_job_callback;
  154. if (on_rejected.is_function()) {
  155. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: Creating JobCallback for on_rejected function @ {}", this, &on_rejected.as_function());
  156. on_rejected_job_callback = make_job_callback(on_rejected.as_function());
  157. }
  158. auto* fulfill_reaction = PromiseReaction::create(vm, PromiseReaction::Type::Fulfill, result_capability, on_fulfilled_job_callback);
  159. auto* reject_reaction = PromiseReaction::create(vm, PromiseReaction::Type::Reject, result_capability, on_rejected_job_callback);
  160. switch (m_state) {
  161. case Promise::State::Pending:
  162. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: state is State::Pending, adding fulfill/reject reactions", this);
  163. m_fulfill_reactions.append(fulfill_reaction);
  164. m_reject_reactions.append(reject_reaction);
  165. break;
  166. case Promise::State::Fulfilled: {
  167. auto value = m_result;
  168. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: State is State::Fulfilled, creating PromiseReactionJob for PromiseReaction @ {} with argument {}", this, fulfill_reaction, value);
  169. auto* fulfill_job = PromiseReactionJob::create(global_object(), *fulfill_reaction, value);
  170. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: Enqueuing job @ {}", this, fulfill_job);
  171. vm.enqueue_promise_job(*fulfill_job);
  172. break;
  173. }
  174. case Promise::State::Rejected: {
  175. auto reason = m_result;
  176. if (!m_is_handled)
  177. vm.promise_rejection_tracker(*this, RejectionOperation::Handle);
  178. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: State is State::Rejected, creating PromiseReactionJob for PromiseReaction @ {} with argument {}", this, reject_reaction, reason);
  179. auto* reject_job = PromiseReactionJob::create(global_object(), *reject_reaction, reason);
  180. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: Enqueuing job @ {}", this, reject_job);
  181. vm.enqueue_promise_job(*reject_job);
  182. break;
  183. }
  184. default:
  185. VERIFY_NOT_REACHED();
  186. }
  187. m_is_handled = true;
  188. if (!result_capability.has_value()) {
  189. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: No ResultCapability, returning undefined", this);
  190. return js_undefined();
  191. }
  192. auto* promise = result_capability.value().promise;
  193. dbgln_if(PROMISE_DEBUG, "[Promise @ {} / perform_then()]: Returning Promise @ {} from ResultCapability @ {}", this, promise, &result_capability.value());
  194. return promise;
  195. }
  196. void Promise::visit_edges(Cell::Visitor& visitor)
  197. {
  198. Base::visit_edges(visitor);
  199. visitor.visit(m_result);
  200. for (auto& reaction : m_fulfill_reactions)
  201. visitor.visit(reaction);
  202. for (auto& reaction : m_reject_reactions)
  203. visitor.visit(reaction);
  204. }
  205. }