Stage 3 Draft / February 12, 2018

[+In, ?Yield, ?Await]

;

Note

A return statement causes a function to cease execution and return a value to the caller. If Expression is omitted, the return value is undefined. Otherwise, the return value is the value of Expression.

7.1.1Runtime Semantics: Evaluation

ReturnStatement

return

;

Return Completion{[[Type]]: return, [[Value]]: undefined, [[Target]]: empty}.

ReturnStatement

return

;

Let exprRef be the result of evaluating Expression.
Let exprValue be ? GetValue(exprRef).
If ! GetGeneratorKind() is async, set exprValue to ? Await(exprValue).
Return Completion{[[Type]]: return, [[Value]]: exprValue, [[Target]]: empty}.

7.2Iteration Statements

Syntax

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

while

(

[+In, ?Yield, ?Await]

)

;

while

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[~In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

var

VariableDeclarationList

[~In, ?Yield, ?Await]

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

LexicalDeclaration

[~In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

Note

This section is extended by Annex B.3.6.

7.2.1Semantics

7.2.1.1Static Semantics: Early Errors

while

(

)

;

while

(

)

for

(

opt

;

opt

;

opt

)

for

(

var

VariableDeclarationList

;

opt

;

opt

)

for

(

LexicalDeclaration

opt

;

opt

)

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

It is a Syntax Error if IsLabelledFunction(Statement) is true.

Note

It is only necessary to apply this rule if the extension specified in B.3.2 is implemented.

7.2.2The `for`-`in` and, `for`-`of`, and `for`-`await`-`of` Statements

7.2.2.1Static Semantics: Early Errors

for

(

)

for

(

)

for

await

(

)

It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol.

If LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression can be parsed with no tokens left over using AssignmentPattern as the goal symbol then the following rules are not applied. Instead, the Early Error rules for AssignmentPattern are used.

It is a Syntax Error if IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.
It is a Syntax Error if the LeftHandSideExpression is CoverParenthesizedExpressionAndArrowParameterList:(Expression) and Expression derives a production that would produce a Syntax Error according to these rules if that production is substituted for LeftHandSideExpression. This rule is recursively applied.

Note

The last rule means that the other rules are applied even if parentheses surround Expression.

for

(

)

for

(

)

for

await

(

)

It is a Syntax Error if the BoundNames of ForDeclaration contains "let".
It is a Syntax Error if any element of the BoundNames of ForDeclaration also occurs in the VarDeclaredNames of Statement.
It is a Syntax Error if the BoundNames of ForDeclaration contains any duplicate entries.

7.2.2.2Static Semantics: ContainsDuplicateLabels

With argument labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

Note

This section is extended by Annex B.3.6.

7.2.2.3Static Semantics: ContainsUndefinedBreakTarget

With argument labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

Note

This section is extended by Annex B.3.6.

7.2.2.4Static Semantics: ContainsUndefinedContinueTarget

With arguments iterationSet and labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

Note

This section is extended by Annex B.3.6.

7.2.2.5Static Semantics: VarDeclaredNames

for

(

)

Return the VarDeclaredNames of Statement.

for

(

var

)

Let names be the BoundNames of ForBinding.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

for

(

)

Return the VarDeclaredNames of Statement.

for

(

)

for

await

(

)

Return the VarDeclaredNames of Statement.

for

(

var

)

for

await

(

var

)

Let names be the BoundNames of ForBinding.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

for

(

)

for

await

(

)

Return the VarDeclaredNames of Statement.

Note

This section is extended by Annex B.3.6.

7.2.2.6Static Semantics: VarScopedDeclarations

for

(

)

Return the VarScopedDeclarations of Statement.

for

(

var

)

Let declarations be a List containing ForBinding.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

for

(

)

Return the VarScopedDeclarations of Statement.

for

(

)

for

await

(

)

Return the VarScopedDeclarations of Statement.

for

(

var

)

for

await

(

var

)

Let declarations be a List containing ForBinding.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

for

(

)

for

await

(

)

Return the VarScopedDeclarations of Statement.

Note

This section is extended by Annex B.3.6.

7.2.2.7Runtime Semantics: LabelledEvaluation

With argument labelSet.

for

(

)

Let keyResult be ? ForIn/OfHeadEvaluation(« », Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, assignment, labelSet).

for

(

var

)

Let keyResult be ? ForIn/OfHeadEvaluation(« », Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, varBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(BoundNames of ForDeclaration, Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, lexicalBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, assignment, labelSet).

for

(

var

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, varBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(BoundNames of ForDeclaration, AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, lexicalBinding, labelSet).

for

await

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, assignment, labelSet, async).

for

await

(

var

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, varBinding, labelSet, async).

for

await

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(BoundNames of ForDeclaration, AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, lexicalBinding, labelSet, async).

Note

This section is extended by Annex B.3.6.

7.2.2.8Runtime Semantics: ForIn/OfHeadEvaluation ( `TDZnames`, `expr`, `iterationKind` )

The abstract operation ForIn/OfHeadEvaluation is called with arguments TDZnames, expr, and iterationKind. The value of iterationKind is either enumerate or, iterate, or async-iterate.

Let oldEnv be the running execution context's LexicalEnvironment.
If TDZnames is not an empty List, then
1. Assert: TDZnames has no duplicate entries.
2. Let TDZ be ! NewDeclarativeEnvironment(oldEnv).
3. Let TDZEnvRec be TDZ's EnvironmentRecord.
4. For each string name in TDZnames, do
  1. Perform ! TDZEnvRec.CreateMutableBinding(name, false).
5. Set the running execution context's LexicalEnvironment to TDZ.
Let exprRef be the result of evaluating the production that is expr.
Set the running execution context's LexicalEnvironment to oldEnv.
Let exprValue be ? GetValue(exprRef).
If iterationKind is enumerate, then
1. If exprValue.[[Value]] is null or undefined, then
  1. Return Completion{[[Type]]: break, [[Value]]: empty, [[Target]]: empty}.
2. Let obj be ? ToObject(exprValue).
3. Return ? obj.[[Enumerate]]().
Else,
1. If iterationKind is async-iterate, let iteratorHint be async.
2. Else, let iteratorHint be normal.
3. Return ? GetIterator(exprValue, iteratorHint).

7.2.2.9Runtime Semantics: ForIn/OfBodyEvaluation ( `lhs`, `stmt`, `iteratorRecord`, `lhsKind`, `labelSet` [ , `iteratorKind` ] )

The abstract operation ForIn/OfBodyEvaluation is called with arguments lhs, stmt, iteratorRecord, lhsKind, ~~and~~ labelSet, and optional argument iteratorKind. The value of lhsKind is either assignment, varBinding or lexicalBinding. The value of iteratorKind is either normal or async.

If iteratorKind was not passed, let iteratorKind be normal.
Let oldEnv be the running execution context's LexicalEnvironment.
Let V be undefined.
Let destructuring be IsDestructuring of lhs.
If destructuring is true and if lhsKind is assignment, then
1. Assert: lhs is a LeftHandSideExpression.
2. Let assignmentPattern be the parse of the source text corresponding to lhs using AssignmentPattern as the goal symbol.
Repeat
1. ~~Let nextResult be ? IteratorStep(iteratorRecord).~~
2. ~~If nextResult is false, return NormalCompletion(V).~~
3. Let nextResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « »).
4. If iteratorKind is async, then set nextResult to ? Await(nextResult).
5. If Type(nextResult) is not Object, throw a TypeError exception.
6. Let done be ? IteratorComplete(nextResult).
7. If done is true, return NormalCompletion(V).
8. Let nextValue be ? IteratorValue(nextResult).
9. If lhsKind is either assignment or varBinding, then
  1. If destructuring is false, then
    1. Let lhsRef be the result of evaluating lhs (it may be evaluated repeatedly).
10. Else,
  1. Assert: lhsKind is lexicalBinding.
  2. Assert: lhs is a ForDeclaration.
  3. Let iterationEnv be NewDeclarativeEnvironment(oldEnv).
  4. Perform BindingInstantiation for lhs passing iterationEnv as the argument.
  5. Set the running execution context's LexicalEnvironment to iterationEnv.
  6. If destructuring is false, then
    1. Assert: lhs binds a single name.
    2. Let lhsName be the sole element of BoundNames of lhs.
    3. Let lhsRef be ResolveBinding(lhsName).
    4. Assert: lhsRef is not an abrupt completion.
11. If destructuring is false, then
  1. If lhsRef is an abrupt completion, then
    1. Let status be lhsRef.
  2. Else if lhsKind is lexicalBinding, then
    1. Let status be InitializeReferencedBinding(lhsRef, nextValue).
  3. Else,
    1. Let status be PutValue(lhsRef, nextValue).
12. Else,
  1. If lhsKind is assignment, then
    1. Let status be the result of performing DestructuringAssignmentEvaluation of assignmentPattern using nextValue as the argument.
  2. Else if lhsKind is varBinding, then
    1. Assert: lhs is a ForBinding.
    2. Let status be the result of performing BindingInitialization for lhs passing nextValue and undefined as the arguments.
  3. Else,
    1. Assert: lhsKind is lexicalBinding.
    2. Assert: lhs is a ForDeclaration.
    3. Let status be the result of performing BindingInitialization for lhs passing nextValue and iterationEnv as arguments.
13. If status is an abrupt completion, then
  1. Set the running execution context's LexicalEnvironment to oldEnv.
  2. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  3. Return ? IteratorClose(iteratorRecord, status).
14. Let result be the result of evaluating stmt.
15. Set the running execution context's LexicalEnvironment to oldEnv.
16. If ! LoopContinues(result, labelSet) is false, ~~return ? IteratorClose(iteratorRecord, UpdateEmpty(result, V))~~then
  1. Let status be UpdateEmpty(result, V).
  2. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  3. Return ? IteratorClose(iteratorRecord, status).
17. If result.[[Value]] is not empty, let V be result.[[Value]].

8ECMAScript Language: Functions and Classes

Editor's Note

These patches modify clauses of and add clauses to 14.

8.1Method Definitions

8.1.1Static Semantics: SpecialMethod

MethodDefinition

(

)

{

}

Return false.

get

(

)

{

}

set

(

PropertySetParameterList

)

{

}

Return true.

8.2Generator Definitions

8.2.1Runtime Semantics: Evaluation

YieldExpression

yield

Let generatorKind be ! GetGeneratorKind().
If generatorKind is async, then return ? AsyncGeneratorYield(undefined).
Otherwise, rReturn ? GeneratorYield(CreateIterResultObject(undefined, false)).

YieldExpression

yield

Let generatorKind be ! GetGeneratorKind().
Let exprRef be the result of evaluating AssignmentExpression.
Let value be ? GetValue(exprRef).
If generatorKind is async, then return ? AsyncGeneratorYield(value).
Otherwise, rReturn ? GeneratorYield(CreateIterResultObject(value, false)).

YieldExpression

yield

Let generatorKind be ! GetGeneratorKind().
Let exprRef be the result of evaluating AssignmentExpression.
Let value be ? GetValue(exprRef).
Let iteratorRecord be ? GetIterator(value, generatorKind).
Let iterator be iteratorRecord.[[Iterator]].
Let received be NormalCompletion(undefined).
Repeat
1. If received.[[Type]] is normal, then
  1. ~~Let innerResult be ? IteratorNext(iteratorRecord, received.[[Value]]).~~
  2. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
  3. If generatorKind is async, then set innerResult to ? Await(innerResult).
  4. If Type(innerResult) is not Object, throw a TypeError exception.
  5. Let done be ? IteratorComplete(innerResult).
  6. If done is true, then
    1. Return ? IteratorValue(innerResult).
  7. If generatorKind is async, then let received be AsyncGeneratorYield(? IteratorValue(innerResult)).
  8. Else, lLet received be GeneratorYield(innerResult).
2. Else if received.[[Type]] is throw, then
  1. Let throw be ? GetMethod(iterator, "throw").
  2. If throw is not undefined, then
    1. Let innerResult be ? Call(throw, iterator, « received.[[Value]] »).
    2. If generatorKind is async, then set innerResult to ? Await(innerResult).
    3. NOTE: Exceptions from the inner iterator throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next.
    4. If Type(innerResult) is not Object, throw a TypeError exception.
    5. Let done be ? IteratorComplete(innerResult).
    6. If done is true, then
      1. Return ? IteratorValue(innerResult).
    7. If generatorKind is async, then let received be AsyncGeneratorYield(? IteratorValue(innerResult)).
    8. Else, lLet received be GeneratorYield(innerResult).
  3. Else,
    1. NOTE: If iterator does not have a throw method, this throw is going to terminate the yield* loop. But first we need to give iterator a chance to clean up.
    2. Let closeCompletion be Completion{[[Type]]: normal, [[Value]]: empty, [[Target]]: empty}.
    3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
    4. Else, pPerform ? IteratorClose(iteratorRecord, ~~Completion{[[Type]]: normal, [[Value]]: empty, [[Target]]: empty}~~closeCompletion).
    5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: iterator does not have a throw method.
    6. Throw a TypeError exception.
3. Else,
  1. Assert: received.[[Type]] is return.
  2. Let return be ? GetMethod(iterator, "return").
  3. If return is undefined, ~~return Completion(received).~~then:
    1. If generatorKind is async, then set received.[[Value]] to ? Await(received.[[Value]]).
    2. Return Completion(received).
  4. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
  5. If generatorKind is async, then set innerReturnResult to ? Await(innerReturnResult).
  6. If Type(innerReturnResult) is not Object, throw a TypeError exception.
  7. Let done be ? IteratorComplete(innerReturnResult).
  8. If done is true, then
    1. Let value be ? IteratorValue(innerReturnResult).
    2. Return Completion{[[Type]]: return, [[Value]]: value, [[Target]]: empty}.
  9. If generatorKind is async, then let received be AsyncGeneratorYield(? IteratorValue(innerResult)).
  10. Else, lLet received be GeneratorYield(innerResult).

8.3Async Generator Function Definitions

Syntax

[Yield, Await]

async

[no LineTerminator here]

[?Yield, ?Await]

(

[+Yield, +Await]

)

{

}

[Yield, Await, Default]

async

[no LineTerminator here]

function

[?Yield, ?Await]

(

[+Yield, +Await]

)

{

}

[+Default]

async

[no LineTerminator here]

function

(

[+Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

[+Yield, +Await]

opt

(

[+Yield, +Await]

)

{

}

[+Yield, +Await]

Note 1

YieldExpression and AwaitExpression cannot be used within the FormalParameters of an async generator function because any expressions that are part of FormalParameters are evaluated before the resulting async generator object is in a resumable state.

Note 2

Abstract operations relating to async generator objects are defined in 11.4.3.

8.3.1Static Semantics: Early Errors

(

)

{

}

It is a Syntax Error if HasDirectSuper of AsyncGeneratorMethod is true.
It is a Syntax Error if UniqueFormalParameters Contains YieldExpression is true.
It is a Syntax Error if UniqueFormalParameters Contains AwaitExpression is true.
It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
It is a Syntax Error if any element of the BoundNames of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of AsyncGeneratorBody.

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

If the source code matching this production is strict mode code, the Early Error rules for UniqueFormalParameters:FormalParameters are applied.
If the source code matching this production is strict mode code, it is a Syntax Error if BindingIdentifier is the IdentifierName eval or the IdentifierName arguments.
It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and IsSimpleParameterList of FormalParameters is false.
It is a Syntax Error if any element of the BoundNames of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncGeneratorBody.
It is a Syntax Error if FormalParameters Contains YieldExpression is true.
It is a Syntax Error if FormalParameters Contains AwaitExpression is true.
It is a Syntax Error if FormalParameters Contains SuperProperty is true.
It is a Syntax Error if AsyncGeneratorBody Contains SuperProperty is true.
It is a Syntax Error if FormalParameters Contains SuperCall is true.
It is a Syntax Error if AsyncGeneratorBody Contains SuperCall is true.

8.3.2Static Semantics: BoundNames

function

(

)

{

}

Return the BoundNames of BindingIdentifier.

function

(

)

{

}

Return « "*default*" ».

Note

"*default*" is used within this specification as a synthetic name for hoistable anonymous functions that are defined using export declarations.

8.3.3Static Semantics: ComputedPropertyContains

With parameter symbol.

(

)

{

}

Return the result of ComputedPropertyContains for PropertyName with argument symbol.

8.3.4Static Semantics: Contains

With parameter symbol.

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

Return false.

Note

Static semantic rules that depend upon substructure generally do not look into function definitions.

8.3.5Static Semantics: HasDirectSuper

(

)

{

}

If UniqueFormalParameters Contains SuperCall is true, return true.
Return AsyncGeneratorBody Contains SuperCall.

8.3.6Static Semantics: HasName

function

(

)

{

}

Return false.

function

(

)

{

}

Return true.

8.3.7Static Semantics: IsConstantDeclaration

function

(

)

{

}

function

(

)

{

}

Return false.

8.3.8Static Semantics: IsFunctionDefinition

function

opt

(

)

{

}

Return true.

8.3.9Static Semantics: PropName

(

)

{

}

Return PropName of PropertyName.

8.3.10Runtime Semantics: EvaluateBody

With parameters functionObject and List argumentsList.

Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
Let generator be ? OrdinaryCreateFromConstructor(functionObject, "%AsyncGeneratorPrototype%", « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]] »).
Perform ! AsyncGeneratorStart(generator, FunctionBody).
Return Completion{[[Type]]: return, [[Value]]: generator, [[Target]]: empty}.

8.3.11Runtime Semantics: InstantiateFunctionObject

With parameter scope.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncGeneratorDeclaration is strict mode code, let strict be true. Otherwise let strict be false.
Let name be StringValue of BindingIdentifier.
Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform ! SetFunctionName(F, name).
Return F.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncGeneratorDeclaration is strict mode code, let strict be true. Otherwise let strict be false.
Let F be AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ObjectCreate(%AsyncGeneratorPrototype%).
Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(F, "default").
Return F.

Note

An anonymous AsyncGeneratorDeclaration can only occur as part of an export default declaration.

8.3.12Runtime Semantics: PropertyDefinitionEvaluation

With parameter object and enumerable.

async

[no LineTerminator here]

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. Otherwise let strict be false.
Let scope be the running execution context's LexicalEnvironment.
Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, AsyncGeneratorBody, scope, strict).
Perform ! MakeMethod(closure, object).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform ! SetFunctionName(closure, propKey).
Let desc be PropertyDescriptor{[[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

8.3.13Runtime Semantics: Evaluation

async

[no LineTerminator here]

function

(

)

{

}

If the function code for this AsyncGeneratorExpression is strict mode code, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the running execution context.
Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Return closure.

async

[no LineTerminator here]

function

(

)

{