[promises] Move CreateResolvingFunctions to c++

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-utils.h"
+#include "src/builtins/builtins.h"
+
+namespace v8 {
+namespace internal {
+
+enum PromiseResolvingFunctionContextSlot {
+  kAlreadyVisitedSlot = 4,

[adamk, 2016/11/09 00:06:23]

Should this 4 be Context::MIN_CONTEXT_SLOTS or something?

[gsathya, 2016/11/09 00:57:33]

Done.

+  kPromiseSlot,
+  kDebugEventSlot,
+};
+
+BUILTIN(PromiseResolveClosure) {

[adamk, 2016/11/09 00:06:23]

Can you add a comment here about what this relates to in the spec?

[gsathya, 2016/11/09 00:57:33]

Done.

+  HandleScope scope(isolate);
+
+  Handle<Object> value = args.atOrUndefined(isolate, 1);

[adamk, 2016/11/09 00:06:23]

Please move this down to where it's actually used, no need to pull it out before
the bailout.

[gsathya, 2016/11/09 00:57:33]

Done.

+  Handle<Context> context(isolate->context(), isolate);
+  Handle<Smi> already_visited(Smi::cast(context->get(kAlreadyVisitedSlot)),
+                              isolate);
+
+  if (already_visited->value() != 0) {
+    return isolate->heap()->undefined_value();
+  }
+
+  context->set(kAlreadyVisitedSlot, Smi::FromInt(1));
+  Handle<JSObject> promise(JSObject::cast(context->get(kPromiseSlot)), isolate);
+
+  MaybeHandle<Object> maybe_result;
+  Handle<Object> argv[] = {promise, value};
+  maybe_result = Execution::Call(isolate, isolate->promise_resolve(),

[adamk, 2016/11/09 00:06:23]

RETURN_FAILURE_ON_EXCEPTION here, I think.

[gsathya, 2016/11/09 00:57:33]

Done.

+                                 isolate->factory()->undefined_value(),
+                                 arraysize(argv), argv);
+  return isolate->heap()->undefined_value();
+}
+
+BUILTIN(PromiseRejectClosure) {

[adamk, 2016/11/09 00:06:23]

Same here, spec reference? And below.

[gsathya, 2016/11/09 00:57:33]

Done.

+  HandleScope scope(isolate);
+
+  Handle<Object> value = args.atOrUndefined(isolate, 1);

[adamk, 2016/11/09 00:06:23]

Same thing, this can move down to where it's used.

[gsathya, 2016/11/09 00:57:33]

Done.

+  Handle<Context> context(isolate->context(), isolate);
+  Handle<Smi> already_visited(Smi::cast(context->get(kAlreadyVisitedSlot)),
+                              isolate);
+
+  if (already_visited->value() != 0) {
+    return isolate->heap()->undefined_value();
+  }
+
+  context->set(kAlreadyVisitedSlot, Smi::FromInt(1));
+
+  Handle<JSObject> promise(JSObject::cast(context->get(kPromiseSlot)), isolate);
+  Handle<Object> debug_event(context->get(kDebugEventSlot), isolate);
+  MaybeHandle<Object> maybe_result;
+  Handle<Object> argv[] = {promise, value, debug_event};
+  maybe_result = Execution::Call(isolate, isolate->promise_internal_reject(),

[adamk, 2016/11/09 00:06:23]

RETURN_FAILURE_ON_EXCEPTION

[gsathya, 2016/11/09 00:57:33]

Done.

+                                 isolate->factory()->undefined_value(),
+                                 arraysize(argv), argv);
+  return isolate->heap()->undefined_value();
+}
+
+BUILTIN(CreateResolvingFunctions) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(3, args.length());
+
+  Handle<JSObject> promise = args.at<JSObject>(1);
+  Handle<Object> debug_event = args.at<Object>(2);
+
+  Handle<Context> context =
+      isolate->factory()->NewPromiseResolvingFunctionContext();
+  context->set_native_context(*isolate->native_context());
+  context->set(kAlreadyVisitedSlot, Smi::kZero);
+  context->set(kPromiseSlot, *promise);
+  context->set(kDebugEventSlot, *debug_event);
+
+  Handle<SharedFunctionInfo> resolve_shared_fun(
+      isolate->native_context()->promise_resolve_shared_fun(), isolate);
+  Handle<JSFunction> resolve =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          isolate->sloppy_function_without_prototype_map(), resolve_shared_fun,
+          isolate->native_context(), TENURED);
+
+  Handle<SharedFunctionInfo> reject_shared_fun(
+      isolate->native_context()->promise_reject_shared_fun(), isolate);
+  Handle<JSFunction> reject =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          isolate->sloppy_function_without_prototype_map(), reject_shared_fun,
+          isolate->native_context(), TENURED);
+
+  resolve->set_context(*context);
+  reject->set_context(*context);
+
+  Handle<FixedArray> result = isolate->factory()->NewFixedArray(2);
+  result->set(0, *resolve);
+  result->set(1, *reject);
+
+  return *isolate->factory()->NewJSArrayWithElements(result, FAST_ELEMENTS, 2,
+                                                     NOT_TENURED);
+}
+
+}  // namespace internal
+}  // namespace v8