Skip to content

25 Control Abstraction Objects

25.1 Iteration

25.1.1 Common Iteration Interfaces

An interface is a set of property keys whose associated values match a specific specification. Any object that provides all the properties as described by an interface's specification conforms to that interface. An interface is not represented by a distinct object. There may be many separately implemented objects that conform to any interface. An individual object may conform to multiple interfaces.

25.1.1.1 The Iterable Interface

The Iterable interface includes the property described in Table 60:

Iterable Interface Required Properties">
Property Value Requirements
@@iterator A function that returns an Iterator object. The returned object must conform to the Iterator interface.

25.1.1.2 The Iterator Interface

An object that implements the Iterator interface must include the property in Table 61. Such objects may also implement the properties in Table 62.

Iterator Interface Required Properties">
Property Value Requirements
next A function that returns an IteratorResult object. The returned object must conform to the IteratorResult interface. If a previous call to the next method of an Iterator has returned an IteratorResult object whose done property is true, then all subsequent calls to the next method of that object should also return an IteratorResult object whose done property is true. However, this requirement is not enforced.
Note 1

Arguments may be passed to the next function but their interpretation and validity is dependent upon the target Iterator. The for-of statement and other common users of Iterators do not pass any arguments, so Iterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.

 Iterator Interface Optional Properties">
Property Value Requirements
return A function that returns an IteratorResult object. The returned object must conform to the IteratorResult interface. Invoking this method notifies the Iterator object that the caller does not intend to make any more next method calls to the Iterator. The returned IteratorResult object will typically have a done property whose value is true, and a value property with the value passed as the argument of the return method. However, this requirement is not enforced.
throw A function that returns an IteratorResult object. The returned object must conform to the IteratorResult interface. Invoking this method notifies the Iterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is to throw the value passed as the argument. If the method does not throw, the returned IteratorResult object will typically have a done property whose value is true.
Note 2

Typically callers of these methods should check for their existence before invoking them. Certain ECMAScript language features including for-of, yield*, and array destructuring call these methods after performing an existence check. Most ECMAScript library functions that accept Iterable objects as arguments also conditionally call them.

25.1.1.3 The AsyncIterable Interface

The AsyncIterable interface includes the properties described in Table 63:

AsyncIterable Interface Required Properties">
Property Value Requirements
@@asyncIterator A function that returns an AsyncIterator object. The returned object must conform to the AsyncIterator interface.

25.1.1.4 The AsyncIterator Interface

An object that implements the AsyncIterator interface must include the properties in Table 64. Such objects may also implement the properties in Table 65.

AsyncIterator Interface Required Properties">
Property Value Requirements
next A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. If a previous call to the next method of an AsyncIterator has returned a promise for an IteratorResult object whose done property is true, then all subsequent calls to the next method of that object should also return a promise for an IteratorResult object whose done property is true. However, this requirement is not enforced.

Additionally, the IteratorResult object that serves as a fulfillment value should have a value property whose value is not a promise (or "thenable"). However, this requirement is also not enforced.
Note 1

Arguments may be passed to the next function but their interpretation and validity is dependent upon the target AsyncIterator. The for-await-of statement and other common users of AsyncIterators do not pass any arguments, so AsyncIterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.

 AsyncIterator Interface Optional Properties">
Property Value Requirements
return A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. Invoking this method notifies the AsyncIterator object that the caller does not intend to make any more next method calls to the AsyncIterator. The returned promise will fulfill with an IteratorResult object which will typically have a done property whose value is true, and a value property with the value passed as the argument of the return method. However, this requirement is not enforced.

Additionally, the IteratorResult object that serves as a fulfillment value should have a value property whose value is not a promise (or "thenable"). If the argument value is used in the typical manner, then if it is a rejected promise, a promise rejected with the same reason should be returned; if it is a fulfilled promise, then its fulfillment value should be used as the value property of the returned promise's IteratorResult object fulfillment value. However, these requirements are also not enforced.
throw A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. Invoking this method notifies the AsyncIterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is to return a rejected promise which rejects with the value passed as the argument.

If the returned promise is fulfilled, the IteratorResult fulfillment value will typically have a done property whose value is true. Additionally, it should have a value property whose value is not a promise (or "thenable"), but this requirement is not enforced.
Note 2

Typically callers of these methods should check for their existence before invoking them. Certain ECMAScript language features including for-await-of and yield* call these methods after performing an existence check.

25.1.1.5 The IteratorResult Interface

The IteratorResult interface includes the properties listed in Table 66:

IteratorResult Interface Properties">
Property Value Requirements
done Either true or false. This is the result status of an iterator next method call. If the end of the iterator was reached done is true. If the end was not reached done is false and a value is available. If a done property (either own or inherited) does not exist, it is consider to have the value false.
value Any ECMAScript language value. If done is false, this is the current iteration element value. If done is true, this is the return value of the iterator, if it supplied one. If the iterator does not have a return value, value is undefined. In that case, the value property may be absent from the conforming object if it does not inherit an explicit value property.

25.1.2 The %IteratorPrototype% Object

The %IteratorPrototype% object:

  • has a [[Prototype]] internal slot whose value is the intrinsic object %ObjectPrototype%.
  • is an ordinary object.
Note

All objects defined in this specification that implement the Iterator interface also inherit from %IteratorPrototype%. ECMAScript code may also define objects that inherit from %IteratorPrototype%.The %IteratorPrototype% object provides a place where additional methods that are applicable to all iterator objects may be added.

The following expression is one way that ECMAScript code can access the %IteratorPrototype% object:

Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))

25.1.2.1 %IteratorPrototype% [ @@iterator ] ( )

The following steps are taken:

  1. Return the this value.

The value of the name property of this function is "[Symbol.iterator]".

25.1.3 The %AsyncIteratorPrototype% Object

The %AsyncIteratorPrototype% object:

  • has a [[Prototype]] internal slot whose value is the intrinsic object %ObjectPrototype%.
  • is an ordinary object.
Note

All objects defined in this specification that implement the AsyncIterator interface also inherit from %AsyncIteratorPrototype%. ECMAScript code may also define objects that inherit from %AsyncIteratorPrototype%.The %AsyncIteratorPrototype% object provides a place where additional methods that are applicable to all async iterator objects may be added.

25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )

The following steps are taken:

  1. Return the this value.

The value of the name property of this function is "[Symbol.asyncIterator]".

25.1.4 Async-from-Sync Iterator Objects

An Async-from-Sync Iterator object is an async iterator that adapts a specific synchronous iterator. There is not a named constructor for Async-from-Sync Iterator objects. Instead, Async-from-Sync iterator objects are created by the CreateAsyncFromSyncIterator abstract operation as needed.

25.1.4.1 CreateAsyncFromSyncIterator ( syncIteratorRecord )

The abstract operation CreateAsyncFromSyncIterator is used to create an async iterator Record from a synchronous iterator Record. It performs the following steps:

  1. Let asyncIterator be ! ObjectCreate(%AsyncFromSyncIteratorPrototype%, « [[SyncIteratorRecord]] »).
  2. Set asyncIterator.[[SyncIteratorRecord]] to syncIteratorRecord.
  3. Return ? GetIterator(asyncIterator, async).

25.1.4.2 The %AsyncFromSyncIteratorPrototype% Object

The %AsyncFromSyncIteratorPrototype% object:

  • has properties that are inherited by all Async-from-Sync Iterator Objects.
  • is an ordinary object.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %AsyncIteratorPrototype%.
  • has the following properties:

25.1.4.2.1 %AsyncFromSyncIteratorPrototype%.next ( value )

  1. Let O be the this value.
  2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
  3. If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] internal slot, then
    1. Let invalidIteratorError be a newly created TypeError object.
    2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
    3. Return promiseCapability.[[Promise]].
  4. Let syncIteratorRecord be O.[[SyncIteratorRecord]].
  5. Let nextResult be IteratorNext(syncIteratorRecord, value).
  6. IfAbruptRejectPromise(nextResult, promiseCapability).
  7. Let nextDone be IteratorComplete(nextResult).
  8. IfAbruptRejectPromise(nextDone, promiseCapability).
  9. Let nextValue be IteratorValue(nextResult).
  10. IfAbruptRejectPromise(nextValue, promiseCapability).
  11. Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
  12. Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « nextValue »).
  13. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions.
  14. Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
  15. Set onFulfilled.[[Done]] to nextDone.
  16. Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
  17. Return promiseCapability.[[Promise]].

