Implement yield* operator (#3923)

Missing features: - caching next() method (this also true for normal generators) - automatic sync to async generator conversion JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
2020-06-25 17:11:16 +02:00
parent c12c60c550
commit f88489beef
28 changed files with 1258 additions and 111 deletions
@@ -16,9 +16,13 @@
 #include "ecma-alloc.h"
 #include "ecma-async-generator-object.h"
 #include "ecma-builtins.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
 #include "ecma-iterator-object.h"
+#include "ecma-objects.h"
 #include "ecma-promise-object.h"
 #include "jcontext.h"
 #include "opcodes.h"
@@ -87,6 +91,98 @@ ecma_async_generator_enqueue (vm_executable_object_t *async_generator_object_p,
  return result;
 } /* ecma_async_generator_enqueue */

+/**
+ * Call a function and await its return value
+ *
+ * @return ECMA_VALUE_UNDEFINED on success, error otherwise
+ */
+static ecma_value_t
+ecma_async_yield_call (ecma_value_t function, /**< function (takes reference) */
+                       vm_executable_object_t *async_generator_object_p, /**< async generator */
+                       ecma_value_t argument, /**< argument passed to the function */
+                       const char *error_msg_p) /**< error message when the function is not callable */
+{
+  if (!ecma_is_value_object (function) || !ecma_op_is_callable (function))
+  {
+    ecma_free_value (function);
+    return ecma_raise_type_error (error_msg_p);
+  }
+
+  ecma_object_t *return_obj_p = ecma_get_object_from_value (function);
+  ecma_value_t iterator = async_generator_object_p->frame_ctx.block_result;
+  ecma_value_t result;
+
+  if (argument == ECMA_VALUE_EMPTY)
+  {
+    result = ecma_op_function_call (return_obj_p, iterator, NULL, 0);
+  }
+  else
+  {
+    result = ecma_op_function_call (return_obj_p, iterator, &argument, 1);
+  }
+
+  ecma_deref_object (return_obj_p);
+
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    return result;
+  }
+
+  return ecma_promise_async_await ((ecma_extended_object_t *) async_generator_object_p, result);
+} /* ecma_async_yield_call */
+
+/**
+ * Perform an exception throw and call the approprite handler
+ */
+static ecma_value_t
+ecma_async_yield_throw (vm_executable_object_t *async_generator_object_p, /**< async generator */
+                        ecma_value_t value) /**< thrown value */
+{
+  ecma_object_t *obj_p = ecma_get_object_from_value (async_generator_object_p->frame_ctx.block_result);
+  ecma_value_t result = ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_THROW);
+
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    return result;
+  }
+
+  if (result == ECMA_VALUE_UNDEFINED)
+  {
+    result = ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_RETURN);
+
+    if (result == ECMA_VALUE_UNDEFINED)
+    {
+      return ecma_raise_type_error (ECMA_ERR_MSG ("Iterator throw() is not available."));
+    }
+
+    result = ecma_async_yield_call (result,
+                                    async_generator_object_p,
+                                    ECMA_VALUE_EMPTY,
+                                    ECMA_ERR_MSG ("Iterator return() is not callable."));
+
+    if (ECMA_IS_VALUE_ERROR (result))
+    {
+      return result;
+    }
+
+    ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, CLOSE);
+    return ECMA_VALUE_UNDEFINED;
+  }
+
+  result = ecma_async_yield_call (result,
+                                  async_generator_object_p,
+                                  value,
+                                  ECMA_ERR_MSG ("Iterator throw() is not callable."));
+
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    return result;
+  }
+
+  ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
+  return ECMA_VALUE_UNDEFINED;
+} /* ecma_async_yield_throw */
+
 /**
 * Execute the next task in the command queue of the async generator
 */
@@ -99,26 +195,91 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<

  ecma_value_t head = async_generator_object_p->extended_object.u.class_prop.u.head;
  ecma_async_generator_task_t *task_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_async_generator_task_t, head);
+  ecma_value_t result;

