[promises] Remove deferred object

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 1795 matching lines @@
   delete tltop->promise_on_stack_;
   tltop->promise_on_stack_ = prev;
   global_handles()->Destroy(global_promise.location());
 }
 
 namespace {
 bool InternalPromiseHasUserDefinedRejectHandler(Isolate* isolate,
                                                 Handle<JSPromise> promise);
 
 bool PromiseHandlerCheck(Isolate* isolate, Handle<JSReceiver> handler,
-                         Handle<JSObject> deferred) {
+                         Handle<JSReceiver> deferred_promise) {
   // Recurse to the forwarding Promise, if any. This may be due to
   //  - await reaction forwarding to the throwaway Promise, which has
   //    a dependency edge to the outer Promise.
   //  - PromiseIdResolveHandler forwarding to the output of .then
   //  - Promise.all/Promise.race forwarding to a throwaway Promise, which
   //    has a dependency edge to the generated outer Promise.
   // Otherwise, this is a real reject handler for the Promise.
   Handle<Symbol> key = isolate->factory()->promise_forwarding_handler_symbol();
   Handle<Object> forwarding_handler = JSReceiver::GetDataProperty(handler, key);
   if (forwarding_handler->IsUndefined(isolate)) {
     return true;
   }
 
-  // TODO(gsathya): Remove this once we get rid of deferred objects.
-  Handle<String> promise_str = isolate->factory()->promise_string();
-  Handle<Object> deferred_promise_obj =
-      JSObject::GetDataProperty(deferred, promise_str);
-  if (!deferred_promise_obj->IsJSPromise()) {
+  if (!deferred_promise->IsJSPromise()) {
     return true;
   }
 
   return InternalPromiseHasUserDefinedRejectHandler(
-      isolate, Handle<JSPromise>::cast(deferred_promise_obj));
+      isolate, Handle<JSPromise>::cast(deferred_promise));
 }
 
 bool InternalPromiseHasUserDefinedRejectHandler(Isolate* isolate,
                                                 Handle<JSPromise> promise) {
   // If this promise was marked as being handled by a catch block
   // in an async function, then it has a user-defined reject handler.
   if (promise->handled_hint()) return true;
 
   // If this Promise is subsumed by another Promise (a Promise resolved
   // with another Promise, or an intermediate, hidden, throwaway Promise
   // within async/await), then recurse on the outer Promise.
   // In this case, the dependency is one possible way that the Promise
   // could be resolved, so it does not subsume the other following cases.
   Handle<Symbol> key = isolate->factory()->promise_handled_by_symbol();
   Handle<Object> outer_promise_obj = JSObject::GetDataProperty(promise, key);
   if (outer_promise_obj->IsJSPromise() &&
       InternalPromiseHasUserDefinedRejectHandler(
           isolate, Handle<JSPromise>::cast(outer_promise_obj))) {
     return true;
   }
 
   Handle<Object> queue(promise->reject_reactions(), isolate);
-  Handle<Object> deferred(promise->deferred(), isolate);
+  Handle<Object> deferred_promise(promise->deferred_promise(), isolate);
 
   if (queue->IsUndefined(isolate)) {
     return false;
   }
 
   if (queue->IsCallable()) {
     return PromiseHandlerCheck(isolate, Handle<JSReceiver>::cast(queue),
-                               Handle<JSObject>::cast(deferred));
+                               Handle<JSReceiver>::cast(deferred_promise));
   }
 
   Handle<FixedArray> queue_arr = Handle<FixedArray>::cast(queue);
-  Handle<FixedArray> deferred_arr = Handle<FixedArray>::cast(deferred);
-  for (int i = 0; i < deferred_arr->length(); i++) {
+  Handle<FixedArray> deferred_promise_arr =
+      Handle<FixedArray>::cast(deferred_promise);
+  for (int i = 0; i < deferred_promise_arr->length(); i++) {
     Handle<JSReceiver> queue_item(JSReceiver::cast(queue_arr->get(i)));
-    Handle<JSObject> deferred_item(JSObject::cast(deferred_arr->get(i)));
-    if (PromiseHandlerCheck(isolate, queue_item, deferred_item)) {
+    Handle<JSReceiver> deferred_promise_item(
+        JSReceiver::cast(deferred_promise_arr->get(i)));
+    if (PromiseHandlerCheck(isolate, queue_item, deferred_promise_item)) {
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace
 
 bool Isolate::PromiseHasUserDefinedRejectHandler(Handle<Object> promise) {
@@ skipping 1403 matching lines @@
 void Isolate::PromiseReactionJob(Handle<PromiseReactionJobInfo> info,
                                  MaybeHandle<Object>* result,
                                  MaybeHandle<Object>* maybe_exception) {
   PromiseDebugEventScope helper(this, info->debug_id(), info->debug_name());
 
   Handle<JSPromise> promise(info->promise(), this);
   Handle<Object> value(info->value(), this);
   Handle<Object> tasks(info->tasks(), this);
   Handle<JSFunction> promise_handle_fn = promise_handle();
   Handle<Object> undefined = factory()->undefined_value();
-  Handle<Object> deferred(info->deferred(), this);
+  Handle<Object> deferred_promise(info->deferred_promise(), this);
 
-  if (deferred->IsFixedArray()) {
+  if (deferred_promise->IsFixedArray()) {
     DCHECK(tasks->IsFixedArray());
-    Handle<FixedArray> deferred_arr = Handle<FixedArray>::cast(deferred);
+    Handle<FixedArray> deferred_promise_arr =
+        Handle<FixedArray>::cast(deferred_promise);
+    Handle<FixedArray> deferred_on_resolve_arr(
+        FixedArray::cast(info->deferred_on_resolve()), this);
+    Handle<FixedArray> deferred_on_reject_arr(
+        FixedArray::cast(info->deferred_on_reject()), this);
     Handle<FixedArray> tasks_arr = Handle<FixedArray>::cast(tasks);
-    for (int i = 0; i < deferred_arr->length(); i++) {
-      Handle<Object> argv[] = {promise, value, handle(tasks_arr->get(i), this),
-                               handle(deferred_arr->get(i), this)};
+    for (int i = 0; i < deferred_promise_arr->length(); i++) {
+      Handle<Object> argv[] = {promise,
+                               value,
+                               handle(tasks_arr->get(i), this),
+                               handle(deferred_promise_arr->get(i), this),
+                               handle(deferred_on_resolve_arr->get(i), this),
+                               handle(deferred_on_reject_arr->get(i), this)};
       *result = Execution::TryCall(this, promise_handle_fn, undefined,
                                    arraysize(argv), argv, maybe_exception);
       // If execution is terminating, just bail out.
       if (result->is_null() && maybe_exception->is_null()) {
         return;
       }
     }
   } else {
-    Handle<Object> argv[] = {promise, value, tasks, deferred};
+    Handle<Object> argv[] = {promise,
+                             value,
+                             tasks,
+                             deferred_promise,
+                             handle(info->deferred_on_resolve(), this),
+                             handle(info->deferred_on_reject(), this)};
     *result = Execution::TryCall(this, promise_handle_fn, undefined,
                                  arraysize(argv), argv, maybe_exception);
   }
 }
 
 void Isolate::PromiseResolveThenableJob(
     Handle<PromiseResolveThenableJobInfo> info, MaybeHandle<Object>* result,
     MaybeHandle<Object>* maybe_exception) {
   PromiseDebugEventScope helper(this, info->debug_id(), info->debug_name());
 
@@ skipping 318 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8