25.1.4.2.2 %AsyncFromSyncIteratorPrototype%.return ( value )

  1. Let O be the this value.
  2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
  3. If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] internal slot, then
    1. Let invalidIteratorError be a newly created TypeError object.
    2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
    3. Return promiseCapability.[[Promise]].
  4. Let syncIterator be O.[[SyncIteratorRecord]].[[Iterator]].
  5. Let return be GetMethod(syncIterator, "return").
  6. IfAbruptRejectPromise(return, promiseCapability).
  7. If return is undefined, then
    1. Let iterResult be ! CreateIterResultObject(value, true).
    2. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »).
    3. Return promiseCapability.[[Promise]].
  8. Let returnResult be Call(return, syncIterator, « value »).
  9. IfAbruptRejectPromise(returnResult, promiseCapability).
  10. If Type(returnResult) is not Object, then
    1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
    2. Return promiseCapability.[[Promise]].
  11. Let returnDone be IteratorComplete(returnResult).
  12. IfAbruptRejectPromise(returnDone, promiseCapability).
  13. Let returnValue be IteratorValue(returnResult).
  14. IfAbruptRejectPromise(returnValue, promiseCapability).
  15. Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
  16. Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « returnValue »).
  17. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions.
  18. Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
  19. Set onFulfilled.[[Done]] to returnDone.
  20. Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
  21. Return promiseCapability.[[Promise]].

25.1.4.2.3 %AsyncFromSyncIteratorPrototype%.throw ( value )

  1. Let O be the this value.
  2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
  3. If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] internal slot, then
    1. Let invalidIteratorError be a newly created TypeError object.
    2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
    3. Return promiseCapability.[[Promise]].
  4. Let syncIterator be O.[[SyncIteratorRecord]].[[Iterator]].
  5. Let throw be GetMethod(syncIterator, "throw").
  6. IfAbruptRejectPromise(throw, promiseCapability).
  7. If throw is undefined, then
    1. Perform ! Call(promiseCapability.[[Reject]], undefined, « value »).
    2. Return promiseCapability.[[Promise]].
  8. Let throwResult be Call(throw, syncIterator, « value »).
  9. IfAbruptRejectPromise(throwResult, promiseCapability).
  10. If Type(throwResult) is not Object, then
    1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
    2. Return promiseCapability.[[Promise]].
  11. Let throwDone be IteratorComplete(throwResult).
  12. IfAbruptRejectPromise(throwDone, promiseCapability).
  13. Let throwValue be IteratorValue(throwResult).
  14. IfAbruptRejectPromise(throwValue, promiseCapability).
  15. Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
  16. Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « throwValue »).
  17. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions.
  18. Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
  19. Set onFulfilled.[[Done]] to throwDone.
  20. Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
  21. Return promiseCapability.[[Promise]].