-  if (task_p->operation_type == ECMA_ASYNC_GENERATOR_DO_RETURN)
-  {
-    async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
-  }
-  else if (task_p->operation_type == ECMA_ASYNC_GENERATOR_DO_THROW)
+  if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
  {
+    switch (task_p->operation_type)
+    {
+      case ECMA_ASYNC_GENERATOR_DO_NEXT:
+      {
+        result = ecma_op_iterator_next (async_generator_object_p->frame_ctx.block_result, task_p->operation_value);
+
+        if (ECMA_IS_VALUE_ERROR (result))
+        {
+          break;
+        }
+
+        result = ecma_promise_async_await ((ecma_extended_object_t *) async_generator_object_p, result);
+
+        if (ECMA_IS_VALUE_ERROR (result))
+        {
+          break;
+        }
+
+        ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
+        break;
+      }
+      case ECMA_ASYNC_GENERATOR_DO_THROW:
+      {
+        result = ecma_async_yield_throw (async_generator_object_p, task_p->operation_value);
+        break;
+      }
+      default:
+      {
+        JERRY_ASSERT (task_p->operation_type == ECMA_ASYNC_GENERATOR_DO_RETURN);
+
+        result = ecma_copy_value (task_p->operation_value);
+        result = ecma_promise_async_await ((ecma_extended_object_t *) async_generator_object_p, result);
+
+        if (ECMA_IS_VALUE_ERROR (result))
+        {
+          break;
+        }
+
+        ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, RETURN);
+        break;
+      }
+    }
+
+    ecma_free_value_if_not_object (task_p->operation_value);
+    task_p->operation_value = ECMA_VALUE_UNDEFINED;
+
+    if (result == ECMA_VALUE_UNDEFINED)
+    {
+      return;
+    }
+
+    JERRY_ASSERT (ECMA_IS_VALUE_ERROR (result));
+
+    ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
+    async_generator_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
    async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+
+    result = jcontext_take_exception ();
+  }
+  else
+  {
+    if (task_p->operation_type == ECMA_ASYNC_GENERATOR_DO_RETURN)
+    {
+      async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
+    }
+    else if (task_p->operation_type == ECMA_ASYNC_GENERATOR_DO_THROW)
+    {
+      async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+    }
+
+    result = task_p->operation_value;
+    ecma_ref_if_object (result);
+    task_p->operation_value = ECMA_VALUE_UNDEFINED;
  }

-  ecma_value_t value = task_p->operation_value;
-  ecma_ref_if_object (value);
-  task_p->operation_value = ECMA_VALUE_UNDEFINED;
-
-  value = opfunc_resume_executable_object (async_generator_object_p, value);
+  result = opfunc_resume_executable_object (async_generator_object_p, result);

  if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_COMPLETED)
  {
    JERRY_ASSERT (head == async_generator_object_p->extended_object.u.class_prop.u.head);
-    ecma_async_generator_finalize (async_generator_object_p, value);
+    ecma_async_generator_finalize (async_generator_object_p, result);
  }
 } /* ecma_async_generator_run */

@@ -132,8 +293,6 @@ ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p,
  ecma_value_t next = async_generator_object_p->extended_object.u.class_prop.u.head;
  ecma_async_generator_task_t *task_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_async_generator_task_t, next);

-  ECMA_SET_INTERNAL_VALUE_ANY_POINTER (async_generator_object_p->extended_object.u.class_prop.u.head, NULL);
-
  if (ECMA_IS_VALUE_ERROR (value))
  {
    value = jcontext_take_exception ();
@@ -149,6 +308,7 @@ ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p,
  ecma_free_value (value);

  next = task_p->next;
+  async_generator_object_p->extended_object.u.class_prop.u.head = next;
  jmem_heap_free_block (task_p, sizeof (ecma_async_generator_task_t));

  while (!ECMA_IS_INTERNAL_VALUE_NULL (next))
@@ -169,10 +329,126 @@ ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p,
    ecma_free_value_if_not_object (task_p->operation_value);

    next = task_p->next;
+    async_generator_object_p->extended_object.u.class_prop.u.head = next;
    jmem_heap_free_block (task_p, sizeof (ecma_async_generator_task_t));
  }
 } /* ecma_async_generator_finalize */

