[promises] Clean up promise utils and remove dead code

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-promise.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
-#include "src/promise-utils.h"
 
 namespace v8 {
 namespace internal {
 
 typedef compiler::Node Node;
 typedef CodeStubAssembler::ParameterMode ParameterMode;
 typedef compiler::CodeAssemblerState CodeAssemblerState;
 
 Node* PromiseBuiltinsAssembler::AllocateJSPromise(Node* context) {
   Node* const native_context = LoadNativeContext(context);
@@ skipping 182 matching lines @@
   StoreContextElementNoWriteBarrier(context, Context::EXTENSION_INDEX,
                                     TheHoleConstant());
   StoreContextElementNoWriteBarrier(context, Context::NATIVE_CONTEXT_INDEX,
                                     native_context);
   return context;
 }
 
 Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(
     Node* promise, Node* debug_event, Node* native_context) {
   Node* const context =
-      CreatePromiseContext(native_context, PromiseUtils::kPromiseContextLength);
-  StoreContextElementNoWriteBarrier(context, PromiseUtils::kAlreadyVisitedSlot,
+      CreatePromiseContext(native_context, kPromiseContextLength);
+  StoreContextElementNoWriteBarrier(context, kAlreadyVisitedSlot,
                                     SmiConstant(0));
-  StoreContextElementNoWriteBarrier(context, PromiseUtils::kPromiseSlot,
-                                    promise);
-  StoreContextElementNoWriteBarrier(context, PromiseUtils::kDebugEventSlot,
-                                    debug_event);
+  StoreContextElementNoWriteBarrier(context, kPromiseSlot, promise);
+  StoreContextElementNoWriteBarrier(context, kDebugEventSlot, debug_event);
   return context;
 }
 
 Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext(
     Node* promise_capability, Node* native_context) {
-  int kContextLength = GetPromiseCapabilityExecutor::kContextLength;
+  int kContextLength = kCapabilitiesContextLength;
   Node* context = CreatePromiseContext(native_context, kContextLength);
-  StoreContextElementNoWriteBarrier(
-      context, GetPromiseCapabilityExecutor::kCapabilitySlot,
-      promise_capability);
+  StoreContextElementNoWriteBarrier(context, kCapabilitySlot,
+                                    promise_capability);
   return context;
 }
 
 Node* PromiseBuiltinsAssembler::ThrowIfNotJSReceiver(
     Node* context, Node* value, MessageTemplate::Template msg_template,
     const char* method_name) {
   Label out(this), throw_exception(this, Label::kDeferred);
   Variable var_value_map(this, MachineRepresentation::kTagged);
 
   GotoIf(TaggedIsSmi(value), &throw_exception);
@@ skipping 738 matching lines @@
 
 // ES#sec-promise-reject-functions
 // Promise Reject Functions
 TF_BUILTIN(PromiseRejectClosure, PromiseBuiltinsAssembler) {
   Node* const value = Parameter(1);
   Node* const context = Parameter(4);
 
   Label out(this);
 
   // 3. Let alreadyResolved be F.[[AlreadyResolved]].
-  int has_already_visited_slot = PromiseUtils::kAlreadyVisitedSlot;
+  int has_already_visited_slot = kAlreadyVisitedSlot;
 
   Node* const has_already_visited =
       LoadContextElement(context, has_already_visited_slot);
 
   // 4. If alreadyResolved.[[Value]] is true, return undefined.
   GotoIf(SmiEqual(has_already_visited, SmiConstant(1)), &out);
 
   // 5.Set alreadyResolved.[[Value]] to true.
   StoreContextElementNoWriteBarrier(context, has_already_visited_slot,
                                     SmiConstant(1));
 
   // 2. Let promise be F.[[Promise]].
   Node* const promise =
-      LoadContextElement(context, IntPtrConstant(PromiseUtils::kPromiseSlot));
-  Node* const debug_event = LoadContextElement(
-      context, IntPtrConstant(PromiseUtils::kDebugEventSlot));
+      LoadContextElement(context, IntPtrConstant(kPromiseSlot));
+  Node* const debug_event =
+      LoadContextElement(context, IntPtrConstant(kDebugEventSlot));
 
   InternalPromiseReject(context, promise, value, debug_event);
   Return(UndefinedConstant());
 
   Bind(&out);
   Return(UndefinedConstant());
 }
 
 TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) {
   Node* const executor = Parameter(1);
@@ skipping 170 matching lines @@
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions
 TF_BUILTIN(PromiseResolveClosure, PromiseBuiltinsAssembler) {
   Node* const value = Parameter(1);
   Node* const context = Parameter(4);
 
   Label out(this);
 
   // 3. Let alreadyResolved be F.[[AlreadyResolved]].
-  int has_already_visited_slot = PromiseUtils::kAlreadyVisitedSlot;
+  int has_already_visited_slot = kAlreadyVisitedSlot;
 
   Node* const has_already_visited =
       LoadContextElement(context, has_already_visited_slot);
 
   // 4. If alreadyResolved.[[Value]] is true, return undefined.
   GotoIf(SmiEqual(has_already_visited, SmiConstant(1)), &out);
 
   // 5.Set alreadyResolved.[[Value]] to true.
   StoreContextElementNoWriteBarrier(context, has_already_visited_slot,
                                     SmiConstant(1));
 
   // 2. Let promise be F.[[Promise]].
   Node* const promise =
-      LoadContextElement(context, IntPtrConstant(PromiseUtils::kPromiseSlot));
+      LoadContextElement(context, IntPtrConstant(kPromiseSlot));
 
   InternalResolvePromise(context, promise, value);
   Return(UndefinedConstant());
 
   Bind(&out);
   Return(UndefinedConstant());
 }
 
 TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) {
   Node* const promise = Parameter(1);
@@ skipping 232 matching lines @@
       Return(result);
     }
   }
 }
 
 TF_BUILTIN(PromiseGetCapabilitiesExecutor, PromiseBuiltinsAssembler) {
   Node* const resolve = Parameter(1);
   Node* const reject = Parameter(2);
   Node* const context = Parameter(5);
 
-  Node* const capability = LoadContextElement(
-      context, GetPromiseCapabilityExecutor::kCapabilitySlot);
+  Node* const capability = LoadContextElement(context, kCapabilitySlot);
 
   Label if_alreadyinvoked(this, Label::kDeferred);
   GotoIf(WordNotEqual(
              LoadObjectField(capability, JSPromiseCapability::kResolveOffset),
              UndefinedConstant()),
          &if_alreadyinvoked);
   GotoIf(WordNotEqual(
              LoadObjectField(capability, JSPromiseCapability::kRejectOffset),
              UndefinedConstant()),
          &if_alreadyinvoked);
@@ skipping 67 matching lines @@
   Node* const reason = Parameter(2);
   Node* const debug_event = Parameter(3);
   Node* const context = Parameter(6);
 
   InternalPromiseReject(context, promise, reason, debug_event);
   Return(UndefinedConstant());
 }
 
 }  // namespace internal
 }  // namespace v8