25.1.4.2.4 %AsyncFromSyncIteratorPrototype% [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "Async-from-Sync Iterator".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.1.4.2.5 Async-from-Sync Iterator Value Unwrap Functions

An async-from-sync iterator value unwrap function is an anonymous built-in function that is used by methods of %AsyncFromSyncIteratorPrototype% when processing the value field of an IteratorResult object, in order to wait for its value if it is a promise and re-package the result in a new "unwrapped" IteratorResult object. Each async iterator value unwrap function has a [[Done]] internal slot.

When an async-from-sync iterator value unwrap function F is called with argument value, the following steps are taken:

  1. Return ! CreateIterResultObject(value, F.[[Done]]).

25.1.4.3 Properties of Async-from-Sync Iterator Instances

Async-from-Sync Iterator instances are ordinary objects that inherit properties from the %AsyncFromSyncIteratorPrototype% intrinsic object. Async-from-Sync Iterator instances are initially created with the internal slots listed in Table 67.

Internal Slot Description
[[SyncIteratorRecord]] A Record, of the type returned by GetIterator, representing the original synchronous iterator which is being adapted.

25.2 GeneratorFunction Objects

GeneratorFunction objects are functions that are usually created by evaluating GeneratorDeclarations, GeneratorExpressions, and GeneratorMethods. They may also be created by calling the %GeneratorFunction% intrinsic.

A staggering variety of boxes and arrows.

25.2.1 The GeneratorFunction Constructor

The GeneratorFunction constructor:

  • is the intrinsic object %GeneratorFunction%.
  • creates and initializes a new GeneratorFunction object when called as a function rather than as a constructor. Thus the function call GeneratorFunction (…) is equivalent to the object creation expression new GeneratorFunction (…) with the same arguments.
  • is designed to be subclassable. It may be used as the value of an extends clause of a class definition. Subclass constructors that intend to inherit the specified GeneratorFunction behaviour must include a super call to the GeneratorFunction constructor to create and initialize subclass instances with the internal slots necessary for built-in GeneratorFunction behaviour. All ECMAScript syntactic forms for defining generator function objects create direct instances of GeneratorFunction. There is no syntactic means to create instances of GeneratorFunction subclasses.

25.2.1.1 GeneratorFunction ( p1, p2, … , pn, body )

The last argument specifies the body (executable code) of a generator function; any preceding arguments specify formal parameters.

When the GeneratorFunction function is called with some arguments p1, p2, … , pn, body (where n might be 0, that is, there are no “p” arguments, and where body might also not be provided), the following steps are taken:

  1. Let C be the active function object.
  2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
  3. Return ? CreateDynamicFunction(C, NewTarget, "generator", args).
 Note

See NOTE for 19.2.1.1.

25.2.2 Properties of the GeneratorFunction Constructor

The GeneratorFunction constructor:

  • is a standard built-in function object that inherits from the Function constructor.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %Function%.
  • has a name property whose value is "GeneratorFunction".
  • has the following properties:

25.2.2.1 GeneratorFunction.length

This is a data property with a value of 1. This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.2.2 GeneratorFunction.prototype

The initial value of GeneratorFunction.prototype is the intrinsic object %Generator%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.2.3 Properties of the GeneratorFunction Prototype Object

The GeneratorFunction prototype object:

  • is an ordinary object.
  • is not a function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed in Table 27 or Table 68.
  • is the value of the prototype property of the intrinsic object %GeneratorFunction%.
  • is the intrinsic object %Generator% (see Figure 2).
  • has a [[Prototype]] internal slot whose value is the intrinsic object %FunctionPrototype%.

25.2.3.1 GeneratorFunction.prototype.constructor

The initial value of GeneratorFunction.prototype.constructor is the intrinsic object %GeneratorFunction%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.3.2 GeneratorFunction.prototype.prototype

The value of GeneratorFunction.prototype.prototype is the %GeneratorPrototype% intrinsic object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.3.3 GeneratorFunction.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "GeneratorFunction".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.4 GeneratorFunction Instances

Every GeneratorFunction instance is an ECMAScript function object and has the internal slots listed in Table 27. The value of the [[FunctionKind]] internal slot for all such instances is "generator".

Each GeneratorFunction instance has the following own properties:

25.2.4.1 length

The specification for the length property of Function instances given in 19.2.4.1 also applies to GeneratorFunction instances.

25.2.4.2 name

The specification for the name property of Function instances given in 19.2.4.2 also applies to GeneratorFunction instances.

25.2.4.3 prototype

Whenever a GeneratorFunction instance is created another ordinary object is also created and is the initial value of the generator function's prototype property. The value of the prototype property is used to initialize the [[Prototype]] internal slot of a newly created Generator object when the generator function object is invoked using [[Call]].

This property has the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Unlike Function instances, the object that is the value of the a GeneratorFunction's prototype property does not have a constructor property whose value is the GeneratorFunction instance.

25.3 AsyncGeneratorFunction Objects

AsyncGeneratorFunction objects are functions that are usually created by evaluating AsyncGeneratorDeclaration, AsyncGeneratorExpression, and AsyncGeneratorMethod syntactic productions. They may also be created by calling the %AsyncGeneratorFunction% intrinsic.

25.3.1 The AsyncGeneratorFunction Constructor

The AsyncGeneratorFunction constructor:

  • is the intrinsic object %AsyncGeneratorFunction%.
  • creates and initializes a new AsyncGeneratorFunction object when called as a function rather than as a constructor. Thus the function call AsyncGeneratorFunction (...) is equivalent to the object creation expression new AsyncGeneratorFunction (...) with the same arguments.
  • is designed to be subclassable. It may be used as the value of an extends clause of a class definition. Subclass constructors that intend to inherit the specified AsyncGeneratorFunction behaviour must include a super call to the AsyncGeneratorFunction constructor to create and initialize subclass instances with the internal slots necessary for built-in AsyncGeneratorFunction behaviour. All ECMAScript syntactic forms for defining async generator function objects create direct instances of AsyncGeneratorFunction. There is no syntactic means to create instances of AsyncGeneratorFunction subclasses.

25.3.1.1 AsyncGeneratorFunction ( p1, p2, ..., pn, body )

The last argument specifies the body (executable code) of an async generator function; any preceding arguments specify formal parameters.

When the AsyncGeneratorFunction function is called with some arguments p1, p2, … , pn, body (where n might be 0, that is, there are no "p" arguments, and where body might also not be provided), the following steps are taken:

  1. Let C be the active function object.
  2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
  3. Return ? CreateDynamicFunction(C, NewTarget, "async generator", args).
 Note

See NOTE for 19.2.1.1.

25.3.2 Properties of the AsyncGeneratorFunction Constructor

The AsyncGeneratorFunction constructor:

  • is a standard built-in function object that inherits from the Function constructor.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %Function%.
  • has a name property whose value is "AsyncGeneratorFunction".
  • has the following properties:

25.3.2.1 AsyncGeneratorFunction.length

This is a data property with a value of 1. This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.2.2 AsyncGeneratorFunction.prototype

The initial value of AsyncGeneratorFunction.prototype is the intrinsic object %AsyncGenerator%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.3.3 Properties of the AsyncGeneratorFunction Prototype Object

The AsyncGeneratorFunction prototype object:

  • is an ordinary object.
  • is not a function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed in Table 27 or Table 69.
  • is the value of the prototype property of the intrinsic object %AsyncGeneratorFunction%.
  • is the intrinsic object %AsyncGenerator%.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %FunctionPrototype%.

25.3.3.1 AsyncGeneratorFunction.prototype.constructor

The initial value of AsyncGeneratorFunction.prototype.constructor is the intrinsic object %AsyncGeneratorFunction%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.3.2 AsyncGeneratorFunction.prototype.prototype

The value of AsyncGeneratorFunction.prototype.prototype is the %AsyncGeneratorPrototype% intrinsic object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.3.3 AsyncGeneratorFunction.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "AsyncGeneratorFunction".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.4 AsyncGeneratorFunction Instances

Every AsyncGeneratorFunction instance is an ECMAScript function object and has the internal slots listed in Table 27. The value of the [[FunctionKind]] internal slot for all such instances is "generator".

Each AsyncGeneratorFunction instance has the following own properties:

25.3.4.1 length

The value of the length property is an integer that indicates the typical number of arguments expected by the AsyncGeneratorFunction. However, the language permits the function to be invoked with some other number of arguments. The behaviour of an AsyncGeneratorFunction when invoked on a number of arguments other than the number specified by its length property depends on the function.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.4.2 name

The specification for the name property of Function instances given in 19.2.4.2 also applies to AsyncGeneratorFunction instances.

25.3.4.3 prototype

Whenever an AsyncGeneratorFunction instance is created another ordinary object is also created and is the initial value of the async generator function's prototype property. The value of the prototype property is used to initialize the [[Prototype]] internal slot of a newly created AsyncGenerator object when the generator function object is invoked using [[Call]].

This property has the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Unlike function instances, the object that is the value of the an AsyncGeneratorFunction's prototype property does not have a constructor property whose value is the AsyncGeneratorFunction instance.

25.4 Generator Objects

A Generator object is an instance of a generator function and conforms to both the Iterator and Iterable interfaces.

Generator instances directly inherit properties from the object that is the value of the prototype property of the Generator function that created the instance. Generator instances indirectly inherit properties from the Generator Prototype intrinsic, %GeneratorPrototype%.

25.4.1 Properties of the Generator Prototype Object

The Generator prototype object:

  • is the intrinsic object %GeneratorPrototype%.
  • is the initial value of the prototype property of the intrinsic object %Generator% (the GeneratorFunction.prototype).
  • is an ordinary object.
  • is not a Generator instance and does not have a [[GeneratorState]] internal slot.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %IteratorPrototype%.
  • has properties that are indirectly inherited by all Generator instances.

25.4.1.1 Generator.prototype.constructor

The initial value of Generator.prototype.constructor is the intrinsic object %Generator%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.4.1.2 Generator.prototype.next ( value )

The next method performs the following steps:

  1. Let g be the this value.
  2. Return ? GeneratorResume(g, value).

25.4.1.3 Generator.prototype.return ( value )

The return method performs the following steps:

  1. Let g be the this value.
  2. Let C be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
  3. Return ? GeneratorResumeAbrupt(g, C).

25.4.1.4 Generator.prototype.throw ( exception )

The throw method performs the following steps:

  1. Let g be the this value.
  2. Let C be ThrowCompletion(exception).
  3. Return ? GeneratorResumeAbrupt(g, C).

25.4.1.5 Generator.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "Generator".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.4.2 Properties of Generator Instances

Generator instances are initially created with the internal slots described in Table 68.

Internal Slot Description
[[GeneratorState]] The current execution state of the generator. The possible values are: undefined, "suspendedStart", "suspendedYield", "executing", and "completed".
[[GeneratorContext]] The execution context that is used when executing the code of this generator.

25.4.3 Generator Abstract Operations

25.4.3.1 GeneratorStart ( generator, generatorBody )

The abstract operation GeneratorStart with arguments generator and generatorBody performs the following steps:

  1. Assert: The value of generator.[[GeneratorState]] is undefined.
  2. Let genContext be the running execution context.
  3. Set the Generator component of genContext to generator.
  4. Set the code evaluation state of genContext such that when evaluation is resumed for that execution context the following steps will be performed:
    1. Let result be the result of evaluating generatorBody.
    2. Assert: If we return here, the generator either threw an exception or performed either an implicit or explicit return.
    3. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
    4. Set generator.[[GeneratorState]] to "completed".
    5. Once a generator enters the "completed" state it never leaves it and its associated execution context is never resumed. Any execution state associated with generator can be discarded at this point.
    6. If result.[[Type]] is normal, let resultValue be undefined.
    7. Else if result.[[Type]] is return, let resultValue be result.[[Value]].
    8. Else,
      1. Assert: result.[[Type]] is throw.
      2. Return Completion(result).
    9. Return CreateIterResultObject(resultValue, true).
  5. Set generator.[[GeneratorContext]] to genContext.
  6. Set generator.[[GeneratorState]] to "suspendedStart".
  7. Return NormalCompletion(undefined).

25.4.3.2 GeneratorValidate ( generator )

The abstract operation GeneratorValidate with argument generator performs the following steps:

  1. If Type(generator) is not Object, throw a TypeError exception.
  2. If generator does not have a [[GeneratorState]] internal slot, throw a TypeError exception.
  3. Assert: generator also has a [[GeneratorContext]] internal slot.
  4. Let state be generator.[[GeneratorState]].
  5. If state is "executing", throw a TypeError exception.
  6. Return state.

25.4.3.3 GeneratorResume ( generator, value )

The abstract operation GeneratorResume with arguments generator and value performs the following steps:

  1. Let state be ? GeneratorValidate(generator).
  2. If state is "completed", return CreateIterResultObject(undefined, true).
  3. Assert: state is either "suspendedStart" or "suspendedYield".
  4. Let genContext be generator.[[GeneratorContext]].
  5. Let methodContext be the running execution context.
  6. Suspend methodContext.
  7. Set generator.[[GeneratorState]] to "executing".
  8. Push genContext onto the execution context stack; genContext is now the running execution context.
  9. Resume the suspended evaluation of genContext using NormalCompletion(value) as the result of the operation that suspended it. Let result be the value returned by the resumed computation.
  10. Assert: When we return here, genContext has already been removed from the execution context stack and methodContext is the currently running execution context.
  11. Return Completion(result).

25.4.3.4 GeneratorResumeAbrupt ( generator, abruptCompletion )

The abstract operation GeneratorResumeAbrupt with arguments generator and abruptCompletion performs the following steps:

  1. Let state be ? GeneratorValidate(generator).
  2. If state is "suspendedStart", then
    1. Set generator.[[GeneratorState]] to "completed".
    2. Once a generator enters the "completed" state it never leaves it and its associated execution context is never resumed. Any execution state associated with generator can be discarded at this point.
    3. Set state to "completed".
  3. If state is "completed", then
    1. If abruptCompletion.[[Type]] is return, then
      1. Return CreateIterResultObject(abruptCompletion.[[Value]], true).
    2. Return Completion(abruptCompletion).
  4. Assert: state is "suspendedYield".
  5. Let genContext be generator.[[GeneratorContext]].
  6. Let methodContext be the running execution context.
  7. Suspend methodContext.
  8. Set generator.[[GeneratorState]] to "executing".
  9. Push genContext onto the execution context stack; genContext is now the running execution context.
  10. Resume the suspended evaluation of genContext using abruptCompletion as the result of the operation that suspended it. Let result be the completion record returned by the resumed computation.
  11. Assert: When we return here, genContext has already been removed from the execution context stack and methodContext is the currently running execution context.
  12. Return Completion(result).

25.4.3.5 GetGeneratorKind ( )

  1. Let genContext be the running execution context.
  2. If genContext does not have a Generator component, return non-generator.
  3. Let generator be the Generator component of genContext.
  4. If generator has an [[AsyncGeneratorState]] internal slot, return async.
  5. Else, return sync.

25.4.3.6 GeneratorYield ( iterNextObj )

The abstract operation GeneratorYield with argument iterNextObj performs the following steps:

  1. Assert: iterNextObj is an Object that implements the IteratorResult interface.
  2. Let genContext be the running execution context.
  3. Assert: genContext is the execution context of a generator.
  4. Let generator be the value of the Generator component of genContext.
  5. Assert: GetGeneratorKind() is sync.
  6. Set generator.[[GeneratorState]] to "suspendedYield".
  7. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
  8. Set the code evaluation state of genContext such that when evaluation is resumed with a Completion resumptionValue the following steps will be performed:
    1. Return resumptionValue.
    2. NOTE: This returns to the evaluation of the YieldExpression that originally called this abstract operation.
  9. Return NormalCompletion(iterNextObj).
  10. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of genContext.

25.5 AsyncGenerator Objects

An AsyncGenerator object is an instance of an async generator function and conforms to both the AsyncIterator and AsyncIterable interfaces.

AsyncGenerator instances directly inherit properties from the object that is the value of the prototype property of the AsyncGenerator function that created the instance. AsyncGenerator instances indirectly inherit properties from the AsyncGenerator Prototype intrinsic, %AsyncGeneratorPrototype%.

25.5.1 Properties of the AsyncGenerator Prototype Object

The AsyncGenerator prototype object:

  • is the intrinsic object %AsyncGeneratorPrototype%.
  • is the initial value of the prototype property of the intrinsic object %AsyncGenerator% (the AsyncGeneratorFunction.prototype).
  • is an ordinary object.
  • is not an AsyncGenerator instance and does not have an [[AsyncGeneratorState]] internal slot.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %AsyncIteratorPrototype%.
  • has properties that are indirectly inherited by all AsyncGenerator instances.

25.5.1.1 AsyncGenerator.prototype.constructor

The initial value of AsyncGenerator.prototype.constructor is the intrinsic object %AsyncGenerator%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.5.1.2 AsyncGenerator.prototype.next ( value )

  1. Let generator be the this value.
  2. Let completion be NormalCompletion(value).
  3. Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.3 AsyncGenerator.prototype.return ( value )

  1. Let generator be the this value.
  2. Let completion be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
  3. Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.4 AsyncGenerator.prototype.throw ( exception )

  1. Let generator be the this value.
  2. Let completion be ThrowCompletion(exception).
  3. Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.5 AsyncGenerator.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "AsyncGenerator".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.5.2 Properties of AsyncGenerator Instances

AsyncGenerator instances are initially created with the internal slots described below:

Internal Slot Description
[[AsyncGeneratorState]] The current execution state of the async generator. The possible values are: undefined, "suspendedStart", "suspendedYield", "executing", "awaiting-return", and "completed".
[[AsyncGeneratorContext]] The execution context that is used when executing the code of this async generator.
[[AsyncGeneratorQueue]] A List of AsyncGeneratorRequest records which represent requests to resume the async generator.

25.5.3 AsyncGenerator Abstract Operations

25.5.3.1 AsyncGeneratorRequest Records

The AsyncGeneratorRequest is a Record value used to store information about how an async generator should be resumed and contains capabilities for fulfilling or rejecting the corresponding promise.

They have the following fields:

Field Name Value Meaning
[[Completion]] A Completion record The completion which should be used to resume the async generator.
[[Capability]] A PromiseCapability record The promise capabilities associated with this request.

25.5.3.2 AsyncGeneratorStart ( generator, generatorBody )

  1. Assert: generator is an AsyncGenerator instance.
  2. Assert: generator.[[AsyncGeneratorState]] is undefined.
  3. Let genContext be the running execution context.
  4. Set the Generator component of genContext to generator.
  5. Set the code evaluation state of genContext such that when evaluation is resumed for that execution context the following steps will be performed:
    1. Let result be the result of evaluating generatorBody.
    2. Assert: If we return here, the async generator either threw an exception or performed either an implicit or explicit return.
    3. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
    4. Set generator.[[AsyncGeneratorState]] to "completed".
    5. If result is a normal completion, let resultValue be undefined.
    6. Else,
      1. Let resultValue be result.[[Value]].
      2. If result.[[Type]] is not return, then
        1. Return ! AsyncGeneratorReject(generator, resultValue).
    7. Return ! AsyncGeneratorResolve(generator, resultValue, true).
  6. Set generator.[[AsyncGeneratorContext]] to genContext.
  7. Set generator.[[AsyncGeneratorState]] to "suspendedStart".
  8. Set generator.[[AsyncGeneratorQueue]] to a new empty List.
  9. Return undefined.

25.5.3.3 AsyncGeneratorResolve ( generator, value, done )

  1. Assert: generator is an AsyncGenerator instance.
  2. Let queue be generator.[[AsyncGeneratorQueue]].
  3. Assert: queue is not an empty List.
  4. Remove the first element from queue and let next be the value of that element.
  5. Let promiseCapability be next.[[Capability]].
  6. Let iteratorResult be ! CreateIterResultObject(value, done).
  7. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
  8. Perform ! AsyncGeneratorResumeNext(generator).
  9. Return undefined.

25.5.3.4 AsyncGeneratorReject ( generator, exception )

  1. Assert: generator is an AsyncGenerator instance.
  2. Let queue be generator.[[AsyncGeneratorQueue]].
  3. Assert: queue is not an empty List.
  4. Remove the first element from queue and let next be the value of that element.
  5. Let promiseCapability be next.[[Capability]].
  6. Perform ! Call(promiseCapability.[[Reject]], undefined, « exception »).
  7. Perform ! AsyncGeneratorResumeNext(generator).
  8. Return undefined.

25.5.3.5 AsyncGeneratorResumeNext ( generator )

  1. Assert: generator is an AsyncGenerator instance.
  2. Let state be generator.[[AsyncGeneratorState]].
  3. Assert: state is not "executing".
  4. If state is "awaiting-return", return undefined.
  5. Let queue be generator.[[AsyncGeneratorQueue]].
  6. If queue is an empty List, return undefined.
  7. Let next be the value of the first element of queue.
  8. Assert: next is an AsyncGeneratorRequest record.
  9. Let completion be next.[[Completion]].
  10. If completion is an abrupt completion, then
    1. If state is "suspendedStart", then
      1. Set generator.[[AsyncGeneratorState]] to "completed".
      2. Set state to "completed".
    2. If state is "completed", then
      1. If completion.[[Type]] is return, then
        1. Set generator.[[AsyncGeneratorState]] to "awaiting-return".
        2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
        3. Perform ! Call(promiseCapability.[[Resolve]], undefined, « completion.[[Value]] »).
        4. Let stepsFulfilled be the algorithm steps defined in AsyncGeneratorResumeNext Return Processor Fulfilled Functions.
        5. Let onFulfilled be CreateBuiltinFunction(stepsFulfilled, « [[Generator]] »).
        6. Set onFulfilled.[[Generator]] to generator.
        7. Let stepsRejected be the algorithm steps defined in AsyncGeneratorResumeNext Return Processor Rejected Functions.
        8. Let onRejected be CreateBuiltinFunction(stepsRejected, « [[Generator]] »).
        9. Set onRejected.[[Generator]] to generator.
        10. Let throwawayCapability be ! NewPromiseCapability(%Promise%).
        11. Set throwawayCapability.[[Promise]].[[PromiseIsHandled]] to true.
        12. Perform ! PerformPromiseThen(promiseCapability.[[Promise]], onFulfilled, onRejected, throwawayCapability).
        13. Return undefined.
      2. Else,
        1. Assert: completion.[[Type]] is throw.
        2. Perform ! AsyncGeneratorReject(generator, completion.[[Value]]).
        3. Return undefined.
  11. Else if state is "completed", return ! AsyncGeneratorResolve(generator, undefined, true).
  12. Assert: state is either "suspendedStart" or "suspendedYield".
  13. Let genContext be generator.[[AsyncGeneratorContext]].
  14. Let callerContext be the running execution context.
  15. Suspend callerContext.
  16. Set generator.[[AsyncGeneratorState]] to "executing".
  17. Push genContext onto the execution context stack; genContext is now the running execution context.
  18. Resume the suspended evaluation of genContext using completion as the result of the operation that suspended it. Let result be the completion record returned by the resumed computation.
  19. Assert: result is never an abrupt completion.
  20. Assert: When we return here, genContext has already been removed from the execution context stack and callerContext is the currently running execution context.
  21. Return undefined.

25.5.3.5.1 AsyncGeneratorResumeNext Return Processor Fulfilled Functions

An AsyncGeneratorResumeNext return processor fulfilled function is an anonymous built-in function that is used as part of the AsyncGeneratorResumeNext specification device to unwrap promises passed in to the AsyncGenerator.prototype.return ( value ) method. Each AsyncGeneratorResumeNext return processor fulfilled function has a [[Generator]] internal slot.

When an AsyncGeneratorResumeNext return processor fulfilled function F is called with argument value, the following steps are taken:

  1. Set F.[[Generator]].[[AsyncGeneratorState]] to "completed".
  2. Return ! AsyncGeneratorResolve(F.[[Generator]], value, true).

The length property of an AsyncGeneratorResumeNext return processor fulfilled function is 1.

25.5.3.5.2 AsyncGeneratorResumeNext Return Processor Rejected Functions

An AsyncGeneratorResumeNext return processor rejected function is an anonymous built-in function that is used as part of the AsyncGeneratorResumeNext specification device to unwrap promises passed in to the AsyncGenerator.prototype.return ( value ) method. Each AsyncGeneratorResumeNext return processor rejected function has a [[Generator]] internal slot.

When an AsyncGeneratorResumeNext return processor rejected function F is called with argument reason, the following steps are taken:

  1. Set F.[[Generator]].[[AsyncGeneratorState]] to "completed".
  2. Return ! AsyncGeneratorReject(F.[[Generator]], reason).

The length property of an AsyncGeneratorResumeNext return processor rejected function is 1.

25.5.3.6 AsyncGeneratorEnqueue ( generator, completion )

  1. Assert: completion is a Completion Record.
  2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
  3. If Type(generator) is not Object, or if generator does not have an [[AsyncGeneratorState]] internal slot, then
    1. Let badGeneratorError be a newly created TypeError object.
    2. Perform ! Call(promiseCapability.[[Reject]], undefined, « badGeneratorError »).
    3. Return promiseCapability.[[Promise]].
  4. Let queue be generator.[[AsyncGeneratorQueue]].
  5. Let request be AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }.
  6. Append request to the end of queue.
  7. Let state be generator.[[AsyncGeneratorState]].
  8. If state is not "executing", then
    1. Perform ! AsyncGeneratorResumeNext(generator).
  9. Return promiseCapability.[[Promise]].