+/**
+ * Continue after an await operation is completed.
+ *
+ * @return an updated value for the value argument
+ */
+ecma_value_t
+ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_p, /**< async generator */
+                                 ecma_value_t value) /**< job value (takes reference) */
+{
+  switch (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p))
+  {
+    case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT:
+    case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_RETURN:
+    {
+      if (!ecma_is_value_object (value))
+      {
+        ecma_free_value (value);
+        return ecma_raise_type_error (ECMA_ERR_MSG ("Value received by yield* is not Object."));
+      }
+
+      ecma_object_t *result_obj_p = ecma_get_object_from_value (value);
+      ecma_value_t result = ecma_op_object_get_by_magic_id (result_obj_p, LIT_MAGIC_STRING_DONE);
+
+      if (ECMA_IS_VALUE_ERROR (result))
+      {
+        ecma_deref_object (result_obj_p);
+        return result;
+      }
+
+      bool done = ecma_op_to_boolean (result);
+      ecma_free_value (result);
+      result = ecma_op_object_get_by_magic_id (result_obj_p, LIT_MAGIC_STRING_VALUE);
+      ecma_deref_object (result_obj_p);
+
+      if (ECMA_IS_VALUE_ERROR (result))
+      {
+        return result;
+      }
+
+      if (!done)
+      {
+        ECMA_ASYNC_YIELD_ITERATOR_SET_STATE (async_generator_object_p, NEXT_VALUE);
+        return ecma_promise_async_await ((ecma_extended_object_t *) async_generator_object_p, result);
+      }
+
+      if (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p) == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT)
+      {
+        ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
+        return result;
+      }
+
+      ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
+      async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
+      return result;
+    }
+    case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN:
+    {
+      ecma_object_t *obj_p = ecma_get_object_from_value (async_generator_object_p->frame_ctx.block_result);
+      ecma_value_t result = ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_RETURN);
+
+      if (ECMA_IS_VALUE_ERROR (result))
+      {
+        ecma_free_value (value);
+        return result;
+      }
+
+      if (result == ECMA_VALUE_UNDEFINED)
+      {
+        ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
+        async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
+        return value;
+      }
+
+      result = ecma_async_yield_call (result,
+                                      async_generator_object_p,
+                                      value,
+                                      ECMA_ERR_MSG ("Iterator return() is not callable."));
+      ecma_free_value (value);
+
+      if (ECMA_IS_VALUE_ERROR (result))
+      {
+        return result;
+      }
+
+      JERRY_ASSERT (result == ECMA_VALUE_UNDEFINED);
+      ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, RETURN, NEXT_RETURN);
+      return ECMA_VALUE_UNDEFINED;
+    }
+    case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_VALUE:
+    {
+      ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, NEXT_VALUE, OPERATION);
+      opfunc_async_generator_yield ((ecma_extended_object_t *) async_generator_object_p, value);
+      return ECMA_VALUE_UNDEFINED;
+    }
+    case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_OPERATION:
+    {
+      /* Currently this is always a throw exception case. */
+      ecma_value_t result = ecma_async_yield_throw (async_generator_object_p, value);
+      ecma_free_value (value);
+      return result;
+    }
+    default:
+    {
+      JERRY_ASSERT (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p)
+                    == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_CLOSE);
+
+      const char *msg_p = (ecma_is_value_object (value) ? ECMA_ERR_MSG ("Iterator throw() is not available.")
+                                                        : ECMA_ERR_MSG ("Value received by yield* is not Object."));
+
+      ecma_free_value (value);
+      return ecma_raise_type_error (msg_p);
+    }
+  }
+} /* ecma_async_yield_continue_await */
+
 #endif /* ENABLED (JERRY_ESNEXT) */

 /**
@@ -38,12 +38,76 @@ typedef enum
  ECMA_ASYNC_GENERATOR_DO_RETURN, /**< async generator return operation */
 } ecma_async_generator_operation_type_t;

