[csa] Refactor promises API

test/cctest/test-code-stub-assembler.cc

 // Copyright 2015 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/base/utils/random-number-generator.h"
 #include "src/builtins/builtins-promise.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/compiler/node.h"
 #include "src/isolate.h"
@@ skipping 1805 matching lines @@
 
   isolate->SetPromiseHook(CustomPromiseHook);
   result = ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK_EQ(isolate->heap()->true_value(), *result);
 
   isolate->SetPromiseHook(nullptr);
   result = ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK_EQ(isolate->heap()->false_value(), *result);
 }
 
-TEST(AllocateJSPromise) {
+TEST(AllocateAndInitJSPromise) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseInit(promise);
+  Node* const promise = m.AllocateAndInitJSPromise(context);
   m.Return(promise);
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result =
       ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK(result->IsJSPromise());
 }
 
-TEST(PromiseInit) {
+TEST(AllocateAndSetJSPromise) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseInit(promise);
+  Node* const promise = m.AllocateAndSetJSPromise(
+      context, m.SmiConstant(v8::Promise::kPending), m.SmiConstant(1));
   m.Return(promise);
 
   Handle<Code> code = data.GenerateCode();
-  CHECK(!code.is_null());
-
-  FunctionTester ft(code, kNumParams);
-  Handle<Object> result =
-      ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
-  CHECK(result->IsJSPromise());
-  Handle<JSPromise> js_promise = Handle<JSPromise>::cast(result);
-  CHECK_EQ(v8::Promise::kPending, js_promise->status());
-  CHECK_EQ(isolate->heap()->undefined_value(), js_promise->result());
-  CHECK(!js_promise->has_handler());
-}
-
-TEST(PromiseSet) {
-  Isolate* isolate(CcTest::InitIsolateOnce());
-
-  const int kNumParams = 1;
-  CodeAssemblerTester data(isolate, kNumParams);
-  CodeStubAssembler m(data.state());
-
-  Node* const context = m.Parameter(kNumParams + 2);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseSet(promise, m.SmiConstant(v8::Promise::kPending), m.SmiConstant(1));
-  m.Return(promise);
-
-  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result =
       ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK(result->IsJSPromise());
   Handle<JSPromise> js_promise = Handle<JSPromise>::cast(result);
   CHECK_EQ(v8::Promise::kPending, js_promise->status());
   CHECK_EQ(Smi::FromInt(1), js_promise->result());
   CHECK(!js_promise->has_handler());
 }
 
 TEST(AllocatePromiseReactionJobInfo) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseInit(promise);
+  Node* const promise = m.AllocateAndInitJSPromise(context);
   Node* const tasks = m.AllocateFixedArray(FAST_ELEMENTS, m.IntPtrConstant(1));
   m.StoreFixedArrayElement(tasks, 0, m.UndefinedConstant());
   Node* const deferred_promise =
       m.AllocateFixedArray(FAST_ELEMENTS, m.IntPtrConstant(1));
   m.StoreFixedArrayElement(deferred_promise, 0, m.UndefinedConstant());
   Node* const info = m.AllocatePromiseReactionJobInfo(
       promise, m.SmiConstant(1), tasks, deferred_promise, m.UndefinedConstant(),
       m.UndefinedConstant(), context);
   m.Return(info);
 
@@ skipping 65 matching lines @@
 }
 
 TEST(PromiseHasHandler) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   PromiseBuiltinsAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseInit(promise);
+  Node* const promise =
+      m.AllocateAndInitJSPromise(context, m.UndefinedConstant());
   m.Return(m.SelectBooleanConstant(m.PromiseHasHandler(promise)));
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result =
       ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK_EQ(isolate->heap()->false_value(), *result);
 }
 
 TEST(CreatePromiseResolvingFunctionsContext) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   PromiseBuiltinsAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
   Node* const native_context = m.LoadNativeContext(context);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseSet(promise, m.SmiConstant(v8::Promise::kPending), m.SmiConstant(1));
+  Node* const promise =
+      m.AllocateAndInitJSPromise(context, m.UndefinedConstant());
   Node* const promise_context = m.CreatePromiseResolvingFunctionsContext(
       promise, m.BooleanConstant(false), native_context);
   m.Return(promise_context);
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result =
       ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
@@ skipping 10 matching lines @@
 
 TEST(CreatePromiseResolvingFunctions) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   PromiseBuiltinsAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
   Node* const native_context = m.LoadNativeContext(context);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseSet(promise, m.SmiConstant(v8::Promise::kPending), m.SmiConstant(1));
+  Node* const promise =
+      m.AllocateAndInitJSPromise(context, m.UndefinedConstant());
   Node *resolve, *reject;
   std::tie(resolve, reject) = m.CreatePromiseResolvingFunctions(
       promise, m.BooleanConstant(false), native_context);
   Node* const kSize = m.IntPtrConstant(2);
   Node* const arr = m.AllocateFixedArray(FAST_ELEMENTS, kSize);
   m.StoreFixedArrayElement(arr, 0, resolve);
   m.StoreFixedArrayElement(arr, 1, reject);
   m.Return(arr);
 
   Handle<Code> code = data.GenerateCode();
@@ skipping 10 matching lines @@
 
 TEST(AllocateFunctionWithMapAndContext) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   PromiseBuiltinsAssembler m(data.state());
 
   Node* const context = m.Parameter(kNumParams + 2);
   Node* const native_context = m.LoadNativeContext(context);
-  Node* const promise = m.AllocateJSPromise(context);
-  m.PromiseSet(promise, m.SmiConstant(v8::Promise::kPending), m.SmiConstant(1));
+  Node* const promise =
+      m.AllocateAndInitJSPromise(context, m.UndefinedConstant());
   Node* promise_context = m.CreatePromiseResolvingFunctionsContext(
       promise, m.BooleanConstant(false), native_context);
   Node* resolve_info =
       m.LoadContextElement(native_context, Context::PROMISE_RESOLVE_SHARED_FUN);
   Node* const map = m.LoadContextElement(
       native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);
   Node* const resolve =
       m.AllocateFunctionWithMapAndContext(map, resolve_info, promise_context);
   m.Return(resolve);
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result_obj =
       ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
   CHECK(result_obj->IsJSFunction());
   Handle<JSFunction> fun = Handle<JSFunction>::cast(result_obj);
   CHECK_EQ(isolate->heap()->empty_fixed_array(), fun->properties());
   CHECK_EQ(isolate->heap()->empty_fixed_array(), fun->elements());
   CHECK_EQ(isolate->heap()->empty_literals_array(), fun->literals());
   CHECK_EQ(isolate->heap()->the_hole_value(), fun->prototype_or_initial_map());
   CHECK_EQ(*isolate->promise_resolve_shared_fun(), fun->shared());
   CHECK_EQ(isolate->promise_resolve_shared_fun()->code(), fun->code());
   CHECK_EQ(isolate->heap()->undefined_value(), fun->next_function_link());
 }
 
 }  // namespace internal
 }  // namespace v8