25.5.3.7 AsyncGeneratorYield ( value )

The abstract operation AsyncGeneratorYield with argument value performs the following steps:

  1. Let genContext be the running execution context.
  2. Assert: genContext is the execution context of a generator.
  3. Let generator be the value of the Generator component of genContext.
  4. Assert: GetGeneratorKind() is async.
  5. Set value to ? Await(value).
  6. Set generator.[[AsyncGeneratorState]] to "suspendedYield".
  7. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
  8. Set the code evaluation state of genContext such that when evaluation is resumed with a Completion resumptionValue the following steps will be performed:
    1. If resumptionValue.[[Type]] is not return, return Completion(resumptionValue).
    2. Let awaited be Await(resumptionValue.[[Value]]).
    3. If awaited.[[Type]] is throw, return Completion(awaited).
    4. Assert: awaited.[[Type]] is normal.
    5. Return Completion { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
    6. NOTE: When one of the above steps returns, it returns to the evaluation of the YieldExpression production that originally called this abstract operation.
  9. Return ! AsyncGeneratorResolve(generator, value, false).
  10. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of genContext.

25.6 Promise Objects

A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.

Any Promise object is in one of three mutually exclusive states: fulfilled, rejected, and pending:

  • A promise p is fulfilled if p.then(f, r) will immediately enqueue a Job to call the function f.
  • A promise p is rejected if p.then(f, r) will immediately enqueue a Job to call the function r.
  • A promise is pending if it is neither fulfilled nor rejected.

A promise is said to be settled if it is not pending, i.e. if it is either fulfilled or rejected.

A promise is resolved if it is settled or if it has been “locked in” to match the state of another promise. Attempting to resolve or reject a resolved promise has no effect. A promise is unresolved if it is not resolved. An unresolved promise is always in the pending state. A resolved promise may be pending, fulfilled or rejected.

25.6.1 Promise Abstract Operations

25.6.1.1 PromiseCapability Records

A PromiseCapability is a Record value used to encapsulate a promise object along with the functions that are capable of resolving or rejecting that promise object. PromiseCapability Records are produced by the NewPromiseCapability abstract operation.

PromiseCapability Records have the fields listed in Table 71.

Field Name Value Meaning
[[Promise]] An object An object that is usable as a promise.
[[Resolve]] A function object The function that is used to resolve the given promise object.
[[Reject]] A function object The function that is used to reject the given promise object.

25.6.1.1.1 IfAbruptRejectPromise ( value, capability )

IfAbruptRejectPromise is a shorthand for a sequence of algorithm steps that use a PromiseCapability Record. An algorithm step of the form:

  1. IfAbruptRejectPromise(value, capability).

means the same thing as:

  1. If value is an abrupt completion, then
    1. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »).
    2. Return capability.[[Promise]].
  2. Else if value is a Completion Record, let value be value.[[Value]].

