[promises] rename PromiseContainer to PromiseResolveThenableJobInfo

This is a much more descriptive name.

BUG=v8:5343
TBR=bmeurer@chromium.org

Review-Url: https://codereview.chromium.org/2412263002
Cr-Commit-Position: refs/heads/master@{#40240}

src/ast/ast-types.cc

@@ -261,7 +261,7 @@ AstType::bitset AstBitsetType::Lub(i::Map* map) {
     case ACCESS_CHECK_INFO_TYPE:
     case INTERCEPTOR_INFO_TYPE:
     case CALL_HANDLER_INFO_TYPE:
-    case PROMISE_CONTAINER_TYPE:
+    case PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE:
     case PROMISE_REACTION_JOB_INFO_TYPE:
     case FUNCTION_TEMPLATE_INFO_TYPE:
     case OBJECT_TEMPLATE_INFO_TYPE:

src/compiler/types.cc

@@ -264,7 +264,7 @@ Type::bitset BitsetType::Lub(i::Map* map) {
     case TYPE_FEEDBACK_INFO_TYPE:
     case ALIASED_ARGUMENTS_ENTRY_TYPE:
     case BOX_TYPE:
-    case PROMISE_CONTAINER_TYPE:
+    case PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE:
     case PROMISE_REACTION_JOB_INFO_TYPE:
     case DEBUG_INFO_TYPE:
     case BREAK_POINT_INFO_TYPE:

src/factory.cc

@@ -923,12 +923,13 @@ Handle<Struct> Factory::NewStruct(InstanceType type) {
       Struct);
 }
 
-Handle<PromiseContainer> Factory::NewPromiseContainer(
+Handle<PromiseResolveThenableJobInfo> Factory::NewPromiseResolveThenableJobInfo(
     Handle<JSReceiver> thenable, Handle<JSReceiver> then,
     Handle<JSFunction> resolve, Handle<JSFunction> reject,
     Handle<Object> before_debug_event, Handle<Object> after_debug_event) {
-  Handle<PromiseContainer> result =
-      Handle<PromiseContainer>::cast(NewStruct(PROMISE_CONTAINER_TYPE));
+  Handle<PromiseResolveThenableJobInfo> result =
+      Handle<PromiseResolveThenableJobInfo>::cast(
+          NewStruct(PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE));
   result->set_thenable(*thenable);
   result->set_then(*then);
   result->set_resolve(*resolve);

src/factory.h

@@ -66,8 +66,8 @@ class Factory final {
       Handle<Object> before_debug, Handle<Object> after_debug_event,
       Handle<Context> context);
 
-  // Create a new PromiseContainer struct.
-  Handle<PromiseContainer> NewPromiseContainer(
+  // Create a new PromiseResolveThenableJobInfo struct.
+  Handle<PromiseResolveThenableJobInfo> NewPromiseResolveThenableJobInfo(
       Handle<JSReceiver> thenable, Handle<JSReceiver> then,
       Handle<JSFunction> resolve, Handle<JSFunction> reject,
       Handle<Object> before_debug_event, Handle<Object> after_debug_event);

src/isolate.cc

@@ -3136,16 +3136,16 @@ void Isolate::PromiseReactionJob(Handle<PromiseReactionJobInfo> info,
   }
 }
 
-void Isolate::PromiseResolveThenableJob(Handle<PromiseContainer> container,
-                                        MaybeHandle<Object>* result,
-                                        MaybeHandle<Object>* maybe_exception) {
-  PromiseDebugEventScope helper(this, container->before_debug_event(),
-                                container->after_debug_event());
-
-  Handle<JSReceiver> thenable(container->thenable(), this);
-  Handle<JSFunction> resolve(container->resolve(), this);
-  Handle<JSFunction> reject(container->reject(), this);
-  Handle<JSReceiver> then(container->then(), this);
+void Isolate::PromiseResolveThenableJob(
+    Handle<PromiseResolveThenableJobInfo> info, MaybeHandle<Object>* result,
+    MaybeHandle<Object>* maybe_exception) {
+  PromiseDebugEventScope helper(this, info->before_debug_event(),
+                                info->after_debug_event());
+
+  Handle<JSReceiver> thenable(info->thenable(), this);
+  Handle<JSFunction> resolve(info->resolve(), this);
+  Handle<JSFunction> reject(info->reject(), this);
+  Handle<JSReceiver> then(info->then(), this);
   Handle<Object> argv[] = {resolve, reject};
   *result = Execution::TryCall(this, then, thenable, arraysize(argv), argv,
                                maybe_exception);
@@ -3162,7 +3162,7 @@ void Isolate::PromiseResolveThenableJob(Handle<PromiseContainer> container,
 
 void Isolate::EnqueueMicrotask(Handle<Object> microtask) {
   DCHECK(microtask->IsJSFunction() || microtask->IsCallHandlerInfo() ||
-         microtask->IsPromiseContainer() ||
+         microtask->IsPromiseResolveThenableJobInfo() ||
          microtask->IsPromiseReactionJobInfo());
   Handle<FixedArray> queue(heap()->microtask_queue(), this);
   int num_tasks = pending_microtask_count();
@@ -3218,9 +3218,10 @@ void Isolate::RunMicrotasksInternal() {
         Context* context;
         if (microtask->IsJSFunction()) {
           context = Handle<JSFunction>::cast(microtask)->context();
-        } else if (microtask->IsPromiseContainer()) {
-          context =
-              Handle<PromiseContainer>::cast(microtask)->resolve()->context();
+        } else if (microtask->IsPromiseResolveThenableJobInfo()) {
+          context = Handle<PromiseResolveThenableJobInfo>::cast(microtask)
+                        ->resolve()
+                        ->context();
         } else {
           context = Handle<PromiseReactionJobInfo>::cast(microtask)->context();
         }
@@ -3238,9 +3239,10 @@ void Isolate::RunMicrotasksInternal() {
           result = Execution::TryCall(this, microtask_function,
                                       factory()->undefined_value(), 0, NULL,
                                       &maybe_exception);
-        } else if (microtask->IsPromiseContainer()) {
-          PromiseResolveThenableJob(Handle<PromiseContainer>::cast(microtask),
-                                    &result, &maybe_exception);
+        } else if (microtask->IsPromiseResolveThenableJobInfo()) {
+          PromiseResolveThenableJob(
+              Handle<PromiseResolveThenableJobInfo>::cast(microtask), &result,
+              &maybe_exception);
         } else {
           PromiseReactionJob(Handle<PromiseReactionJobInfo>::cast(microtask),
                              &result, &maybe_exception);

src/isolate.h

@@ -1112,7 +1112,7 @@ class Isolate {
   void PromiseReactionJob(Handle<PromiseReactionJobInfo> info,
                           MaybeHandle<Object>* result,
                           MaybeHandle<Object>* maybe_exception);
-  void PromiseResolveThenableJob(Handle<PromiseContainer> container,
+  void PromiseResolveThenableJob(Handle<PromiseResolveThenableJobInfo> info,
                                  MaybeHandle<Object>* result,
                                  MaybeHandle<Object>* maybe_exception);
   void EnqueueMicrotask(Handle<Object> microtask);

src/objects-debug.cc

@@ -912,14 +912,17 @@ void Box::BoxVerify() {
   value()->ObjectVerify();
 }
 
-void PromiseContainer::PromiseContainerVerify() {
-  CHECK(IsPromiseContainer());
-  thenable()->ObjectVerify();
-  then()->ObjectVerify();
-  resolve()->ObjectVerify();
-  reject()->ObjectVerify();
-  before_debug_event()->ObjectVerify();
-  after_debug_event()->ObjectVerify();
+void PromiseResolveThenableJobInfo::PromiseResolveThenableJobInfoVerify() {
+  Isolate* isolate = GetIsolate();
+  CHECK(IsPromiseResolveThenableJobInfo());
+  CHECK(thenable()->IsJSReceiver());
+  CHECK(then()->IsJSReceiver());
+  CHECK(resolve()->IsJSFunction());
+  CHECK(reject()->IsJSFunction());
+  CHECK(before_debug_event()->IsJSObject() ||
+        before_debug_event()->IsUndefined(isolate));
+  CHECK(after_debug_event()->IsJSObject() ||
+        after_debug_event()->IsUndefined(isolate));
 }
 
 void PromiseReactionJobInfo::PromiseReactionJobInfoVerify() {

src/objects-inl.h

@@ -5654,12 +5654,14 @@ ACCESSORS(AccessorInfo, data, Object, kDataOffset)
 
 ACCESSORS(Box, value, Object, kValueOffset)
 
-ACCESSORS(PromiseContainer, thenable, JSReceiver, kThenableOffset)
-ACCESSORS(PromiseContainer, then, JSReceiver, kThenOffset)
-ACCESSORS(PromiseContainer, resolve, JSFunction, kResolveOffset)
-ACCESSORS(PromiseContainer, reject, JSFunction, kRejectOffset)
-ACCESSORS(PromiseContainer, before_debug_event, Object, kBeforeDebugEventOffset)
-ACCESSORS(PromiseContainer, after_debug_event, Object, kAfterDebugEventOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, thenable, JSReceiver, kThenableOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, then, JSReceiver, kThenOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, resolve, JSFunction, kResolveOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, reject, JSFunction, kRejectOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, before_debug_event, Object,
+          kBeforeDebugEventOffset)
+ACCESSORS(PromiseResolveThenableJobInfo, after_debug_event, Object,
+          kAfterDebugEventOffset)
 
 ACCESSORS(PromiseReactionJobInfo, value, Object, kValueOffset);
 ACCESSORS(PromiseReactionJobInfo, tasks, Object, kTasksOffset);

src/objects-printer.cc

@@ -1150,8 +1150,9 @@ void Box::BoxPrint(std::ostream& os) {  // NOLINT
   os << "\n";
 }
 
-void PromiseContainer::PromiseContainerPrint(std::ostream& os) {  // NOLINT
-  HeapObject::PrintHeader(os, "PromiseContainer");
+void PromiseResolveThenableJobInfo::PromiseResolveThenableJobInfoPrint(
+    std::ostream& os) {  // NOLINT
+  HeapObject::PrintHeader(os, "PromiseResolveThenableJobInfo");
   os << "\n - thenable: " << Brief(thenable());
   os << "\n - then: " << Brief(then());
   os << "\n - resolve: " << Brief(resolve());

src/objects.h

@@ -143,7 +143,7 @@
 //     - Struct
 //       - Box
 //       - AccessorInfo
-//       - PromiseContainer
+//       - PromiseResolveThenableJobInfo
 //       - PromiseReactionJobInfo
 //       - AccessorPair
 //       - AccessCheckInfo
@@ -400,7 +400,7 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(TYPE_FEEDBACK_INFO_TYPE)                                    \
   V(ALIASED_ARGUMENTS_ENTRY_TYPE)                               \
   V(BOX_TYPE)                                                   \
-  V(PROMISE_CONTAINER_TYPE)                                     \
+  V(PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE)                     \
   V(PROMISE_REACTION_JOB_INFO_TYPE)                             \
   V(PROTOTYPE_INFO_TYPE)                                        \
   V(CONTEXT_EXTENSION_TYPE)                                     \
@@ -508,7 +508,8 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
 // manually.
 #define STRUCT_LIST(V)                                                       \
   V(BOX, Box, box)                                                           \
-  V(PROMISE_CONTAINER, PromiseContainer, promise_container)                  \
+  V(PROMISE_RESOLVE_THENABLE_JOB_INFO, PromiseResolveThenableJobInfo,        \
+    promise_resolve_thenable_job_info)                                       \
   V(PROMISE_REACTION_JOB_INFO, PromiseReactionJobInfo,                       \
     promise_reaction_job_info)                                               \
   V(ACCESSOR_INFO, AccessorInfo, accessor_info)                              \
@@ -692,7 +693,7 @@ enum InstanceType {
   TYPE_FEEDBACK_INFO_TYPE,
   ALIASED_ARGUMENTS_ENTRY_TYPE,
   BOX_TYPE,
-  PROMISE_CONTAINER_TYPE,
+  PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE,
   PROMISE_REACTION_JOB_INFO_TYPE,
   DEBUG_INFO_TYPE,
   BREAK_POINT_INFO_TYPE,
@@ -6682,8 +6683,7 @@ class Struct: public HeapObject {
 };
 
 // A container struct to hold state required for PromiseResolveThenableJob.
-// TODO(gsathya): Rename this to be less generic.
-class PromiseContainer : public Struct {
+class PromiseResolveThenableJobInfo : public Struct {
  public:
   DECL_ACCESSORS(thenable, JSReceiver)
   DECL_ACCESSORS(then, JSReceiver)
@@ -6701,12 +6701,12 @@ class PromiseContainer : public Struct {
       kBeforeDebugEventOffset + kPointerSize;
   static const int kSize = kAfterDebugEventOffset + kPointerSize;
 
-  DECLARE_CAST(PromiseContainer)
-  DECLARE_PRINTER(PromiseContainer)
-  DECLARE_VERIFIER(PromiseContainer)
+  DECLARE_CAST(PromiseResolveThenableJobInfo)
+  DECLARE_PRINTER(PromiseResolveThenableJobInfo)
+  DECLARE_VERIFIER(PromiseResolveThenableJobInfo)
 
  private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PromiseContainer);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PromiseResolveThenableJobInfo);
 };
 
 // Struct to hold state required for PromiseReactionJob.

src/runtime/runtime-internal.cc

@@ -596,9 +596,11 @@ RUNTIME_FUNCTION(Runtime_EnqueuePromiseResolveThenableJob) {
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, reject, 3);
   CONVERT_ARG_HANDLE_CHECKED(Object, before_debug_event, 4);
   CONVERT_ARG_HANDLE_CHECKED(Object, after_debug_event, 5);
-  Handle<PromiseContainer> container = isolate->factory()->NewPromiseContainer(
-      resolution, then, resolve, reject, before_debug_event, after_debug_event);
-  isolate->EnqueueMicrotask(container);
+  Handle<PromiseResolveThenableJobInfo> info =
+      isolate->factory()->NewPromiseResolveThenableJobInfo(
+          resolution, then, resolve, reject, before_debug_event,
+          after_debug_event);
+  isolate->EnqueueMicrotask(info);
   return isolate->heap()->undefined_value();
 }