+/**
+ * AsyncGenerator yield iterator states.
+ */
+typedef enum
+{
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT, /**< wait for an iterator result object */
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_RETURN, /**< wait for an iterator result object after a return operation */
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN, /**< wait for the argument passed to return operation */
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_VALUE, /**< wait for the value property of an iterator result object */
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_OPERATION, /**< wait for the generator operation (next/throw/return) */
+  ECMA_ASYNC_YIELD_ITERATOR_AWAIT_CLOSE, /**< wait for the result of iterator close operation */
+} ecma_async_yield_iterator_states_t;
+
+/**
+ * Get the state of an async yield iterator.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_GET_STATE(async_generator_object_p) \
+  ((async_generator_object_p)->extended_object.u.class_prop.extra_info >> ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT)
+
+/**
+ * Set the state of an async yield iterator.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_SET_STATE(async_generator_object_p, to) \
+  do \
+  { \
+    uint16_t extra_info = (async_generator_object_p)->extended_object.u.class_prop.extra_info; \
+    extra_info &= ((1 << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT) - 1); \
+    extra_info |= (ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## to) << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT; \
+    (async_generator_object_p)->extended_object.u.class_prop.extra_info = extra_info; \
+  } \
+  while (false)
+
+/**
+ * Helper value for ECMA_ASYNC_YIELD_ITERATOR_END.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_END_MASK \
+  (((1 << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT) - 1) - ECMA_GENERATOR_ITERATE_AND_YIELD)
+
+/**
+ * Return from yield iterator.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_END(async_generator_object_p) \
+  ((async_generator_object_p)->extended_object.u.class_prop.extra_info &= ECMA_ASYNC_YIELD_ITERATOR_END_MASK)
+
+/**
+ * Helper macro for ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_CS1(from, to) \
+  ((ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## from) ^ (ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## to))
+
+/**
+ * Helper macro for ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_CS2(from, to) \
+  (ECMA_ASYNC_YIELD_ITERATOR_CS1(from, to) << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT)
+
+/**
+ * Change the state of an async yield iterator.
+ */
+#define ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE(async_generator_object_p, from, to) \
+  ((async_generator_object_p)->extended_object.u.class_prop.extra_info ^= ECMA_ASYNC_YIELD_ITERATOR_CS2 (from, to))
+
 ecma_value_t ecma_async_generator_enqueue (vm_executable_object_t *async_generator_object_p,
                                           ecma_async_generator_operation_type_t operation, ecma_value_t value);

 void ecma_async_generator_run (vm_executable_object_t *async_generator_object_p);
 void ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p, ecma_value_t value);

+ecma_value_t ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_p, ecma_value_t value);
+
 #endif /* ENABLED (JERRY_ESNEXT) */

 /**
@@ -439,7 +439,7 @@ ecma_op_container_create (const ecma_value_t *arguments_list_p, /**< arguments l

  ecma_object_t *adder_func_p = ecma_get_object_from_value (result);

-  result = ecma_op_get_iterator (iterable, ECMA_VALUE_EMPTY);
+  result = ecma_op_get_iterator (iterable, ECMA_VALUE_SYNC_ITERATOR);

  if (ECMA_IS_VALUE_ERROR (result))
  {
@@ -181,12 +181,13 @@ ecma_op_get_iterator (ecma_value_t value, /**< value to get iterator from */
    return value;
  }

-  /* 2. */
-  bool has_method = !ecma_is_value_empty (method);
+  bool has_method = false;

-  if (!has_method)
+  /* 2. */
+  if (method == ECMA_VALUE_SYNC_ITERATOR)
  {
    /* 2.a */
+    has_method = true;
    method = ecma_op_get_method_by_symbol_id (value, LIT_GLOBAL_SYMBOL_ITERATOR);

    /* 2.b */
@@ -195,6 +196,17 @@ ecma_op_get_iterator (ecma_value_t value, /**< value to get iterator from */
      return method;
    }
  }
+  else if (method == ECMA_VALUE_ASYNC_ITERATOR)
+  {
+    /* TODO: CreateAsyncFromSyncIterator should be supported. */
+    has_method = true;
+    method = ecma_op_get_method_by_symbol_id (value, LIT_GLOBAL_SYMBOL_ASYNC_ITERATOR);
+
+    if (ECMA_IS_VALUE_ERROR (method))
+    {
+      return method;
+    }
+  }

  /* 3. */
  if (!ecma_is_value_object (method) || !ecma_op_is_callable (method))