25.6.1.2 PromiseReaction Records

The PromiseReaction is a Record value used to store information about how a promise should react when it becomes resolved or rejected with a given value. PromiseReaction records are created by the PerformPromiseThen abstract operation, and are used by a PromiseReactionJob.

PromiseReaction records have the fields listed in Table 72.

Field Name Value Meaning
[[Capability]] A PromiseCapability Record The capabilities of the promise for which this record provides a reaction handler.
[[Type]] Either "Fulfill" or "Reject". The [[Type]] is used when [[Handler]] is undefined to allow for behaviour specific to the settlement type.
[[Handler]] A function object or undefined. The function that should be applied to the incoming value, and whose return value will govern what happens to the derived promise. If [[Handler]] is undefined, a function that depends on the value of [[Type]] will be used instead.

25.6.1.3 CreateResolvingFunctions ( promise )

When CreateResolvingFunctions is performed with argument promise, the following steps are taken:

  1. Let alreadyResolved be a new Record { [[Value]]: false }.
  2. Let stepsResolve be the algorithm steps defined in Promise Resolve Functions (25.6.1.3.2).
  3. Let resolve be CreateBuiltinFunction(stepsResolve, « [[Promise]], [[AlreadyResolved]] »).
  4. Set resolve.[[Promise]] to promise.
  5. Set resolve.[[AlreadyResolved]] to alreadyResolved.
  6. Let stepsReject be the algorithm steps defined in Promise Reject Functions (25.6.1.3.1).
  7. Let reject be CreateBuiltinFunction(stepsReject, « [[Promise]], [[AlreadyResolved]] »).
  8. Set reject.[[Promise]] to promise.
  9. Set reject.[[AlreadyResolved]] to alreadyResolved.
  10. Return a new Record { [[Resolve]]: resolve, [[Reject]]: reject }.

25.6.1.3.1 Promise Reject Functions

A promise reject function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.

When a promise reject function F is called with argument reason, the following steps are taken:

  1. Assert: F has a [[Promise]] internal slot whose value is an Object.
  2. Let promise be F.[[Promise]].
  3. Let alreadyResolved be F.[[AlreadyResolved]].
  4. If alreadyResolved.[[Value]] is true, return undefined.
  5. Set alreadyResolved.[[Value]] to true.
  6. Return RejectPromise(promise, reason).

The length property of a promise reject function is 1.

25.6.1.3.2 Promise Resolve Functions

A promise resolve function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.

When a promise resolve function F is called with argument resolution, the following steps are taken:

  1. Assert: F has a [[Promise]] internal slot whose value is an Object.
  2. Let promise be F.[[Promise]].
  3. Let alreadyResolved be F.[[AlreadyResolved]].
  4. If alreadyResolved.[[Value]] is true, return undefined.
  5. Set alreadyResolved.[[Value]] to true.
  6. If SameValue(resolution, promise) is true, then
    1. Let selfResolutionError be a newly created TypeError object.
    2. Return RejectPromise(promise, selfResolutionError).
  7. If Type(resolution) is not Object, then
    1. Return FulfillPromise(promise, resolution).
  8. Let then be Get(resolution, "then").
  9. If then is an abrupt completion, then
    1. Return RejectPromise(promise, then.[[Value]]).
  10. Let thenAction be then.[[Value]].
  11. If IsCallable(thenAction) is false, then
    1. Return FulfillPromise(promise, resolution).
  12. Perform EnqueueJob("PromiseJobs", PromiseResolveThenableJob, « promise, resolution, thenAction »).
  13. Return undefined.

The length property of a promise resolve function is 1.

25.6.1.4 FulfillPromise ( promise, value )

When the FulfillPromise abstract operation is called with arguments promise and value, the following steps are taken:

  1. Assert: The value of promise.[[PromiseState]] is "pending".
  2. Let reactions be promise.[[PromiseFulfillReactions]].
  3. Set promise.[[PromiseResult]] to value.
  4. Set promise.[[PromiseFulfillReactions]] to undefined.
  5. Set promise.[[PromiseRejectReactions]] to undefined.
  6. Set promise.[[PromiseState]] to "fulfilled".
  7. Return TriggerPromiseReactions(reactions, value).

25.6.1.5 NewPromiseCapability ( C )

The abstract operation NewPromiseCapability takes a constructor function, and attempts to use that constructor function in the fashion of the built-in Promise constructor to create a Promise object and extract its resolve and reject functions. The promise plus the resolve and reject functions are used to initialize a new PromiseCapability Record which is returned as the value of this abstract operation.

  1. If IsConstructor(C) is false, throw a TypeError exception.
  2. NOTE: C is assumed to be a constructor function that supports the parameter conventions of the Promise constructor (see 25.6.3.1).
  3. Let promiseCapability be a new PromiseCapability { [[Promise]]: undefined, [[Resolve]]: undefined, [[Reject]]: undefined }.
  4. Let steps be the algorithm steps defined in GetCapabilitiesExecutor Functions.
  5. Let executor be CreateBuiltinFunction(steps, « [[Capability]] »).
  6. Set executor.[[Capability]] to promiseCapability.
  7. Let promise be ? Construct(C, « executor »).
  8. If IsCallable(promiseCapability.[[Resolve]]) is false, throw a TypeError exception.
  9. If IsCallable(promiseCapability.[[Reject]]) is false, throw a TypeError exception.
  10. Set promiseCapability.[[Promise]] to promise.
  11. Return promiseCapability.
 Note

