YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement for-await-of statement. (#3946)

Browse Source 
AsyncIteratorClose has not supported yet.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
This commit is contained in:
Zoltan Herczeg
2020-06-30 11:21:50 +02:00
committed by GitHub
parent 0b404ea893
commit 5535ea88ac
20 changed files with 729 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/ecma/base/ecma-gc.c
+30 -1
View File
@@ -466,7 +466,36 @@ ecma_gc_mark_executable_object (ecma_object_t *object_p) /**< object */
register_p++;
}
register_p += executable_object_p->frame_ctx.context_depth;
if (executable_object_p->frame_ctx.context_depth > 0)
{
ecma_value_t *context_end_p = register_p;
register_p += executable_object_p->frame_ctx.context_depth;
ecma_value_t *context_top_p = register_p;
do
{
uint32_t offsets = vm_get_context_value_offsets (context_top_p);
while (VM_CONTEXT_HAS_NEXT_OFFSET (offsets))
{
int32_t offset = VM_CONTEXT_GET_NEXT_OFFSET (offsets);
if (ecma_is_value_object (context_top_p[offset]))
{
ecma_gc_set_object_visited (ecma_get_object_from_value (context_top_p[offset]));
}
offsets >>= VM_CONTEXT_OFFSET_SHIFT;
}
JERRY_ASSERT (context_top_p >= context_end_p + offsets);
context_top_p -= offsets;
}
while (context_top_p > context_end_p);
}
register_end_p = executable_object_p->frame_ctx.stack_top_p;
while (register_p < register_end_p)
jerry-core/ecma/base/ecma-globals.h
+34 -2
View File
@@ -1865,18 +1865,50 @@ typedef enum
ECMA_EXECUTABLE_OBJECT_COMPLETED = (1u << 0), /**< executable object is completed and cannot be resumed */
ECMA_EXECUTABLE_OBJECT_RUNNING = (1u << 1), /**< executable object is currently running */
/* Generator specific flags. */
ECMA_GENERATOR_ITERATE_AND_YIELD = (1u << 2), /**< the generator performs a yield* operation */
ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD = (1u << 2), /**< the executable object performs
* an await or a yield* operation */
ECMA_ASYNC_GENERATOR_CALLED = (1u << 3), /**< the async generator was executed before */
/* This must be the last generator specific flag. */
ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT = 4, /**< shift for async yield iterator state */
ECMA_AWAIT_STATE_SHIFT = 4, /**< shift for await states */
} ecma_executable_object_flags_t;
/**
* Async function states after an await is completed.
*/
typedef enum
{
ECMA_AWAIT_YIELD_NEXT, /**< wait for an iterator result object */
ECMA_AWAIT_YIELD_NEXT_RETURN, /**< wait for an iterator result object after a return operation */
ECMA_AWAIT_YIELD_RETURN, /**< wait for the argument passed to return operation */
ECMA_AWAIT_YIELD_NEXT_VALUE, /**< wait for the value property of an iterator result object */
ECMA_AWAIT_YIELD_OPERATION, /**< wait for the generator operation (next/throw/return) */
ECMA_AWAIT_YIELD_CLOSE, /**< wait for the result of iterator close operation */
/* After adding new ECMA_AWAIT_YIELD items, the ECMA_AWAIT_YIELD_END should be updated. */
ECMA_AWAIT_FOR_NEXT, /**< wait for an iterator result object of for-await-of statement */
} ecma_await_states_t;
/**
* Checks whether the executable object is waiting for resuming.
*/
#define ECMA_EXECUTABLE_OBJECT_IS_SUSPENDED(extra_info) \
(!((extra_info) & (ECMA_EXECUTABLE_OBJECT_COMPLETED | ECMA_EXECUTABLE_OBJECT_RUNNING)))
/**
* Last item of yield* related await states.
*/
#define ECMA_AWAIT_YIELD_END ECMA_AWAIT_YIELD_CLOSE
/**
* Helper macro for ECMA_EXECUTABLE_OBJECT_RESUME_EXEC.
*/
#define ECMA_EXECUTABLE_OBJECT_RESUME_EXEC_MASK ((uint16_t) ~ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
/**
* Resume execution of the byte code.
*/
#define ECMA_EXECUTABLE_OBJECT_RESUME_EXEC(executable_object_p) \
((executable_object_p)->extended_object.u.class_prop.extra_info &= ECMA_EXECUTABLE_OBJECT_RESUME_EXEC_MASK)
/**
* Enqueued task of an AsyncGenerator.
*
jerry-core/ecma/builtin-objects/ecma-builtin-generator-prototype.c
+3 -3
View File
@@ -91,7 +91,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
while (true)
{
if (generator_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (generator_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
ecma_value_t iterator = generator_object_p->frame_ctx.block_result;
ecma_value_t next_method = generator_object_p->frame_ctx.stack_top_p[-1];
@@ -119,7 +119,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
return result;
}
generator_object_p->extended_object.u.class_prop.extra_info &= (uint16_t) ~ECMA_GENERATOR_ITERATE_AND_YIELD;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (generator_object_p);
generator_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (generator_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
@@ -173,7 +173,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
}
ecma_deref_object (ecma_get_object_from_value (iterator));
generator_object_p->extended_object.u.class_prop.extra_info |= ECMA_GENERATOR_ITERATE_AND_YIELD;
generator_object_p->extended_object.u.class_prop.extra_info |= ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD;
generator_object_p->frame_ctx.block_result = iterator;
if (generator_object_p->frame_ctx.stack_top_p[0] != ECMA_VALUE_UNDEFINED)
jerry-core/ecma/operations/ecma-async-generator-object.c
+93 -35
View File
@@ -27,6 +27,7 @@
#include "jcontext.h"
#include "opcodes.h"
#include "vm.h"
#include "vm-stack.h"
#if ENABLED (JERRY_ESNEXT)
@@ -165,7 +166,7 @@ ecma_async_yield_throw (vm_executable_object_t *async_generator_object_p, /**< a
return result;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, CLOSE);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_CLOSE);
return ECMA_VALUE_UNDEFINED;
}
@@ -179,7 +180,7 @@ ecma_async_yield_throw (vm_executable_object_t *async_generator_object_p, /**< a
return result;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_NEXT);
return ECMA_VALUE_UNDEFINED;
} /* ecma_async_yield_throw */
@@ -197,7 +198,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
ecma_async_generator_task_t *task_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_async_generator_task_t, head);
ecma_value_t result;
if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
switch (task_p->operation_type)
{
@@ -219,7 +220,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
break;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_NEXT);
break;
}
case ECMA_ASYNC_GENERATOR_DO_THROW:
@@ -239,7 +240,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
break;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, RETURN);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_RETURN);
break;
}
}
@@ -254,7 +255,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
JERRY_ASSERT (ECMA_IS_VALUE_ERROR (result));
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
async_generator_object_p->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
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;
@@ -346,13 +347,15 @@ ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p,
* @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) */
ecma_await_continue (vm_executable_object_t *executable_object_p, /**< executable object */
ecma_value_t value) /**< job value (takes reference) */
{
switch (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p))
ecma_await_states_t state = (ecma_await_states_t) ECMA_AWAIT_GET_STATE (executable_object_p);
switch (state)
{
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT:
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_RETURN:
case ECMA_AWAIT_YIELD_NEXT:
case ECMA_AWAIT_YIELD_NEXT_RETURN:
{
if (!ecma_is_value_object (value))
{
@@ -381,23 +384,21 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
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);
ECMA_AWAIT_SET_STATE (executable_object_p, YIELD_NEXT_VALUE);
return ecma_promise_async_await ((ecma_extended_object_t *) executable_object_p, result);
}
if (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p) == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT)
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
if (state == ECMA_AWAIT_YIELD_NEXT_RETURN)
{
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
return result;
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
}
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:
case ECMA_AWAIT_YIELD_RETURN:
{
ecma_object_t *obj_p = ecma_get_object_from_value (async_generator_object_p->frame_ctx.block_result);
ecma_object_t *obj_p = ecma_get_object_from_value (executable_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))
@@ -408,13 +409,13 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
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;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
executable_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,
executable_object_p,
value,
ECMA_ERR_MSG ("Iterator return() is not callable."));
ecma_free_value (value);
@@ -425,35 +426,92 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
}
JERRY_ASSERT (result == ECMA_VALUE_UNDEFINED);
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, RETURN, NEXT_RETURN);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_RETURN, YIELD_NEXT_RETURN);
return ECMA_VALUE_UNDEFINED;
}
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_VALUE:
case ECMA_AWAIT_YIELD_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);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_NEXT_VALUE, YIELD_OPERATION);
opfunc_async_generator_yield ((ecma_extended_object_t *) executable_object_p, value);
return ECMA_VALUE_UNDEFINED;
}
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_OPERATION:
case ECMA_AWAIT_YIELD_OPERATION:
{
/* Currently this is always a throw exception case. */
ecma_value_t result = ecma_async_yield_throw (async_generator_object_p, value);
ecma_value_t result = ecma_async_yield_throw (executable_object_p, value);
ecma_free_value (value);
return result;
}
default:
case ECMA_AWAIT_YIELD_CLOSE:
{
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);
}
default:
{
JERRY_ASSERT (state == ECMA_AWAIT_FOR_NEXT);
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (executable_object_p->frame_ctx.stack_top_p[-1]) == VM_CONTEXT_FOR_AWAIT_OF);
if (!ecma_is_value_object (value))
{
ecma_free_value (value);
return ecma_raise_type_error (ECMA_ERR_MSG ("Value received by for-async-of 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);
ecma_value_t *stack_top_p = executable_object_p->frame_ctx.stack_top_p;
JERRY_ASSERT (stack_top_p[-2] == ECMA_VALUE_UNDEFINED);
JERRY_ASSERT (ecma_is_value_object (stack_top_p[-3]));
JERRY_ASSERT (stack_top_p[-4] == ECMA_VALUE_UNDEFINED || ecma_is_value_object (stack_top_p[-4]));
if (!done)
{
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;
}
/* It seems browsers call Await(result) here, although the standard does not
* requests to do so. The following code might follow browsers in the future. */
ecma_deref_if_object (result);
stack_top_p[-2] = result;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
return ECMA_VALUE_EMPTY;
}
ecma_deref_object (result_obj_p);
/* This code jumps to the end regardless of the byte code which triggered this await. */
uint32_t context_end = VM_GET_CONTEXT_END (stack_top_p[-1]);
executable_object_p->frame_ctx.byte_code_p = executable_object_p->frame_ctx.byte_code_start_p + context_end;
VM_MINUS_EQUAL_U16 (executable_object_p->frame_ctx.context_depth,
PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION);
stack_top_p -= PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION;
executable_object_p->frame_ctx.stack_top_p = stack_top_p;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
return ECMA_VALUE_EMPTY;
}
}
} /* ecma_async_yield_continue_await */
} /* ecma_await_continue */
#endif /* ENABLED (JERRY_ESNEXT) */
jerry-core/ecma/operations/ecma-async-generator-object.h
+14 -39
View File
@@ -38,67 +38,42 @@ 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)
#define ECMA_AWAIT_GET_STATE(async_generator_object_p) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info >> ECMA_AWAIT_STATE_SHIFT)
/**
* Set the state of an async yield iterator.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_SET_STATE(async_generator_object_p, to) \
#define ECMA_AWAIT_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; \
extra_info &= ((1 << ECMA_AWAIT_STATE_SHIFT) - 1); \
extra_info |= (ECMA_AWAIT_ ## to) << ECMA_AWAIT_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.
* Mask for clearing all ASYNC_AWAIT status bits
*/
#define ECMA_ASYNC_YIELD_ITERATOR_END_MASK \
(((1 << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT) - 1) - ECMA_GENERATOR_ITERATE_AND_YIELD)
#define ECMA_AWAIT_CLEAR_MASK \
(((1 << ECMA_AWAIT_STATE_SHIFT) - 1) - ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
/**
* Return from yield iterator.
* Helper macro for ECMA_AWAIT_CHANGE_STATE.
*/
#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)
#define ECMA_AWAIT_CS_HELPER(from, to) \
(((ECMA_AWAIT_ ## from) ^ (ECMA_AWAIT_ ## to)) << ECMA_AWAIT_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))
#define ECMA_AWAIT_CHANGE_STATE(async_generator_object_p, from, to) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info ^= ECMA_AWAIT_CS_HELPER (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);
@@ -106,7 +81,7 @@ ecma_value_t ecma_async_generator_enqueue (vm_executable_object_t *async_generat
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);
ecma_value_t ecma_await_continue (vm_executable_object_t *async_generator_object_p, ecma_value_t value);
#endif /* ENABLED (JERRY_ESNEXT) */
jerry-core/ecma/operations/ecma-jobqueue.c
+27 -21
View File
@@ -260,40 +260,43 @@ 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)
{
if (!(executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD))
if (!(executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_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)
else if (ECMA_AWAIT_GET_STATE (executable_object_p) == ECMA_AWAIT_YIELD_RETURN)
{
/* Unlike other operations, return captures rejected promises as well. */
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (executable_object_p, RETURN, OPERATION);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_RETURN, YIELD_OPERATION);
}
else
{
if (ECMA_AWAIT_GET_STATE (executable_object_p) <= ECMA_AWAIT_YIELD_END)
{
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
/* 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->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
}
if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
job_p->argument = ecma_async_yield_continue_await (executable_object_p, job_p->argument);
job_p->argument = ecma_await_continue (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)
else if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
/* Continue iteration. */
JERRY_ASSERT (job_p->argument == ECMA_VALUE_UNDEFINED);
@@ -302,15 +305,18 @@ ecma_process_promise_async_reaction_job (ecma_job_promise_async_reaction_t *job_
return ECMA_VALUE_UNDEFINED;
}
/* End of yield*, clear all status. */
ECMA_ASYNC_YIELD_ITERATOR_END (executable_object_p);
if (ECMA_AWAIT_GET_STATE (executable_object_p) <= ECMA_AWAIT_YIELD_END)
{
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
/* Clear all status. */
executable_object_p->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
}
ecma_value_t result = opfunc_resume_executable_object (executable_object_p, job_p->argument);
jerry-core/include/jerryscript-snapshot.h
+1 -1
View File
@@ -30,7 +30,7 @@ extern "C"
/**
* Jerry snapshot format version.
*/
#define JERRY_SNAPSHOT_VERSION (51u)
#define JERRY_SNAPSHOT_VERSION (52u)
/**
* Flags for jerry_generate_snapshot and jerry_generate_function_snapshot.
jerry-core/parser/js/byte-code.c
+1 -1
View File
@@ -27,7 +27,7 @@ JERRY_STATIC_ASSERT ((sizeof (cbc_uint16_arguments_t) % sizeof (jmem_cpointer_t)
*/
JERRY_STATIC_ASSERT (CBC_END == 238,
number_of_cbc_opcodes_changed);
JERRY_STATIC_ASSERT (CBC_EXT_END == 121,
JERRY_STATIC_ASSERT (CBC_EXT_END == 127,
number_of_cbc_ext_opcodes_changed);
#if ENABLED (JERRY_PARSER)
jerry-core/parser/js/byte-code.h
+14 -8
View File
@@ -196,6 +196,8 @@
#define PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION 4
/* PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION must be <= 4 */
#define PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION 4
/* PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION must be <= 4 */
#define PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION 4
/* PARSER_WITH_CONTEXT_STACK_ALLOCATION must be <= 4 */
#define PARSER_WITH_CONTEXT_STACK_ALLOCATION 1
/* PARSER_BLOCK_CONTEXT_STACK_ALLOCATION must be <= 3 */
@@ -536,20 +538,28 @@
-1 + PARSER_WITH_CONTEXT_STACK_ALLOCATION, VM_OC_WITH) \
CBC_OPCODE (CBC_EXT_FOR_IN_GET_NEXT, CBC_NO_FLAG, 1, \
VM_OC_FOR_IN_GET_NEXT | VM_OC_PUT_STACK) \
CBC_FORWARD_BRANCH (CBC_EXT_FOR_IN_CREATE_CONTEXT, \
-1 + PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION, VM_OC_FOR_IN_CREATE_CONTEXT) \
CBC_FORWARD_BRANCH (CBC_EXT_FOR_IN_INIT, \
-1 + PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION, VM_OC_FOR_IN_INIT) \
CBC_OPCODE (CBC_EXT_SET_GETTER, CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2, 0, \
VM_OC_SET_GETTER | VM_OC_NON_STATIC_FLAG | VM_OC_GET_LITERAL_LITERAL) \
CBC_BACKWARD_BRANCH (CBC_EXT_BRANCH_IF_FOR_IN_HAS_NEXT, 0, \
VM_OC_FOR_IN_HAS_NEXT) \
CBC_OPCODE (CBC_EXT_FOR_OF_GET_NEXT, CBC_NO_FLAG, 1, \
VM_OC_FOR_OF_GET_NEXT | VM_OC_PUT_STACK) \
CBC_FORWARD_BRANCH (CBC_EXT_FOR_OF_CREATE_CONTEXT, \
-1 + PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION, VM_OC_FOR_OF_CREATE_CONTEXT) \
CBC_FORWARD_BRANCH (CBC_EXT_FOR_OF_INIT, \
-1 + PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION, VM_OC_FOR_OF_INIT) \
CBC_OPCODE (CBC_EXT_PUSH_NAMED_FUNC_EXPRESSION, CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2, 1, \
VM_OC_PUSH_NAMED_FUNC_EXPR | VM_OC_GET_LITERAL_LITERAL) \
CBC_BACKWARD_BRANCH (CBC_EXT_BRANCH_IF_FOR_OF_HAS_NEXT, 0, \
VM_OC_FOR_OF_HAS_NEXT) \
CBC_OPCODE (CBC_EXT_CLONE_CONTEXT, CBC_NO_FLAG, 0, \
VM_OC_CLONE_CONTEXT) \
CBC_FORWARD_BRANCH (CBC_EXT_FOR_AWAIT_OF_INIT, \
-1 + PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION, VM_OC_FOR_AWAIT_OF_INIT) \
CBC_OPCODE (CBC_EXT_CLONE_FULL_CONTEXT, CBC_NO_FLAG, 0, \
VM_OC_CLONE_CONTEXT) \
CBC_BACKWARD_BRANCH (CBC_EXT_BRANCH_IF_FOR_AWAIT_OF_HAS_NEXT, 0, \
VM_OC_FOR_AWAIT_OF_HAS_NEXT) \
CBC_OPCODE (CBC_EXT_SET_SETTER, CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2, 0, \
VM_OC_SET_SETTER | VM_OC_NON_STATIC_FLAG | VM_OC_GET_LITERAL_LITERAL) \
CBC_FORWARD_BRANCH (CBC_EXT_TRY_CREATE_CONTEXT, PARSER_TRY_CONTEXT_STACK_ALLOCATION, \
@@ -588,10 +598,6 @@
VM_OC_STRING_CONCAT | VM_OC_GET_LITERAL_LITERAL | VM_OC_PUT_STACK) \
CBC_OPCODE (CBC_EXT_GET_TAGGED_TEMPLATE_LITERAL, CBC_HAS_BYTE_ARG, 1, \
VM_OC_GET_TEMPLATE_OBJECT | VM_OC_PUT_STACK) \
CBC_OPCODE (CBC_EXT_CLONE_CONTEXT, CBC_NO_FLAG, 0, \
VM_OC_CLONE_CONTEXT) \
CBC_OPCODE (CBC_EXT_CLONE_FULL_CONTEXT, CBC_NO_FLAG, 0, \
VM_OC_CLONE_CONTEXT) \
CBC_OPCODE (CBC_EXT_LINE, CBC_NO_FLAG, 0, \
VM_OC_LINE) \
CBC_OPCODE (CBC_EXT_ERROR, CBC_NO_FLAG, 0, \
jerry-core/parser/js/js-parser-statm.c
+88 -20
View File
@@ -60,6 +60,7 @@ typedef enum
PARSER_STATEMENT_FOR_IN,
#if ENABLED (JERRY_ESNEXT)
PARSER_STATEMENT_FOR_OF,
PARSER_STATEMENT_FOR_AWAIT_OF,
#endif /* ENABLED (JERRY_ESNEXT) */
PARSER_STATEMENT_WITH,
PARSER_STATEMENT_TRY,
@@ -119,6 +120,8 @@ static const uint8_t parser_statement_flags[] =
#if ENABLED (JERRY_ESNEXT)
/* PARSER_STATEMENT_FOR_OF */
PARSER_STATM_BREAK_TARGET | PARSER_STATM_CONTINUE_TARGET | PARSER_STATM_SINGLE_STATM | PARSER_STATM_CONTEXT_BREAK,
/* PARSER_STATEMENT_FOR_AWAIT_OF */
PARSER_STATM_BREAK_TARGET | PARSER_STATM_CONTINUE_TARGET | PARSER_STATM_SINGLE_STATM | PARSER_STATM_CONTEXT_BREAK,
#endif /* ENABLED (JERRY_ESNEXT) */
/* PARSER_STATEMENT_WITH */
PARSER_STATM_CONTEXT_BREAK | PARSER_STATM_SINGLE_STATM,
@@ -291,6 +294,8 @@ parser_statement_length (uint8_t type) /**< type of statement */
#if ENABLED (JERRY_ESNEXT)
/* PARSER_STATEMENT_FOR_OF */
(uint8_t) (sizeof (parser_for_in_of_statement_t) + sizeof (parser_loop_statement_t) + 1),
/* PARSER_STATEMENT_FOR_AWAIT_OF */
(uint8_t) (sizeof (parser_for_in_of_statement_t) + sizeof (parser_loop_statement_t) + 1),
#endif /* ENABLED (JERRY_ESNEXT) */
/* PARSER_STATEMENT_WITH */
(uint8_t) (sizeof (parser_with_statement_t) + 1 + 1),
@@ -1198,8 +1203,30 @@ parser_parse_for_statement_start (parser_context_t *context_p) /**< context */
JERRY_ASSERT (context_p->token.type == LEXER_KEYW_FOR);
lexer_next_token (context_p);
#if ENABLED (JERRY_ESNEXT)
bool is_for_await = false;
if (context_p->token.type == LEXER_KEYW_AWAIT)
{
if (JERRY_UNLIKELY (context_p->token.lit_location.has_escape))
{
parser_raise_error (context_p, PARSER_ERR_INVALID_KEYWORD);
}
lexer_next_token (context_p);
is_for_await = true;
}
#endif /* ENABLED (JERRY_ESNEXT) */
if (context_p->token.type != LEXER_LEFT_PAREN)
{
#if ENABLED (JERRY_ESNEXT)
if (context_p->token.type == LEXER_LITERAL
&& context_p->token.keyword_type == LEXER_KEYW_AWAIT
&& !context_p->token.lit_location.has_escape)
{
parser_raise_error (context_p, PARSER_ERR_FOR_AWAIT_NO_ASYNC);
}
#endif /* ENABLED (JERRY_ESNEXT) */
parser_raise_error (context_p, PARSER_ERR_LEFT_PAREN_EXPECTED);
}
@@ -1274,6 +1301,16 @@ parser_parse_for_statement_start (parser_context_t *context_p) /**< context */
const uint8_t *source_end_p = context_p->source_p - 2;
scanner_seek (context_p);
#if ENABLED (JERRY_ESNEXT)
if (is_for_in && is_for_await)
{
context_p->token.line = context_p->line;
context_p->token.column = context_p->column - 2;
parser_raise_error (context_p, PARSER_ERR_FOR_AWAIT_NO_OF);
}
#endif /* ENABLED (JERRY_ESNEXT) */
lexer_next_token (context_p);
parser_parse_expression (context_p, PARSE_EXPR);
@@ -1288,10 +1325,16 @@ parser_parse_for_statement_start (parser_context_t *context_p) /**< context */
: PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION);
#endif /* !JERRY_NDEBUG */
parser_emit_cbc_ext_forward_branch (context_p,
is_for_in ? CBC_EXT_FOR_IN_CREATE_CONTEXT
: CBC_EXT_FOR_OF_CREATE_CONTEXT,
&for_in_of_statement.branch);
cbc_ext_opcode_t init_opcode = CBC_EXT_FOR_IN_INIT;
#if ENABLED (JERRY_ESNEXT)
if (!is_for_in)
{
init_opcode = is_for_await ? CBC_EXT_FOR_AWAIT_OF_INIT : CBC_EXT_FOR_OF_INIT;
}
#endif /* ENABLED (JERRY_ESNEXT) */
parser_emit_cbc_ext_forward_branch (context_p, init_opcode, &for_in_of_statement.branch);
JERRY_ASSERT (context_p->last_cbc_opcode == PARSER_CBC_UNAVAILABLE);
for_in_of_statement.start_offset = context_p->byte_code_size;
@@ -1443,12 +1486,17 @@ parser_parse_for_statement_start (parser_context_t *context_p) /**< context */
parser_stack_push (context_p, &for_in_of_statement, sizeof (parser_for_in_of_statement_t));
parser_stack_push (context_p, &loop, sizeof (parser_loop_statement_t));
uint8_t for_type = PARSER_STATEMENT_FOR_IN;
#if ENABLED (JERRY_ESNEXT)
parser_stack_push_uint8 (context_p, is_for_in ? PARSER_STATEMENT_FOR_IN
: PARSER_STATEMENT_FOR_OF);
#else /* !ENABLED (JERRY_ESNEXT) */
parser_stack_push_uint8 (context_p, PARSER_STATEMENT_FOR_IN);
if (!is_for_in)
{
for_type = is_for_await ? PARSER_STATEMENT_FOR_AWAIT_OF : PARSER_STATEMENT_FOR_OF;
}
#endif /* ENABLED (JERRY_ESNEXT) */
parser_stack_push_uint8 (context_p, for_type);
parser_stack_iterator_init (context_p, &context_p->last_statement);
return;
}
@@ -1515,6 +1563,13 @@ parser_parse_for_statement_start (parser_context_t *context_p) /**< context */
}
}
#if ENABLED (JERRY_ESNEXT)
if (is_for_await)
{
parser_raise_error (context_p, PARSER_ERR_FOR_AWAIT_NO_OF);
}
#endif /* ENABLED (JERRY_ESNEXT) */
JERRY_ASSERT (context_p->next_scanner_info_p->source_p != context_p->source_p
|| context_p->next_scanner_info_p->type == SCANNER_TYPE_FOR);
@@ -3286,15 +3341,14 @@ consume_last_statement:
case PARSER_STATEMENT_FOR_IN:
#if ENABLED (JERRY_ESNEXT)
case PARSER_STATEMENT_FOR_OF:
case PARSER_STATEMENT_FOR_AWAIT_OF:
#endif /* ENABLED (JERRY_ESNEXT) */
{
parser_for_in_of_statement_t for_in_of_statement;
parser_loop_statement_t loop;
#if ENABLED (JERRY_ESNEXT)
bool is_for_in = (context_p->stack_top_uint8 == PARSER_STATEMENT_FOR_IN);
#else
bool is_for_in = true;
uint8_t for_type = context_p->stack_top_uint8;
#endif /* ENABLED (JERRY_ESNEXT) */
parser_stack_pop_uint8 (context_p);
@@ -3305,18 +3359,32 @@ consume_last_statement:
parser_set_continues_to_current_position (context_p, loop.branch_list_p);
parser_flush_cbc (context_p);
PARSER_MINUS_EQUAL_U16 (context_p->stack_depth, is_for_in ? PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION
: PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION);
uint16_t stack_allocation = PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION;
#if ENABLED (JERRY_ESNEXT)
if (for_type != PARSER_STATEMENT_FOR_IN)
{
stack_allocation = (for_type == PARSER_STATEMENT_FOR_OF ? PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION
: PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION);
}
#endif /* ENABLED (JERRY_ESNEXT) */
PARSER_MINUS_EQUAL_U16 (context_p->stack_depth, stack_allocation);
#ifndef JERRY_NDEBUG
PARSER_MINUS_EQUAL_U16 (context_p->context_stack_depth,
is_for_in ? PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION
: PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION);
PARSER_MINUS_EQUAL_U16 (context_p->context_stack_depth, stack_allocation);
#endif /* !JERRY_NDEBUG */
parser_emit_cbc_ext_backward_branch (context_p,
is_for_in ? CBC_EXT_BRANCH_IF_FOR_IN_HAS_NEXT
: CBC_EXT_BRANCH_IF_FOR_OF_HAS_NEXT,
for_in_of_statement.start_offset);
cbc_ext_opcode_t opcode = CBC_EXT_BRANCH_IF_FOR_IN_HAS_NEXT;
#if ENABLED (JERRY_ESNEXT)
if (for_type != PARSER_STATEMENT_FOR_IN)
{
opcode = (for_type == PARSER_STATEMENT_FOR_OF ? CBC_EXT_BRANCH_IF_FOR_OF_HAS_NEXT
: CBC_EXT_BRANCH_IF_FOR_AWAIT_OF_HAS_NEXT);
}
#endif /* ENABLED (JERRY_ESNEXT) */
parser_emit_cbc_ext_backward_branch (context_p, opcode, for_in_of_statement.start_offset);
parser_set_breaks_to_current_position (context_p, loop.branch_list_p);
parser_set_branch_to_current_position (context_p, &for_in_of_statement.branch);
jerry-core/parser/js/js-parser-util.c
+8
View File
@@ -956,6 +956,14 @@ parser_error_to_string (parser_error_t error) /**< error code */
{
return "for in-of loop variable declaration may not have an initializer.";
}
case PARSER_ERR_FOR_AWAIT_NO_ASYNC:
{
return "for-await-of is only allowed inside async functions and generators.";
}
case PARSER_ERR_FOR_AWAIT_NO_OF:
{
return "only 'of' form is allowed for for-await loops.";
}
case PARSER_ERR_DUPLICATED_PROTO:
{
return "Duplicate __proto__ fields are not allowed in object literals.";
jerry-core/parser/js/js-parser.h
+2
View File
@@ -82,6 +82,8 @@ typedef enum
PARSER_ERR_YIELD_NOT_ALLOWED, /**< yield expression is not allowed */
PARSER_ERR_AWAIT_NOT_ALLOWED, /**< await expression is not allowed */
PARSER_ERR_FOR_IN_OF_DECLARATION, /**< variable declaration in for-in or for-of loop */
PARSER_ERR_FOR_AWAIT_NO_ASYNC, /**< for-await-of is only allowed inside async functions */
PARSER_ERR_FOR_AWAIT_NO_OF, /**< only 'of' form is allowed for for-await loops */
PARSER_ERR_DUPLICATED_PROTO, /**< duplicated __proto__ fields are not allowed */
#endif /* ENABLED (JERRY_ESNEXT) */
PARSER_ERR_DELETE_IDENT_NOT_ALLOWED, /**< identifier delete is not allowed in strict mode */
jerry-core/parser/js/js-scanner.c
+8
View File
@@ -1181,6 +1181,14 @@ scanner_scan_statement (parser_context_t *context_p, /**< context */
case LEXER_KEYW_FOR:
{
lexer_next_token (context_p);
#if ENABLED (JERRY_ESNEXT)
if (context_p->token.type == LEXER_KEYW_AWAIT)
{
lexer_next_token (context_p);
}
#endif /* ENABLED (JERRY_ESNEXT) */
if (context_p->token.type != LEXER_LEFT_PAREN)
{
scanner_raise_error (context_p);
jerry-core/vm/opcodes.c
+54 -3
View File
@@ -730,6 +730,12 @@ opfunc_resume_executable_object (vm_executable_object_t *executable_object_p, /*
ecma_value_t *stack_top_p = executable_object_p->frame_ctx.stack_top_p;
if (value != ECMA_VALUE_EMPTY)
{
*stack_top_p = value;
executable_object_p->frame_ctx.stack_top_p = stack_top_p + 1;
}
if (executable_object_p->frame_ctx.context_depth > 0)
{
while (register_p < register_end_p)
@@ -752,9 +758,6 @@ opfunc_resume_executable_object (vm_executable_object_t *executable_object_p, /*
ecma_ref_if_object (executable_object_p->frame_ctx.block_result);
*register_p++ = value;
executable_object_p->frame_ctx.stack_top_p = register_p;
JERRY_ASSERT (ECMA_EXECUTABLE_OBJECT_IS_SUSPENDED (executable_object_p->extended_object.u.class_prop.extra_info));
executable_object_p->extended_object.u.class_prop.extra_info |= ECMA_EXECUTABLE_OBJECT_RUNNING;
@@ -840,6 +843,54 @@ opfunc_async_generator_yield (ecma_extended_object_t *async_generator_object_p,
}
} /* opfunc_async_generator_yield */
/**
* Creates a new executable object and awaits for the value
*
* Note:
* extra_flags can be used to set additional extra_info flags
*
* @return a new Promise object on success, error otherwise
*/
ecma_value_t
opfunc_async_create_and_await (vm_frame_ctx_t *frame_ctx_p, /**< frame context */
ecma_value_t value, /**< awaited value (takes reference) */
uint16_t extra_flags) /**< extra flags */
{
JERRY_ASSERT (frame_ctx_p->block_result == ECMA_VALUE_UNDEFINED);
/* TODO: An CBC_FUNCTION_ASYNC_ARROW should be defined. */
JERRY_ASSERT (CBC_FUNCTION_GET_TYPE (frame_ctx_p->bytecode_header_p->status_flags) == CBC_FUNCTION_ASYNC
|| CBC_FUNCTION_GET_TYPE (frame_ctx_p->bytecode_header_p->status_flags) == CBC_FUNCTION_ARROW);
ecma_object_t *promise_p = ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE);
ecma_value_t result = ecma_promise_reject_or_resolve (ecma_make_object_value (promise_p), value, true);
ecma_free_value (value);
if (ECMA_IS_VALUE_ERROR (result))
{
return result;
}
vm_executable_object_t *executable_object_p;
executable_object_p = opfunc_create_executable_object (frame_ctx_p, VM_CREATE_EXECUTABLE_OBJECT_ASYNC);
executable_object_p->extended_object.u.class_prop.extra_info |= extra_flags;
ecma_promise_async_then (result, ecma_make_object_value ((ecma_object_t *) executable_object_p));
ecma_deref_object ((ecma_object_t *) executable_object_p);
ecma_free_value (result);
ecma_object_t *old_new_target_p = JERRY_CONTEXT (current_new_target);
JERRY_CONTEXT (current_new_target) = promise_p;
result = ecma_op_create_promise_object (ECMA_VALUE_EMPTY, ECMA_PROMISE_EXECUTOR_EMPTY);
JERRY_ASSERT (ecma_is_value_object (result));
executable_object_p->frame_ctx.block_result = result;
JERRY_CONTEXT (current_new_target) = old_new_target_p;
return result;
} /* opfunc_async_create_and_await */
/**
* Implicit class constructor handler when the classHeritage is not present.
*
jerry-core/vm/opcodes.h
+3
View File
@@ -138,6 +138,9 @@ opfunc_resume_executable_object (vm_executable_object_t *executable_object_p, ec
void
opfunc_async_generator_yield (ecma_extended_object_t *async_generator_object_p, ecma_value_t value);
ecma_value_t
opfunc_async_create_and_await (vm_frame_ctx_t *frame_ctx_p, ecma_value_t value, uint16_t extra_flags);
ecma_value_t
opfunc_create_implicit_class_constructor (uint8_t opcode);
jerry-core/vm/vm-stack.c
+17 -10
View File
@@ -28,10 +28,13 @@
*/
JERRY_STATIC_ASSERT (PARSER_WITH_CONTEXT_STACK_ALLOCATION == PARSER_BLOCK_CONTEXT_STACK_ALLOCATION,
parser_with_context_stack_allocation_must_be_equal_to_parser_block_context_stack_allocation);
with_context_stack_allocation_must_be_equal_to_block_context_stack_allocation);
JERRY_STATIC_ASSERT (PARSER_WITH_CONTEXT_STACK_ALLOCATION == PARSER_TRY_CONTEXT_STACK_ALLOCATION,
parser_with_context_stack_allocation_must_be_equal_to_parser_block_context_stack_allocation);
with_context_stack_allocation_must_be_equal_to_block_context_stack_allocation);
JERRY_STATIC_ASSERT (PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION == PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION,
for_of_context_stack_allocation_must_be_equal_to_for_await_of_context_stack_allocation);
/**
* Abort (finalize) the current stack context, and remove it.
@@ -79,6 +82,7 @@ vm_stack_context_abort (vm_frame_ctx_t *frame_ctx_p, /**< frame context */
}
#if ENABLED (JERRY_ESNEXT)
case VM_CONTEXT_FOR_OF:
case VM_CONTEXT_FOR_AWAIT_OF:
{
ecma_value_t iterator = vm_stack_top_p[-3];
ecma_free_value (vm_stack_top_p[-2]);
@@ -313,7 +317,7 @@ vm_stack_find_finally (vm_frame_ctx_t *frame_ctx_p, /**< frame context */
#if ENABLED (JERRY_ESNEXT)
/**
* Get the offsets of ecma values from the specified item of a context.
* Get the offsets of ecma values corresponding to the passed context.
*
* @return array of offsets, last item represents the size of the context item
*/
@@ -325,7 +329,7 @@ vm_get_context_value_offsets (ecma_value_t *context_item_p) /**< any item of a c
case VM_CONTEXT_FINALLY_THROW:
case VM_CONTEXT_FINALLY_RETURN:
{
return (2 << (VM_CONTEXT_OFFSET_SHIFT)) | PARSER_FINALLY_CONTEXT_STACK_ALLOCATION;
return (PARSER_FINALLY_CONTEXT_STACK_ALLOCATION << VM_CONTEXT_OFFSET_SHIFT) | 2;
}
case VM_CONTEXT_FINALLY_JUMP:
{
@@ -338,16 +342,19 @@ vm_get_context_value_offsets (ecma_value_t *context_item_p) /**< any item of a c
{
return PARSER_WITH_CONTEXT_STACK_ALLOCATION;
}
case VM_CONTEXT_FOR_OF:
case VM_CONTEXT_FOR_IN:
{
return ((4 << (VM_CONTEXT_OFFSET_SHIFT * 3))
| (3 << (VM_CONTEXT_OFFSET_SHIFT * 2))
| (2 << (VM_CONTEXT_OFFSET_SHIFT))
| PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION);
return (PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION << VM_CONTEXT_OFFSET_SHIFT) | 4;
}
default:
{
return (4 << (VM_CONTEXT_OFFSET_SHIFT)) | PARSER_FOR_IN_CONTEXT_STACK_ALLOCATION;
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (context_item_p[-1]) == VM_CONTEXT_FOR_OF
|| VM_GET_CONTEXT_TYPE (context_item_p[-1]) == VM_CONTEXT_FOR_AWAIT_OF);
return ((PARSER_FOR_OF_CONTEXT_STACK_ALLOCATION << (VM_CONTEXT_OFFSET_SHIFT * 3))
| (4 << (VM_CONTEXT_OFFSET_SHIFT * 2))
| (3 << VM_CONTEXT_OFFSET_SHIFT)
| 2);
}
}
} /* vm_get_context_value_offsets */
jerry-core/vm/vm-stack.h
+2 -1
View File
@@ -74,6 +74,7 @@ typedef enum
VM_CONTEXT_FOR_IN, /**< for-in context */
#if ENABLED (JERRY_ESNEXT)
VM_CONTEXT_FOR_OF, /**< for-of context */
VM_CONTEXT_FOR_AWAIT_OF, /**< for-await-of context */
#endif /* ENABLED (JERRY_ESNEXT) */
} vm_stack_context_type_t;
@@ -94,7 +95,7 @@ typedef enum
#define VM_CONTEXT_HAS_NEXT_OFFSET(offsets) ((offsets) >= (1 << VM_CONTEXT_OFFSET_SHIFT))
/**
* Gets the next offset from the offset array.
* Get the next offset from the offset array.
*/
#define VM_CONTEXT_GET_NEXT_OFFSET(offsets) (-((int32_t) ((offsets) & ((1 << VM_CONTEXT_OFFSET_SHIFT) - 1))))
jerry-core/vm/vm.c
+121 -47
View File
@@ -2210,7 +2210,8 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
{
ecma_extended_object_t *async_generator_object_p = VM_GET_EXECUTABLE_OBJECT (frame_ctx_p);
JERRY_ASSERT (!(async_generator_object_p->u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD));
JERRY_ASSERT (!(async_generator_object_p->u.class_prop.extra_info
& ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD));
/* Byte code is executed at the first time. */
left_value = stack_top_p[-1];
@@ -2237,7 +2238,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
goto error;
}
async_generator_object_p->u.class_prop.extra_info |= ECMA_GENERATOR_ITERATE_AND_YIELD;
async_generator_object_p->u.class_prop.extra_info |= ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD;
frame_ctx_p->block_result = left_value;
frame_ctx_p->call_operation = VM_EXEC_RETURN;
@@ -2247,50 +2248,21 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
}
case VM_OC_AWAIT:
{
ecma_value_t promise = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE));
ecma_value_t argument = *(--stack_top_p);
result = ecma_promise_reject_or_resolve (promise, argument, true);
ecma_free_value (argument);
if (ECMA_IS_VALUE_ERROR (result))
if (JERRY_UNLIKELY (frame_ctx_p->block_result == ECMA_VALUE_UNDEFINED))
{
goto error;
frame_ctx_p->call_operation = VM_EXEC_RETURN;
frame_ctx_p->byte_code_p = byte_code_p;
frame_ctx_p->stack_top_p = --stack_top_p;
result = opfunc_async_create_and_await (frame_ctx_p, *stack_top_p, 0);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
return result;
}
frame_ctx_p->call_operation = VM_EXEC_RETURN;
frame_ctx_p->byte_code_p = byte_code_p;
frame_ctx_p->stack_top_p = stack_top_p;
if (frame_ctx_p->block_result == ECMA_VALUE_UNDEFINED)
{
vm_executable_object_t *executable_object_p;
executable_object_p = opfunc_create_executable_object (frame_ctx_p, VM_CREATE_EXECUTABLE_OBJECT_ASYNC);
ecma_promise_async_then (result, ecma_make_object_value ((ecma_object_t *) executable_object_p));
ecma_deref_object ((ecma_object_t *) executable_object_p);
ecma_free_value (result);
ecma_object_t *old_new_target_p = JERRY_CONTEXT (current_new_target);
JERRY_CONTEXT (current_new_target) = ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE);
result = ecma_op_create_promise_object (ECMA_VALUE_EMPTY, ECMA_PROMISE_EXECUTOR_EMPTY);
JERRY_ASSERT (ecma_is_value_object (result));
executable_object_p->frame_ctx.block_result = result;
JERRY_CONTEXT (current_new_target) = old_new_target_p;
}
else
{
ecma_object_t *object_p = (ecma_object_t *) VM_GET_EXECUTABLE_OBJECT (frame_ctx_p);
ecma_promise_async_then (result, ecma_make_object_value (object_p));
ecma_free_value (result);
result = ECMA_VALUE_UNDEFINED;
}
return result;
/* FALLTHRU */
}
case VM_OC_GENERATOR_AWAIT:
{
@@ -3668,7 +3640,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
frame_ctx_p->lex_env_p = with_env_p;
continue;
}
case VM_OC_FOR_IN_CREATE_CONTEXT:
case VM_OC_FOR_IN_INIT:
{
ecma_value_t value = *(--stack_top_p);
@@ -3780,7 +3752,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
continue;
}
#if ENABLED (JERRY_ESNEXT)
case VM_OC_FOR_OF_CREATE_CONTEXT:
case VM_OC_FOR_OF_INIT:
{
ecma_value_t value = *(--stack_top_p);
@@ -3844,7 +3816,8 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
case VM_OC_FOR_OF_GET_NEXT:
{
ecma_value_t *context_top_p = VM_GET_REGISTERS (frame_ctx_p) + register_end + frame_ctx_p->context_depth;
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (context_top_p[-1]) == VM_CONTEXT_FOR_OF);
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (context_top_p[-1]) == VM_CONTEXT_FOR_OF
|| VM_GET_CONTEXT_TYPE (context_top_p[-1]) == VM_CONTEXT_FOR_AWAIT_OF);
*stack_top_p++ = context_top_p[-2];
context_top_p[-2] = ECMA_VALUE_UNDEFINED;
@@ -3853,6 +3826,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
case VM_OC_FOR_OF_HAS_NEXT:
{
JERRY_ASSERT (VM_GET_REGISTERS (frame_ctx_p) + register_end + frame_ctx_p->context_depth == stack_top_p);
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (stack_top_p[-1]) == VM_CONTEXT_FOR_OF);
result = ecma_op_iterator_step (stack_top_p[-3], stack_top_p[-4]);
@@ -3885,6 +3859,106 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
byte_code_p = byte_code_start_p + branch_offset;
continue;
}
case VM_OC_FOR_AWAIT_OF_INIT:
{
ecma_value_t value = *(--stack_top_p);
JERRY_ASSERT (VM_GET_REGISTERS (frame_ctx_p) + register_end + frame_ctx_p->context_depth == stack_top_p);
ecma_value_t next_method;
result = ecma_op_get_iterator (value, ECMA_VALUE_ASYNC_ITERATOR, &next_method);
ecma_free_value (value);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
ecma_value_t iterator = result;
result = ecma_op_iterator_next (result, next_method, ECMA_VALUE_EMPTY);
if (ECMA_IS_VALUE_ERROR (result))
{
ecma_free_value (iterator);
ecma_free_value (next_method);
goto error;
}
branch_offset += (int32_t) (byte_code_start_p - frame_ctx_p->byte_code_start_p);
VM_PLUS_EQUAL_U16 (frame_ctx_p->context_depth, PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION);
stack_top_p += PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION;
stack_top_p[-1] = VM_CREATE_CONTEXT (VM_CONTEXT_FOR_AWAIT_OF, branch_offset);
stack_top_p[-2] = ECMA_VALUE_UNDEFINED;
stack_top_p[-3] = iterator;
stack_top_p[-4] = next_method;
if (byte_code_p[0] == CBC_EXT_OPCODE && byte_code_p[1] == CBC_EXT_CLONE_CONTEXT)
{
/* No need to duplicate the first context. */
byte_code_p += 2;
}
frame_ctx_p->call_operation = VM_EXEC_RETURN;
frame_ctx_p->byte_code_p = byte_code_p;
frame_ctx_p->stack_top_p = stack_top_p;
uint16_t extra_flags = (ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD
| (ECMA_AWAIT_FOR_NEXT << ECMA_AWAIT_STATE_SHIFT));
if (CBC_FUNCTION_GET_TYPE (frame_ctx_p->bytecode_header_p->status_flags) == CBC_FUNCTION_ASYNC_GENERATOR
|| frame_ctx_p->block_result != ECMA_VALUE_UNDEFINED)
{
ecma_extended_object_t *executable_object_p = VM_GET_EXECUTABLE_OBJECT (frame_ctx_p);
result = ecma_promise_async_await (executable_object_p, result);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
executable_object_p->u.class_prop.extra_info |= extra_flags;
return ECMA_VALUE_UNDEFINED;
}
result = opfunc_async_create_and_await (frame_ctx_p, result, extra_flags);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
return result;
}
case VM_OC_FOR_AWAIT_OF_HAS_NEXT:
{
JERRY_ASSERT (VM_GET_REGISTERS (frame_ctx_p) + register_end + frame_ctx_p->context_depth == stack_top_p);
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (stack_top_p[-1]) == VM_CONTEXT_FOR_AWAIT_OF);
result = ecma_op_iterator_next (stack_top_p[-3], stack_top_p[-4], ECMA_VALUE_EMPTY);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
ecma_extended_object_t *executable_object_p = VM_GET_EXECUTABLE_OBJECT (frame_ctx_p);
result = ecma_promise_async_await (executable_object_p, result);
if (ECMA_IS_VALUE_ERROR (result))
{
goto error;
}
uint16_t extra_flags = (ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD
| (ECMA_AWAIT_FOR_NEXT << ECMA_AWAIT_STATE_SHIFT));
executable_object_p->u.class_prop.extra_info |= extra_flags;
frame_ctx_p->call_operation = VM_EXEC_RETURN;
frame_ctx_p->byte_code_p = byte_code_start_p + branch_offset;
frame_ctx_p->stack_top_p = stack_top_p;
return ECMA_VALUE_UNDEFINED;
}
#endif /* ENABLED (JERRY_ESNEXT) */
case VM_OC_TRY:
{
jerry-core/vm/vm.h
+11 -7
View File
@@ -206,7 +206,7 @@ typedef enum
VM_OC_BLOCK_CREATE_CONTEXT, /**< create lexical environment for blocks enclosed in braces */
VM_OC_WITH, /**< with */
VM_OC_FOR_IN_CREATE_CONTEXT, /**< for in create context */
VM_OC_FOR_IN_INIT, /**< for-in init context */
VM_OC_FOR_IN_GET_NEXT, /**< get next */
VM_OC_FOR_IN_HAS_NEXT, /**< has next */
@@ -243,9 +243,11 @@ typedef enum
VM_OC_CLONE_CONTEXT, /**< clone lexical environment with let/const declarations */
VM_OC_SET_COMPUTED_PROPERTY, /**< set computed property */
VM_OC_FOR_OF_CREATE_CONTEXT, /**< for of create context */
VM_OC_FOR_OF_GET_NEXT, /**< get next */
VM_OC_FOR_OF_HAS_NEXT, /**< has next */
VM_OC_FOR_OF_INIT, /**< for-of init context */
VM_OC_FOR_OF_GET_NEXT, /**< for-of get next */
VM_OC_FOR_OF_HAS_NEXT, /**< for-of has next */
VM_OC_FOR_AWAIT_OF_INIT, /**< for-await-of init context */
VM_OC_FOR_AWAIT_OF_HAS_NEXT, /**< for-await-of has next */
VM_OC_LOCAL_EVAL, /**< eval in local context */
VM_OC_SUPER_CALL, /**< call the 'super' constructor */
@@ -312,9 +314,11 @@ typedef enum
VM_OC_CLONE_CONTEXT = VM_OC_NONE, /**< clone lexical environment with let/const declarations */
VM_OC_SET_COMPUTED_PROPERTY = VM_OC_NONE, /**< set computed property is unused */
VM_OC_FOR_OF_CREATE_CONTEXT = VM_OC_NONE, /**< for of create context */
VM_OC_FOR_OF_GET_NEXT = VM_OC_NONE, /**< get next */
VM_OC_FOR_OF_HAS_NEXT = VM_OC_NONE, /**< has next */
VM_OC_FOR_OF_INIT = VM_OC_NONE, /**< for-of init context */
VM_OC_FOR_OF_GET_NEXT = VM_OC_NONE, /**< for-of get next */
VM_OC_FOR_OF_HAS_NEXT = VM_OC_NONE, /**< for-of has next */
VM_OC_FOR_AWAIT_OF_INIT = VM_OC_NONE, /**< for-await-of init context */
VM_OC_FOR_AWAIT_OF_HAS_NEXT = VM_OC_NONE, /**< for-await-of has next */
VM_OC_LOCAL_EVAL = VM_OC_NONE, /**< eval in local context */
VM_OC_SUPER_CALL = VM_OC_NONE, /**< call the 'super' constructor */
tests/jerry/es.next/for-await-of.js
+198
View File
@@ -0,0 +1,198 @@
// Copyright JS Foundation and other contributors, http://js.foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
function check_syntax_error (code)
{
try {
eval (code);
assert (false);
} catch (e) {
assert (e instanceof SyntaxError);
}
}
check_syntax_error ("for await (a of b)");
check_syntax_error ("async function f() { for await (a in b) ; }");
check_syntax_error ("async function f() { for await ( ; ; ) ; }");
check_syntax_error ("async function f() { for await (let a = 0; a < 4; a++) ; }");
var successCount = 0;
// Test 1
var promise1 = Promise.resolve("Resolved");
var asyncIter1 = {
[Symbol.asyncIterator]() {
var idx = 0;
function next() {
idx++;
if (idx == 1) {
return { value:"Val", done: false }
} else if (idx == 2) {
return { value:promise1, done: false }
} else if (idx == 3) {
return { value:4.5, done: false }
}
return { value:promise1, done: true }
}
successCount++
return { next }
}
}
function checkAsyncIter1(v, idx)
{
if (idx === 1) {
assert(v === "Val")
} else if (idx === 2) {
assert(v === promise1)
} else if (idx === 3) {
assert(v === 4.5)
} else {
assert(false)
}
}
async function f1a() {
var idx = 0;
for await (var v of asyncIter1) {
checkAsyncIter1(v, ++idx);
successCount++;
}
successCount++;
}
f1a()
async function f1b() {
await promise1
var idx = 0;
for await (var v of asyncIter1) {
checkAsyncIter1(v, ++idx);
successCount++;
}
successCount++;
}
f1b()
async function *f1c() {
var idx = 0;
for await (var v of asyncIter1) {
checkAsyncIter1(v, ++idx);
successCount++;
}
successCount++;
}
f1c().next()
async function *f1d() {
await promise1
var idx = 0;
for await (var v of asyncIter1) {
checkAsyncIter1(v, ++idx);
successCount++;
}
successCount++;
}
f1d().next()
// Test 2
var state2 = 0
var promise2 = Promise.reject("Rejected");
var asyncIter2 = {
[Symbol.asyncIterator]() {
var idx = 0;
assert(++state2 === 1)
function next() {
idx++;
if (idx == 1) {
assert(++state2 === 2)
return { value:"Str", done: false }
} else if (idx == 2) {
assert(++state2 === 4)
return { value:promise2, done: false }
} else if (idx == 3) {
assert(++state2 === 6)
return { value:-3.5, done: false }
}
assert(++state2 === 8)
return { value:promise2, done: true }
}
successCount++
return { next }
}
}
function checkAsyncIter2(v, idx)
{
if (idx === 1) {
assert(v === "Str")
} else if (idx === 2) {
assert(v === promise2)
} else if (idx === 3) {
assert(v === -3.5)
} else {
assert(false)
}
}
async function *f2a() {
var idx = 0;
for await (var v of asyncIter2) {
checkAsyncIter2(v, ++idx)
yield v
}
successCount++;
}
async function f2b() {
var idx = 0;
var g = f2a();
var v;
while (true) {
v = await g.next()
if (v.done) {
break;
}
checkAsyncIter2(v.value, ++idx)
++state2
assert(state2 === 3 || state2 === 5 || state2 === 7)
}
successCount++;
}
f2b();
// END
function __checkAsync() {
assert(state2 === 8)
assert(successCount === 23)
}