@@ -206,7 +218,7 @@ ecma_op_get_iterator (ecma_value_t value, /**< value to get iterator from */
  ecma_object_t *method_obj_p = ecma_get_object_from_value (method);
  ecma_value_t iterator = ecma_op_function_call (method_obj_p, value, NULL, 0);

-  if (!has_method)
+  if (has_method)
  {
    ecma_deref_object (method_obj_p);
  }
@@ -239,7 +251,7 @@ ecma_op_get_iterator (ecma_value_t value, /**< value to get iterator from */
 * @return iterator result object - if success
 *         raised error - otherwise
 */
-static ecma_value_t
+ecma_value_t
 ecma_op_iterator_next (ecma_value_t iterator, /**< iterator value */
                       ecma_value_t value) /**< the routines's value argument */
 {
@@ -59,6 +59,9 @@ ecma_op_get_iterator (ecma_value_t value, ecma_value_t method);
 ecma_value_t
 ecma_op_iterator_value (ecma_value_t iter_result);

+ecma_value_t
+ecma_op_iterator_next (ecma_value_t iterator, ecma_value_t value);
+
 ecma_value_t
 ecma_op_iterator_close (ecma_value_t iterator);

@@ -260,7 +260,49 @@ ecma_process_promise_async_reaction_job (ecma_job_promise_async_reaction_t *job_

  if (ecma_job_queue_get_type (&job_p->header) == ECMA_JOB_PROMISE_ASYNC_REACTION_REJECTED)
  {
-    executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+    if (!(executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD))
+    {
+      executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+    }
+    else if (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (executable_object_p) == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN)
+    {
+      /* Unlike other operations, return captures rejected promises as well. */
+      ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (executable_object_p, RETURN, OPERATION);
+    }
+    else
+    {
+      /* Exception: Abort iterators, clear all status. */
+      ECMA_ASYNC_YIELD_ITERATOR_END (executable_object_p);
+
+      JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
+      executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
+      executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+    }
+  }
+
+  if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
+  {
+    job_p->argument = ecma_async_yield_continue_await (executable_object_p, job_p->argument);
+
+    if (ECMA_IS_VALUE_ERROR (job_p->argument))
+    {
+      job_p->argument = jcontext_take_exception ();
+      executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
+    }
+    else if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
+    {
+      /* Continue iteration. */
+      JERRY_ASSERT (job_p->argument == ECMA_VALUE_UNDEFINED);
+
+      ecma_free_promise_async_reaction_job (job_p);
+      return ECMA_VALUE_UNDEFINED;
+    }
+
+    /* End of yield*, clear all status. */
+    ECMA_ASYNC_YIELD_ITERATOR_END (executable_object_p);
+
+    JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
+    executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
  }

  ecma_value_t result = opfunc_resume_executable_object (executable_object_p, job_p->argument);
@@ -979,6 +979,30 @@ ecma_promise_async_then (ecma_value_t promise, /**< promise object */
  ecma_free_value (value);
 } /* ecma_promise_async_then */

+/**
+ * Resolves the value and resume the execution of an async function after the resolve is completed
+ *
+ * @return ECMA_VALUE_UNDEFINED if not error is occured, an error otherwise
+ */
+ecma_value_t
+ecma_promise_async_await (ecma_extended_object_t *async_generator_object_p, /**< async generator function */
+                          ecma_value_t value) /**< value to be resolved (takes the reference) */
+{
+  ecma_value_t promise = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE));
+  ecma_value_t result = ecma_promise_reject_or_resolve (promise, value, true);
+
+  ecma_free_value (value);
+
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    return result;
+  }
+
+  ecma_promise_async_then (result, ecma_make_object_value ((ecma_object_t *) async_generator_object_p));
+  ecma_free_value (result);
+  return ECMA_VALUE_UNDEFINED;
+} /* ecma_promise_async_await */
+
 /**
 * @}
 * @}
@@ -92,6 +92,7 @@ ecma_value_t ecma_promise_new_capability (ecma_value_t constructor);
 ecma_value_t ecma_promise_reject_or_resolve (ecma_value_t this_arg, ecma_value_t value, bool is_resolve);
 ecma_value_t ecma_promise_then (ecma_value_t promise, ecma_value_t on_fulfilled, ecma_value_t on_rejected);
 void ecma_promise_async_then (ecma_value_t promise, ecma_value_t executable_object);
+ecma_value_t ecma_promise_async_await (ecma_extended_object_t *async_generator_object_p, ecma_value_t value);
 void ecma_promise_create_resolving_functions (ecma_object_t *object_p, ecma_promise_resolving_functions_t *funcs,
                                              bool create_already_resolved);
 void ecma_promise_free_resolving_functions (ecma_promise_resolving_functions_t *funcs);