This abstract operation supports Promise subclassing, as it is generic on any constructor that calls a passed executor function argument in the same way as the Promise constructor. It is used to generalize static methods of the Promise constructor to any subclass.

25.6.1.5.1 GetCapabilitiesExecutor Functions

A GetCapabilitiesExecutor function is an anonymous built-in function that has a [[Capability]] internal slot.

When a GetCapabilitiesExecutor function F is called with arguments resolve and reject, the following steps are taken:

  1. Assert: F has a [[Capability]] internal slot whose value is a PromiseCapability Record.
  2. Let promiseCapability be F.[[Capability]].
  3. If promiseCapability.[[Resolve]] is not undefined, throw a TypeError exception.
  4. If promiseCapability.[[Reject]] is not undefined, throw a TypeError exception.
  5. Set promiseCapability.[[Resolve]] to resolve.
  6. Set promiseCapability.[[Reject]] to reject.
  7. Return undefined.

The length property of a GetCapabilitiesExecutor function is 2.

25.6.1.6 IsPromise ( x )

The abstract operation IsPromise checks for the promise brand on an object.

  1. If Type(x) is not Object, return false.
  2. If x does not have a [[PromiseState]] internal slot, return false.
  3. Return true.

25.6.1.7 RejectPromise ( promise, reason )

When the RejectPromise abstract operation is called with arguments promise and reason, the following steps are taken:

  1. Assert: The value of promise.[[PromiseState]] is "pending".
  2. Let reactions be promise.[[PromiseRejectReactions]].
  3. Set promise.[[PromiseResult]] to reason.
  4. Set promise.[[PromiseFulfillReactions]] to undefined.
  5. Set promise.[[PromiseRejectReactions]] to undefined.
  6. Set promise.[[PromiseState]] to "rejected".
  7. If promise.[[PromiseIsHandled]] is false, perform HostPromiseRejectionTracker(promise, "reject").
  8. Return TriggerPromiseReactions(reactions, reason).

25.6.1.8 TriggerPromiseReactions ( reactions, argument )

The abstract operation TriggerPromiseReactions takes a collection of PromiseReactionRecords and enqueues a new Job for each record. Each such Job processes the [[Type]] and [[Handler]] of the PromiseReactionRecord, and if the [[Handler]] is a function, calls it passing the given argument. If the [[Handler]] is undefined, the behaviour is determined by the [[Type]].

  1. For each reaction in reactions, in original insertion order, do
    1. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « reaction, argument »).
  2. Return undefined.

25.6.1.9 HostPromiseRejectionTracker ( promise, operation )

HostPromiseRejectionTracker is an implementation-defined abstract operation that allows host environments to track promise rejections.

An implementation of HostPromiseRejectionTracker must complete normally in all cases. The default implementation of HostPromiseRejectionTracker is to unconditionally return an empty normal completion.

Note 1

HostPromiseRejectionTracker is called in two scenarios:

  • When a promise is rejected without any handlers, it is called with its operation argument set to "reject".
  • When a handler is added to a rejected promise for the first time, it is called with its operation argument set to "handle".

A typical implementation of HostPromiseRejectionTracker might try to notify developers of unhandled rejections, while also being careful to notify them if such previous notifications are later invalidated by new handlers being attached.

 Note 2

If operation is "handle", an implementation should not hold a reference to promise in a way that would interfere with garbage collection. An implementation may hold a reference to promise if operation is "reject", since it is expected that rejections will be rare and not on hot code paths.

25.6.2 Promise Jobs

25.6.2.1 PromiseReactionJob ( reaction, argument )

The job PromiseReactionJob with parameters reaction and argument applies the appropriate handler to the incoming value, and uses the handler's return value to resolve or reject the derived promise associated with that handler.

  1. Assert: reaction is a PromiseReaction Record.
  2. Let promiseCapability be reaction.[[Capability]].
  3. Let type be reaction.[[Type]].
  4. Let handler be reaction.[[Handler]].
  5. If handler is undefined, then
    1. If type is "Fulfill", let handlerResult be NormalCompletion(argument).
    2. Else,
      1. Assert: type is "Reject".
      2. Let handlerResult be ThrowCompletion(argument).
  6. Else, let handlerResult be Call(handler, undefined, « argument »).
  7. If handlerResult is an abrupt completion, then
    1. Let status be Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »).
  8. Else,
    1. Let status be Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »).
  9. Return Completion(status).

25.6.2.2 PromiseResolveThenableJob ( promiseToResolve, thenable, then )

The job PromiseResolveThenableJob with parameters promiseToResolve, thenable, and then performs the following steps:

  1. Let resolvingFunctions be CreateResolvingFunctions(promiseToResolve).
  2. Let thenCallResult be Call(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
  3. If thenCallResult is an abrupt completion, then
    1. Let status be Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).
    2. Return Completion(status).
  4. Return Completion(thenCallResult).
 Note

This Job uses the supplied thenable and its then method to resolve the given promise. This process must take place as a Job to ensure that the evaluation of the then method occurs after evaluation of any surrounding code has completed.

25.6.3 The Promise Constructor

The Promise constructor:

  • is the intrinsic object %Promise%.
  • is the initial value of the Promise property of the global object.
  • creates and initializes a new Promise object when called as a constructor.
  • is not intended to be called as a function and will throw an exception when called in that manner.
  • is designed to be subclassable. It may be used as the value in an extends clause of a class definition. Subclass constructors that intend to inherit the specified Promise behaviour must include a super call to the Promise constructor to create and initialize the subclass instance with the internal state necessary to support the Promise and Promise.prototype built-in methods.

25.6.3.1 Promise ( executor )

When the Promise function is called with argument executor, the following steps are taken:

  1. If NewTarget is undefined, throw a TypeError exception.
  2. If IsCallable(executor) is false, throw a TypeError exception.
  3. Let promise be ? OrdinaryCreateFromConstructor(NewTarget, "%PromisePrototype%", « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »).
  4. Set promise.[[PromiseState]] to "pending".
  5. Set promise.[[PromiseFulfillReactions]] to a new empty List.
  6. Set promise.[[PromiseRejectReactions]] to a new empty List.
  7. Set promise.[[PromiseIsHandled]] to false.
  8. Let resolvingFunctions be CreateResolvingFunctions(promise).
  9. Let completion be Call(executor, undefined, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
  10. If completion is an abrupt completion, then
    1. Perform ? Call(resolvingFunctions.[[Reject]], undefined, « completion.[[Value]] »).
  11. Return promise.
 Note

The executor argument must be a function object. It is called for initiating and reporting completion of the possibly deferred action represented by this Promise object. The executor is called with two arguments: resolve and reject. These are functions that may be used by the executor function to report eventual completion or failure of the deferred computation. Returning from the executor function does not mean that the deferred action has been completed but only that the request to eventually perform the deferred action has been accepted.

The resolve function that is passed to an executor function accepts a single argument. The executor code may eventually call the resolve function to indicate that it wishes to resolve the associated Promise object. The argument passed to the resolve function represents the eventual value of the deferred action and can be either the actual fulfillment value or another Promise object which will provide the value if it is fulfilled.

The reject function that is passed to an executor function accepts a single argument. The executor code may eventually call the reject function to indicate that the associated Promise is rejected and will never be fulfilled. The argument passed to the reject function is used as the rejection value of the promise. Typically it will be an Error object.

The resolve and reject functions passed to an executor function by the Promise constructor have the capability to actually resolve and reject the associated promise. Subclasses may have different constructor behaviour that passes in customized values for resolve and reject.

25.6.4 Properties of the Promise Constructor

The Promise constructor:

  • has a [[Prototype]] internal slot whose value is the intrinsic object %FunctionPrototype%.
  • has the following properties:

25.6.4.1 Promise.all ( iterable )

The all function returns a new promise which is fulfilled with an array of fulfillment values for the passed promises, or rejects with the reason of the first passed promise that rejects. It resolves all elements of the passed iterable to promises as it runs this algorithm.

  1. Let C be the this value.
  2. If Type(C) is not Object, throw a TypeError exception.
  3. Let promiseCapability be ? NewPromiseCapability(C).
  4. Let iteratorRecord be GetIterator(iterable).
  5. IfAbruptRejectPromise(iteratorRecord, promiseCapability).
  6. Let result be PerformPromiseAll(iteratorRecord, C, promiseCapability).
  7. If result is an abrupt completion, then
    1. If iteratorRecord.[[Done]] is false, let result be IteratorClose(iteratorRecord, result).
    2. IfAbruptRejectPromise(result, promiseCapability).
  8. Return Completion(result).

This function is the %Promise_all% intrinsic object.

Note

The all function requires its this value to be a constructor function that supports the parameter conventions of the Promise constructor.

25.6.4.1.1 Runtime Semantics: PerformPromiseAll ( iteratorRecord, constructor, resultCapability )

When the PerformPromiseAll abstract operation is called with arguments iteratorRecord, constructor, and resultCapability, the following steps are taken:

  1. Assert: constructor is a constructor function.
  2. Assert: resultCapability is a PromiseCapability Record.
  3. Let values be a new empty List.
  4. Let remainingElementsCount be a new Record { [[Value]]: 1 }.
  5. Let index be 0.
  6. Repeat,
    1. Let next be IteratorStep(iteratorRecord).
    2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
    3. ReturnIfAbrupt(next).
    4. If next is false, then
      1. Set iteratorRecord.[[Done]] to true.
      2. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
      3. If remainingElementsCount.[[Value]] is 0, then
        1. Let valuesArray be CreateArrayFromList(values).
        2. Perform ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »).
      4. Return resultCapability.[[Promise]].
    5. Let nextValue be IteratorValue(next).
    6. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
    7. ReturnIfAbrupt(nextValue).
    8. Append undefined to values.
    9. Let nextPromise be ? Invoke(constructor, "resolve", « nextValue »).
    10. Let steps be the algorithm steps defined in Promise.all Resolve Element Functions.
    11. Let resolveElement be CreateBuiltinFunction(steps, « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »).
    12. Set resolveElement.[[AlreadyCalled]] to a new Record { [[Value]]: false }.
    13. Set resolveElement.[[Index]] to index.
    14. Set resolveElement.[[Values]] to values.
    15. Set resolveElement.[[Capability]] to resultCapability.
    16. Set resolveElement.[[RemainingElements]] to remainingElementsCount.
    17. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.
    18. Perform ? Invoke(nextPromise, "then", « resolveElement, resultCapability.[[Reject]] »).
    19. Set index to index + 1.

