[csa] Refactor promises API

src/builtins/builtins-promise.h

 // 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/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 typedef compiler::Node Node;
 typedef CodeStubAssembler::ParameterMode ParameterMode;
 typedef compiler::CodeAssemblerState CodeAssemblerState;
 
 class PromiseBuiltinsAssembler : public CodeStubAssembler {
  public:
   explicit PromiseBuiltinsAssembler(CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
-  Node* AllocateAndInitPromise(Node* context, Node* parent);
+  // These are just wrapper functions over the CSA counterparts and
+  // call out to the init promise hook.

[adamk, 2017/01/03 18:23:06]

This is really a question for caitp, I think, but do we ever want to allow a
builtin to allocate a promise without calling out to the promise hooks? It seems
like all promises need to flow through that code anyway.

[caitp, 2017/01/03 18:32:05]

I'm not sure if there are any situations where we're allowed to avoid the hook
call, so presumably not.

It's weird that CSA's method with the same name doesn't call the init hook, that
seems wrong to me.

+  Node* AllocateAndInitJSPromise(Node* context, Node* parent);
+  Node* AllocateAndSetJSPromise(Node* context, Node* status, Node* result,
+                                Node* parent);
 
   Node* ThrowIfNotJSReceiver(Node* context, Node* value,
                              MessageTemplate::Template msg_template);
 
   Node* SpeciesConstructor(Node* context, Node* object,
                            Node* default_constructor);
 
   Node* PromiseHasHandler(Node* promise);
 
   void PromiseSetHasHandler(Node* promise);
@@ skipping 17 matching lines @@
 
   Node* CreatePromiseResolvingFunctionsContext(Node* promise, Node* debug_event,
                                                Node* native_context);
 
   std::pair<Node*, Node*> CreatePromiseResolvingFunctions(
       Node* promise, Node* native_context, Node* promise_context);
 };
 
 }  // namespace internal
 }  // namespace v8