1// Copyright 2017 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/base/optional.h"
6#include "src/builtins/builtins-async-gen.h"
7#include "src/builtins/builtins-utils-gen.h"
8#include "src/builtins/builtins.h"
9#include "src/codegen/code-factory.h"
10#include "src/codegen/code-stub-assembler.h"
11#include "src/execution/frames-inl.h"
12
13namespace v8 {
14namespace internal {
15
16namespace {
17class AsyncFromSyncBuiltinsAssembler : public AsyncBuiltinsAssembler {
18 public:
19  // The 'next' and 'return' take an optional value parameter, and the 'throw'
20  // method take an optional reason parameter.
21  static const int kValueOrReasonArg = 0;
22
23  explicit AsyncFromSyncBuiltinsAssembler(compiler::CodeAssemblerState* state)
24      : AsyncBuiltinsAssembler(state) {}
25
26  void ThrowIfNotAsyncFromSyncIterator(const TNode<Context> context,
27                                       const TNode<Object> object,
28                                       Label* if_exception,
29                                       TVariable<Object>* var_exception,
30                                       const char* method_name);
31
32  using UndefinedMethodHandler =
33      std::function<void(const TNode<NativeContext> native_context,
34                         const TNode<JSPromise> promise, Label* if_exception)>;
35  using SyncIteratorNodeGenerator =
36      std::function<TNode<Object>(TNode<JSReceiver>)>;
37  void Generate_AsyncFromSyncIteratorMethod(
38      CodeStubArguments* args, const TNode<Context> context,
39      const TNode<Object> iterator, const TNode<Object> sent_value,
40      const SyncIteratorNodeGenerator& get_method,
41      const UndefinedMethodHandler& if_method_undefined,
42      const char* operation_name,
43      Label::Type reject_label_type = Label::kDeferred,
44      base::Optional<TNode<Object>> initial_exception_value = base::nullopt);
45
46  void Generate_AsyncFromSyncIteratorMethod(
47      CodeStubArguments* args, const TNode<Context> context,
48      const TNode<Object> iterator, const TNode<Object> sent_value,
49      Handle<String> name, const UndefinedMethodHandler& if_method_undefined,
50      const char* operation_name,
51      Label::Type reject_label_type = Label::kDeferred,
52      base::Optional<TNode<Object>> initial_exception_value = base::nullopt) {
53    auto get_method = [=](const TNode<JSReceiver> sync_iterator) {
54      return GetProperty(context, sync_iterator, name);
55    };
56    return Generate_AsyncFromSyncIteratorMethod(
57        args, context, iterator, sent_value, get_method, if_method_undefined,
58        operation_name, reject_label_type, initial_exception_value);
59  }
60
61  // Load "value" and "done" from an iterator result object. If an exception
62  // is thrown at any point, jumps to the `if_exception` label with exception
63  // stored in `var_exception`.
64  //
65  // Returns a Pair of Nodes, whose first element is the value of the "value"
66  // property, and whose second element is the value of the "done" property,
67  // converted to a Boolean if needed.
68  std::pair<TNode<Object>, TNode<Oddball>> LoadIteratorResult(
69      const TNode<Context> context, const TNode<NativeContext> native_context,
70      const TNode<Object> iter_result, Label* if_exception,
71      TVariable<Object>* var_exception);
72};
73
74void AsyncFromSyncBuiltinsAssembler::ThrowIfNotAsyncFromSyncIterator(
75    const TNode<Context> context, const TNode<Object> object,
76    Label* if_exception, TVariable<Object>* var_exception,
77    const char* method_name) {
78  Label if_receiverisincompatible(this, Label::kDeferred), done(this);
79
80  GotoIf(TaggedIsSmi(object), &if_receiverisincompatible);
81  Branch(HasInstanceType(CAST(object), JS_ASYNC_FROM_SYNC_ITERATOR_TYPE), &done,
82         &if_receiverisincompatible);
83
84  BIND(&if_receiverisincompatible);
85  {
86    // If Type(O) is not Object, or if O does not have a [[SyncIterator]]
87    // internal slot, then
88
89    // Let badIteratorError be a new TypeError exception.
90    TNode<HeapObject> error =
91        MakeTypeError(MessageTemplate::kIncompatibleMethodReceiver, context,
92                      StringConstant(method_name), object);
93
94    // Perform ! Call(promiseCapability.[[Reject]], undefined,
95    //                « badIteratorError »).
96    *var_exception = error;
97    Goto(if_exception);
98  }
99
100  BIND(&done);
101}
102
103void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod(
104    CodeStubArguments* args, const TNode<Context> context,
105    const TNode<Object> iterator, const TNode<Object> sent_value,
106    const SyncIteratorNodeGenerator& get_method,
107    const UndefinedMethodHandler& if_method_undefined,
108    const char* operation_name, Label::Type reject_label_type,
109    base::Optional<TNode<Object>> initial_exception_value) {
110  const TNode<NativeContext> native_context = LoadNativeContext(context);
111  const TNode<JSPromise> promise = NewJSPromise(context);
112
113  TVARIABLE(
114      Object, var_exception,
115      initial_exception_value ? *initial_exception_value : UndefinedConstant());
116  Label reject_promise(this, reject_label_type);
117
118  ThrowIfNotAsyncFromSyncIterator(context, iterator, &reject_promise,
119                                  &var_exception, operation_name);
120
121  TNode<JSAsyncFromSyncIterator> async_iterator = CAST(iterator);
122  const TNode<JSReceiver> sync_iterator = LoadObjectField<JSReceiver>(
123      async_iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset);
124
125  TNode<Object> method = get_method(sync_iterator);
126
127  if (if_method_undefined) {
128    Label if_isnotundefined(this);
129
130    GotoIfNot(IsNullOrUndefined(method), &if_isnotundefined);
131    if_method_undefined(native_context, promise, &reject_promise);
132
133    BIND(&if_isnotundefined);
134  }
135
136  TVARIABLE(Object, iter_result);
137  {
138    Label has_sent_value(this), no_sent_value(this), merge(this);
139    ScopedExceptionHandler handler(this, &reject_promise, &var_exception);
140    Branch(IntPtrGreaterThan(args->GetLengthWithoutReceiver(),
141                             IntPtrConstant(kValueOrReasonArg)),
142           &has_sent_value, &no_sent_value);
143    BIND(&has_sent_value);
144    {
145      iter_result = Call(context, method, sync_iterator, sent_value);
146      Goto(&merge);
147    }
148    BIND(&no_sent_value);
149    {
150      iter_result = Call(context, method, sync_iterator);
151      Goto(&merge);
152    }
153    BIND(&merge);
154  }
155
156  TNode<Object> value;
157  TNode<Oddball> done;
158  std::tie(value, done) =
159      LoadIteratorResult(context, native_context, iter_result.value(),
160                         &reject_promise, &var_exception);
161
162  const TNode<JSFunction> promise_fun =
163      CAST(LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX));
164  CSA_DCHECK(this, IsConstructor(promise_fun));
165
166  // Let valueWrapper be PromiseResolve(%Promise%, « value »).
167  // IfAbruptRejectPromise(valueWrapper, promiseCapability).
168  TNode<Object> value_wrapper;
169  {
170    ScopedExceptionHandler handler(this, &reject_promise, &var_exception);
171    value_wrapper = CallBuiltin(Builtin::kPromiseResolve, native_context,
172                                promise_fun, value);
173  }
174
175  // Let onFulfilled be a new built-in function object as defined in
176  // Async Iterator Value Unwrap Functions.
177  // Set onFulfilled.[[Done]] to throwDone.
178  const TNode<JSFunction> on_fulfilled =
179      CreateUnwrapClosure(native_context, done);
180
181  // Perform ! PerformPromiseThen(valueWrapper,
182  //     onFulfilled, undefined, promiseCapability).
183  args->PopAndReturn(CallBuiltin(Builtin::kPerformPromiseThen, context,
184                                 value_wrapper, on_fulfilled,
185                                 UndefinedConstant(), promise));
186
187  BIND(&reject_promise);
188  {
189    const TNode<Object> exception = var_exception.value();
190    CallBuiltin(Builtin::kRejectPromise, context, promise, exception,
191                TrueConstant());
192    args->PopAndReturn(promise);
193  }
194}
195
196std::pair<TNode<Object>, TNode<Oddball>>
197AsyncFromSyncBuiltinsAssembler::LoadIteratorResult(
198    const TNode<Context> context, const TNode<NativeContext> native_context,
199    const TNode<Object> iter_result, Label* if_exception,
200    TVariable<Object>* var_exception) {
201  Label if_fastpath(this), if_slowpath(this), merge(this), to_boolean(this),
202      done(this), if_notanobject(this, Label::kDeferred);
203  GotoIf(TaggedIsSmi(iter_result), &if_notanobject);
204
205  const TNode<Map> iter_result_map = LoadMap(CAST(iter_result));
206  GotoIfNot(IsJSReceiverMap(iter_result_map), &if_notanobject);
207
208  const TNode<Object> fast_iter_result_map =
209      LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
210
211  TVARIABLE(Object, var_value);
212  TVARIABLE(Object, var_done);
213  Branch(TaggedEqual(iter_result_map, fast_iter_result_map), &if_fastpath,
214         &if_slowpath);
215
216  BIND(&if_fastpath);
217  {
218    TNode<JSObject> fast_iter_result = CAST(iter_result);
219    var_done = LoadObjectField(fast_iter_result, JSIteratorResult::kDoneOffset);
220    var_value =
221        LoadObjectField(fast_iter_result, JSIteratorResult::kValueOffset);
222    Goto(&merge);
223  }
224
225  BIND(&if_slowpath);
226  {
227    ScopedExceptionHandler handler(this, if_exception, var_exception);
228
229    // Let nextDone be IteratorComplete(nextResult).
230    // IfAbruptRejectPromise(nextDone, promiseCapability).
231    const TNode<Object> iter_result_done =
232        GetProperty(context, iter_result, factory()->done_string());
233
234    // Let nextValue be IteratorValue(nextResult).
235    // IfAbruptRejectPromise(nextValue, promiseCapability).
236    const TNode<Object> iter_result_value =
237        GetProperty(context, iter_result, factory()->value_string());
238
239    var_value = iter_result_value;
240    var_done = iter_result_done;
241    Goto(&merge);
242  }
243
244  BIND(&if_notanobject);
245  {
246    // Sync iterator result is not an object --- Produce a TypeError and jump
247    // to the `if_exception` path.
248    const TNode<Object> error = MakeTypeError(
249        MessageTemplate::kIteratorResultNotAnObject, context, iter_result);
250    *var_exception = error;
251    Goto(if_exception);
252  }
253
254  BIND(&merge);
255  // Ensure `iterResult.done` is a Boolean.
256  GotoIf(TaggedIsSmi(var_done.value()), &to_boolean);
257  Branch(IsBoolean(CAST(var_done.value())), &done, &to_boolean);
258
259  BIND(&to_boolean);
260  {
261    const TNode<Object> result =
262        CallBuiltin(Builtin::kToBoolean, context, var_done.value());
263    var_done = result;
264    Goto(&done);
265  }
266
267  BIND(&done);
268  return std::make_pair(var_value.value(), CAST(var_done.value()));
269}
270
271}  // namespace
272
273// https://tc39.github.io/proposal-async-iteration/
274// Section #sec-%asyncfromsynciteratorprototype%.next
275TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler) {
276  TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
277      UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
278  CodeStubArguments args(this, argc);
279
280  const TNode<Object> iterator = args.GetReceiver();
281  const TNode<Object> value = args.GetOptionalArgumentValue(kValueOrReasonArg);
282  const auto context = Parameter<Context>(Descriptor::kContext);
283
284  auto get_method = [=](const TNode<JSReceiver> unused) {
285    return LoadObjectField(CAST(iterator),
286                           JSAsyncFromSyncIterator::kNextOffset);
287  };
288  Generate_AsyncFromSyncIteratorMethod(
289      &args, context, iterator, value, get_method, UndefinedMethodHandler(),
290      "[Async-from-Sync Iterator].prototype.next");
291}
292
293// https://tc39.github.io/proposal-async-iteration/
294// Section #sec-%asyncfromsynciteratorprototype%.return
295TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn,
296           AsyncFromSyncBuiltinsAssembler) {
297  TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
298      UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
299  CodeStubArguments args(this, argc);
300
301  const TNode<Object> iterator = args.GetReceiver();
302  const TNode<Object> value = args.GetOptionalArgumentValue(kValueOrReasonArg);
303  const auto context = Parameter<Context>(Descriptor::kContext);
304
305  auto if_return_undefined = [=, &args](
306                                 const TNode<NativeContext> native_context,
307                                 const TNode<JSPromise> promise,
308                                 Label* if_exception) {
309    // If return is undefined, then
310    // Let iterResult be ! CreateIterResultObject(value, true)
311    const TNode<Object> iter_result = CallBuiltin(
312        Builtin::kCreateIterResultObject, context, value, TrueConstant());
313
314    // Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »).
315    // IfAbruptRejectPromise(nextDone, promiseCapability).
316    // Return promiseCapability.[[Promise]].
317    CallBuiltin(Builtin::kResolvePromise, context, promise, iter_result);
318    args.PopAndReturn(promise);
319  };
320
321  Generate_AsyncFromSyncIteratorMethod(
322      &args, context, iterator, value, factory()->return_string(),
323      if_return_undefined, "[Async-from-Sync Iterator].prototype.return");
324}
325
326// https://tc39.github.io/proposal-async-iteration/
327// Section #sec-%asyncfromsynciteratorprototype%.throw
328TF_BUILTIN(AsyncFromSyncIteratorPrototypeThrow,
329           AsyncFromSyncBuiltinsAssembler) {
330  TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
331      UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
332  CodeStubArguments args(this, argc);
333
334  const TNode<Object> iterator = args.GetReceiver();
335  const TNode<Object> reason = args.GetOptionalArgumentValue(kValueOrReasonArg);
336  const auto context = Parameter<Context>(Descriptor::kContext);
337
338  auto if_throw_undefined = [=](const TNode<NativeContext> native_context,
339                                const TNode<JSPromise> promise,
340                                Label* if_exception) { Goto(if_exception); };
341
342  Generate_AsyncFromSyncIteratorMethod(
343      &args, context, iterator, reason, factory()->throw_string(),
344      if_throw_undefined, "[Async-from-Sync Iterator].prototype.throw",
345      Label::kNonDeferred, reason);
346}
347
348}  // namespace internal
349}  // namespace v8
350