25.6.4.1.2 Promise.all Resolve Element Functions

A Promise.all resolve element function is an anonymous built-in function that is used to resolve a specific Promise.all element. Each Promise.all resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.

When a Promise.all resolve element function F is called with argument x, the following steps are taken:

  1. Let alreadyCalled be F.[[AlreadyCalled]].
  2. If alreadyCalled.[[Value]] is true, return undefined.
  3. Set alreadyCalled.[[Value]] to true.
  4. Let index be F.[[Index]].
  5. Let values be F.[[Values]].
  6. Let promiseCapability be F.[[Capability]].
  7. Let remainingElementsCount be F.[[RemainingElements]].
  8. Set values[index] to x.
  9. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
  10. If remainingElementsCount.[[Value]] is 0, then
    1. Let valuesArray be CreateArrayFromList(values).
    2. Return ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »).
  11. Return undefined.

The length property of a Promise.all resolve element function is 1.

25.6.4.2 Promise.prototype

The initial value of Promise.prototype is the intrinsic object %PromisePrototype%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.6.4.3 Promise.race ( iterable )

The race function returns a new promise which is settled in the same way as the first passed promise to settle. It resolves all elements of the passed iterable to promises as it runs this algorithm.

  1. Let C be the this value.
  2. If Type(C) is not Object, throw a TypeError exception.
  3. Let promiseCapability be ? NewPromiseCapability(C).
  4. Let iteratorRecord be GetIterator(iterable).
  5. IfAbruptRejectPromise(iteratorRecord, promiseCapability).
  6. Let result be PerformPromiseRace(iteratorRecord, C, promiseCapability).
  7. If result is an abrupt completion, then
    1. If iteratorRecord.[[Done]] is false, let result be IteratorClose(iterator, result).
    2. IfAbruptRejectPromise(result, promiseCapability).
  8. Return Completion(result).
 Note 1

If the iterable argument is empty or if none of the promises in iterable ever settle then the pending promise returned by this method will never be settled.

 Note 2

The race function expects its this value to be a constructor function that supports the parameter conventions of the Promise constructor. It also expects that its this value provides a resolve method.

25.6.4.3.1 Runtime Semantics: PerformPromiseRace ( iteratorRecord, constructor, resultCapability )

When the PerformPromiseRace abstract operation is called with arguments iteratorRecord, constructor, and resultCapability, the following steps are taken:

  1. Assert: constructor is a constructor function.
  2. Assert: resultCapability is a PromiseCapability Record.
  3. Repeat,
    1. Let next be IteratorStep(iteratorRecord).
    2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
    3. ReturnIfAbrupt(next).
    4. If next is false, then
      1. Set iteratorRecord.[[Done]] to true.
      2. Return resultCapability.[[Promise]].
    5. Let nextValue be IteratorValue(next).
    6. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
    7. ReturnIfAbrupt(nextValue).
    8. Let nextPromise be ? Invoke(constructor, "resolve", « nextValue »).
    9. Perform ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], resultCapability.[[Reject]] »).

25.6.4.4 Promise.reject ( r )

The reject function returns a new promise rejected with the passed argument.

  1. Let C be the this value.
  2. If Type(C) is not Object, throw a TypeError exception.
  3. Let promiseCapability be ? NewPromiseCapability(C).
  4. Perform ? Call(promiseCapability.[[Reject]], undefined, « r »).
  5. Return promiseCapability.[[Promise]].

This function is the %Promise_reject% intrinsic object.

Note

The reject function expects its this value to be a constructor function that supports the parameter conventions of the Promise constructor.

25.6.4.5 Promise.resolve ( x )

The resolve function returns either a new promise resolved with the passed argument, or the argument itself if the argument is a promise produced by this constructor.

  1. Let C be the this value.
  2. If Type(C) is not Object, throw a TypeError exception.
  3. Return ? PromiseResolve(C, x).

This function is the %Promise_resolve% intrinsic object.

Note

The resolve function expects its this value to be a constructor function that supports the parameter conventions of the Promise constructor.

25.6.4.5.1 PromiseResolve ( C, x )

The abstract operation PromiseResolve, given a constructor and a value, returns a new promise resolved with that value.

  1. Assert: Type(C) is Object.
  2. If IsPromise(x) is true, then
    1. Let xConstructor be ? Get(x, "constructor").
    2. If SameValue(xConstructor, C) is true, return x.
  3. Let promiseCapability be ? NewPromiseCapability(C).
  4. Perform ? Call(promiseCapability.[[Resolve]], undefined, « x »).
  5. Return promiseCapability.[[Promise]].

25.6.4.6 get Promise [ @@species ]

Promise[@@species] is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

  1. Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

Promise prototype methods normally use their this object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.

25.6.5 Properties of the Promise Prototype Object

The Promise prototype object:

  • is the intrinsic object %PromisePrototype%.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %ObjectPrototype%.
  • is an ordinary object.
  • does not have a [[PromiseState]] internal slot or any of the other internal slots of Promise instances.

25.6.5.1 Promise.prototype.catch ( onRejected )

When the catch method is called with argument onRejected, the following steps are taken:

  1. Let promise be the this value.
  2. Return ? Invoke(promise, "then", « undefined, onRejected »).

25.6.5.2 Promise.prototype.constructor

The initial value of Promise.prototype.constructor is the intrinsic object %Promise%.

25.6.5.3 Promise.prototype.finally ( onFinally )

When the finally method is called with argument onFinally, the following steps are taken:

  1. Let promise be the this value.
  2. If Type(promise) is not Object, throw a TypeError exception.
  3. Let C be ? SpeciesConstructor(promise, %Promise%).
  4. Assert: IsConstructor(C) is true.
  5. If IsCallable(onFinally) is false, then
    1. Let thenFinally be onFinally.
    2. Let catchFinally be onFinally.
  6. Else,
    1. Let stepsThenFinally be the algorithm steps defined in Then Finally Functions.
    2. Let thenFinally be CreateBuiltinFunction(stepsThenFinally, « [[Constructor]], [[OnFinally]] »).
    3. Set thenFinally.[[Constructor]] to C.
    4. Set thenFinally.[[OnFinally]] to onFinally.
    5. Let stepsCatchFinally be the algorithm steps defined in Catch Finally Functions.
    6. Let catchFinally be CreateBuiltinFunction(stepsCatchFinally, « [[Constructor]], [[OnFinally]] »).
    7. Set catchFinally.[[Constructor]] to C.
    8. Set catchFinally.[[OnFinally]] to onFinally.
  7. Return ? Invoke(promise, "then", « thenFinally, catchFinally »).

25.6.5.3.1 Then Finally Functions

A Then Finally function is an anonymous built-in function that has a [[Constructor]] and an [[OnFinally]] internal slot. The value of the [[Constructor]] internal slot is a Promise-like constructor function object, and the value of the [[OnFinally]] internal slot is a function object.

When a Then Finally function F is called with argument value, the following steps are taken:

  1. Let onFinally be F.[[OnFinally]].
  2. Assert: IsCallable(onFinally) is true.
  3. Let result be ? Call(onFinally, undefined).
  4. Let C be F.[[Constructor]].
  5. Assert: IsConstructor(C) is true.
  6. Let promise be ? PromiseResolve(C, result).
  7. Let valueThunk be equivalent to a function that returns value.
  8. Return ? Invoke(promise, "then", « valueThunk »).

The length property of a Then Finally function is 1.

25.6.5.3.2 Catch Finally Functions

A Catch Finally function is an anonymous built-in function that has a [[Constructor]] and an [[OnFinally]] internal slot. The value of the [[Constructor]] internal slot is a Promise-like constructor function object, and the value of the [[OnFinally]] internal slot is a function object.

When a Catch Finally function F is called with argument reason, the following steps are taken:

  1. Let onFinally be F.[[OnFinally]].
  2. Assert: IsCallable(onFinally) is true.
  3. Let result be ? Call(onFinally, undefined).
  4. Let C be F.[[Constructor]].
  5. Assert: IsConstructor(C) is true.
  6. Let promise be ? PromiseResolve(C, result).
  7. Let thrower be equivalent to a function that throws reason.
  8. Return ? Invoke(promise, "then", « thrower »).

The length property of a Catch Finally function is 1.

25.6.5.4 Promise.prototype.then ( onFulfilled, onRejected )

When the then method is called with arguments onFulfilled and onRejected, the following steps are taken:

  1. Let promise be the this value.
  2. If IsPromise(promise) is false, throw a TypeError exception.
  3. Let C be ? SpeciesConstructor(promise, %Promise%).
  4. Let resultCapability be ? NewPromiseCapability(C).
  5. Return PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability).

This function is the %PromiseProto_then% intrinsic object.

25.6.5.4.1 PerformPromiseThen ( promise, onFulfilled, onRejected, resultCapability )

The abstract operation PerformPromiseThen performs the “then” operation on promise using onFulfilled and onRejected as its settlement actions. The result is resultCapability's promise.

  1. Assert: IsPromise(promise) is true.
  2. Assert: resultCapability is a PromiseCapability Record.
  3. If IsCallable(onFulfilled) is false, then
    1. Set onFulfilled to undefined.
  4. If IsCallable(onRejected) is false, then
    1. Set onRejected to undefined.
  5. Let fulfillReaction be the PromiseReaction { [[Capability]]: resultCapability, [[Type]]: "Fulfill", [[Handler]]: onFulfilled }.
  6. Let rejectReaction be the PromiseReaction { [[Capability]]: resultCapability, [[Type]]: "Reject", [[Handler]]: onRejected }.
  7. If promise.[[PromiseState]] is "pending", then
    1. Append fulfillReaction as the last element of the List that is promise.[[PromiseFulfillReactions]].
    2. Append rejectReaction as the last element of the List that is promise.[[PromiseRejectReactions]].
  8. Else if promise.[[PromiseState]] is "fulfilled", then
    1. Let value be promise.[[PromiseResult]].
    2. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « fulfillReaction, value »).
  9. Else,
    1. Assert: The value of promise.[[PromiseState]] is "rejected".
    2. Let reason be promise.[[PromiseResult]].
    3. If promise.[[PromiseIsHandled]] is false, perform HostPromiseRejectionTracker(promise, "handle").
    4. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « rejectReaction, reason »).
  10. Set promise.[[PromiseIsHandled]] to true.
  11. Return resultCapability.[[Promise]].

25.6.5.5 Promise.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the String value "Promise".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.6.6 Properties of Promise Instances

Promise instances are ordinary objects that inherit properties from the Promise prototype object (the intrinsic, %PromisePrototype%). Promise instances are initially created with the internal slots described in Table 73.

Internal Slot Description
[[PromiseState]] A String value that governs how a promise will react to incoming calls to its then method. The possible values are: "pending", "fulfilled", and "rejected".
[[PromiseResult]] The value with which the promise has been fulfilled or rejected, if any. Only meaningful if [[PromiseState]] is not "pending".
[[PromiseFulfillReactions]] A List of PromiseReaction records to be processed when/if the promise transitions from the "pending" state to the "fulfilled" state.
[[PromiseRejectReactions]] A List of PromiseReaction records to be processed when/if the promise transitions from the "pending" state to the "rejected" state.
[[PromiseIsHandled]] A boolean indicating whether the promise has ever had a fulfillment or rejection handler; used in unhandled rejection tracking.

25.7 AsyncFunction Objects

AsyncFunction objects are functions that are usually created by evaluating AsyncFunctionDeclarations, AsyncFunctionExpressions, AsyncMethods, and AsyncArrowFunctions. They may also be created by calling the %AsyncFunction% intrinsic.

25.7.1 The AsyncFunction Constructor

The AsyncFunction constructor:

  • is the intrinsic object %AsyncFunction%.
  • is a subclass of Function.
  • creates and initializes a new AsyncFunction object when called as a function rather than as a constructor. Thus the function call AsyncFunction(…) is equivalent to the object creation expression new AsyncFunction(…) with the same arguments.
  • is designed to be subclassable. It may be used as the value of an extends clause of a class definition. Subclass constructors that intend to inherit the specified AsyncFunction behaviour must include a super call to the AsyncFunction constructor to create and initialize a subclass instance with the internal slots necessary for built-in async function behaviour.

25.7.1.1 AsyncFunction ( p1, p2, … , pn, body )

The last argument specifies the body (executable code) of an async function. Any preceding arguments specify formal parameters.

When the AsyncFunction function is called with some arguments p1, p2, …, pn, body (where n might be 0, that is, there are no p arguments, and where body might also not be provided), the following steps are taken:

  1. Let C be the active function object.
 Note
See NOTE for 19.2.1.1.

25.7.2 Properties of the AsyncFunction Constructor

The AsyncFunction constructor:

  • is a standard built-in function object that inherits from the Function constructor.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %Function%.
  • has a name property whose value is "AsyncFunction".
  • has the following properties:

25.7.2.1 AsyncFunction.length

This is a data property with a value of 1. This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.2.2 AsyncFunction.prototype

The initial value of AsyncFunction.prototype is the intrinsic object %AsyncFunctionPrototype%.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.7.3 Properties of the AsyncFunction Prototype Object

The AsyncFunction prototype object:

  • is an ordinary object.
  • is not a function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed in Table 27.
  • is the value of the prototype property of the intrinsic object %AsyncFunction%.
  • is the intrinsic object %AsyncFunctionPrototype%.
  • has a [[Prototype]] internal slot whose value is the intrinsic object %FunctionPrototype%.

25.7.3.1 AsyncFunction.prototype.constructor

The initial value of AsyncFunction.prototype.constructor is the intrinsic object %AsyncFunction%

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.3.2 AsyncFunction.prototype [ @@toStringTag ]

The initial value of the @@toStringTag property is the string value "AsyncFunction".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.4 AsyncFunction Instances

Every AsyncFunction instance is an ECMAScript function object and has the internal slots listed in Table 27. The value of the [[FunctionKind]] internal slot for all such instances is "async". AsyncFunction instances are not constructors and do not have a [[Construct]] internal method. AsyncFunction instances do not have a prototype property as they are not constructable.

Each AsyncFunction instance has the following own properties:

25.7.4.1 length

The specification for the length property of Function instances given in 19.2.4.1 also applies to AsyncFunction instances.

25.7.4.2 name

The specification for the name property of Function instances given in 19.2.4.2 also applies to AsyncFunction instances.

25.7.5 Async Functions Abstract Operations

25.7.5.1 AsyncFunctionStart ( promiseCapability, asyncFunctionBody )

  1. Let runningContext be the running execution context.
  2. Let asyncContext be a copy of runningContext.
  3. Set the code evaluation state of asyncContext such that when evaluation is resumed for that execution context the following steps will be performed:
    1. Let result be the result of evaluating asyncFunctionBody.
    2. Assert: If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done.
    3. Remove asyncContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
    4. If result.[[Type]] is normal, then
      1. Perform ! Call(promiseCapability.[[Resolve]], undefined, « undefined »).
    5. Else if result.[[Type]] is return, then
      1. Perform ! Call(promiseCapability.[[Resolve]], undefined, « result.[[Value]] »).
    6. Else,
      1. Assert: result.[[Type]] is throw.
      2. Perform ! Call(promiseCapability.[[Reject]], undefined, « result.[[Value]] »).
    7. Return.
  4. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
  5. Resume the suspended evaluation of asyncContext. Let result be the value returned by the resumed computation.
  6. Assert: When we return here, asyncContext has already been removed from the execution context stack and runningContext is the currently running execution context.
  7. Assert: result is a normal completion with a value of undefined. The possible sources of completion values are Await or, if the async function doesn't await anything, the step 3.g above.
  8. Return.