UniqueFormalParameters : FormalParameters

• It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements.

FormalParameters : FormalParameterList

• It is a Syntax Error if IsSimpleParameterList of FormalParameterList is false and BoundNames of FormalParameterList contains any duplicate elements.

Note

Multiple occurrences of the same BindingIdentifier in a FormalParameterList is only allowed for functions which have simple parameter lists and which are not defined in strict mode code.

ObjectBindingPattern : { } { BindingRestProperty }

1. Return false.

ObjectBindingPattern : { BindingPropertyList , BindingRestProperty }

1. Return ContainsExpression of BindingPropertyList.

ArrayBindingPattern : [ Elisionopt ]

1. Return false.

ArrayBindingPattern : [ Elisionopt BindingRestElement ]

1. Return ContainsExpression of BindingRestElement.

ArrayBindingPattern : [ BindingElementList , Elisionopt ]

1. Return ContainsExpression of BindingElementList.

ArrayBindingPattern : [ BindingElementList , Elisionopt BindingRestElement ]

1. Let has be ContainsExpression of BindingElementList.
2. If has is true, return true.
3. Return ContainsExpression of BindingRestElement.

BindingPropertyList : BindingPropertyList , BindingProperty

1. Let has be ContainsExpression of BindingPropertyList.
2. If has is true, return true.
3. Return ContainsExpression of BindingProperty.

BindingElementList : BindingElementList , BindingElisionElement

1. Let has be ContainsExpression of BindingElementList.
2. If has is true, return true.
3. Return ContainsExpression of BindingElisionElement.

BindingElisionElement : Elisionopt BindingElement

1. Return ContainsExpression of BindingElement.

BindingProperty : PropertyName : BindingElement

1. Let has be IsComputedPropertyKey of PropertyName.
2. If has is true, return true.
3. Return ContainsExpression of BindingElement.

BindingElement : BindingPattern Initializer

1. Return true.

SingleNameBinding : BindingIdentifier

1. Return false.

SingleNameBinding : BindingIdentifier Initializer

1. Return true.

BindingRestElement : ... BindingIdentifier

1. Return false.

BindingRestElement : ... BindingPattern

1. Return ContainsExpression of BindingPattern.

FormalParameters : [empty]

1. Return false.

FormalParameters : FormalParameterList , FunctionRestParameter

1. If ContainsExpression of FormalParameterList is true, return true.
2. Return ContainsExpression of FunctionRestParameter.

FormalParameterList : FormalParameterList , FormalParameter

1. If ContainsExpression of FormalParameterList is true, return true.
2. Return ContainsExpression of FormalParameter.

ArrowParameters : BindingIdentifier

1. Return false.

ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList

1. Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
2. Return ContainsExpression of formals.

AsyncArrowBindingIdentifier : BindingIdentifier

1. Return false.

BindingElement : BindingPattern

1. Return false.

BindingElement : BindingPattern Initializer

1. Return false.

SingleNameBinding : BindingIdentifier

1. Return true.

SingleNameBinding : BindingIdentifier Initializer

1. Return false.

FormalParameters : [empty]

1. Return true.

FormalParameters : FunctionRestParameter

1. Return false.

FormalParameters : FormalParameterList , FunctionRestParameter

1. Return false.

FormalParameterList : FormalParameterList , FormalParameter

1. If IsSimpleParameterList of FormalParameterList is false, return false.
2. Return IsSimpleParameterList of FormalParameter.

FormalParameter : BindingElement

1. Return IsSimpleParameterList of BindingElement.

ArrowParameters : BindingIdentifier

1. Return true.

ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList

1. Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
2. Return IsSimpleParameterList of formals.

AsyncArrowBindingIdentifier[Yield] : BindingIdentifier[?Yield, +Await]

1. Return true.

CoverCallExpressionAndAsyncArrowHead : MemberExpression Arguments

1. Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
2. Return IsSimpleParameterList of head.

BindingElement : BindingPattern

1. Return false.

BindingElement : BindingPattern Initializer

1. Return true.

SingleNameBinding : BindingIdentifier

1. Return false.

SingleNameBinding : BindingIdentifier Initializer

1. Return true.

FormalParameterList : FormalParameterList , FormalParameter

1. If HasInitializer of FormalParameterList is true, return true.
2. Return HasInitializer of FormalParameter.

FormalParameters : [empty] FunctionRestParameter

1. Return 0.

FormalParameters : FormalParameterList , FunctionRestParameter

1. Return ExpectedArgumentCount of FormalParameterList.

Note

The ExpectedArgumentCount of a FormalParameterList is the number of FormalParameters to the left of either the rest parameter or the first FormalParameter with an Initializer. A FormalParameter without an initializer is allowed after the first parameter with an initializer but such parameters are considered to be optional with undefined as their default value.

FormalParameterList : FormalParameter

1. If HasInitializer of FormalParameter is true, return 0.
2. Return 1.

FormalParameterList : FormalParameterList , FormalParameter

1. Let count be ExpectedArgumentCount of FormalParameterList.
2. If HasInitializer of FormalParameterList is true or HasInitializer of FormalParameter is true, return count.
3. Return count + 1.

ArrowParameters : BindingIdentifier

1. Return 1.

ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList

1. Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
2. Return ExpectedArgumentCount of formals.

PropertySetParameterList : FormalParameter

1. If HasInitializer of FormalParameter is true, return 0.
2. Return 1.

AsyncArrowBindingIdentifier : BindingIdentifier

1. Return 1.

FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } function ( FormalParameters ) { FunctionBody } FunctionExpression : function BindingIdentifieropt ( FormalParameters ) { FunctionBody }

• If the source code matching FormalParameters is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code, it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
• It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody 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 FunctionBody.
• It is a Syntax Error if FormalParameters Contains SuperProperty is true.
• It is a Syntax Error if FunctionBody Contains SuperProperty is true.
• It is a Syntax Error if FormalParameters Contains SuperCall is true.
• It is a Syntax Error if FunctionBody Contains SuperCall is true.

Note

The LexicallyDeclaredNames of a FunctionBody does not include identifiers bound using var or function declarations.

FunctionBody : FunctionStatementList

• It is a Syntax Error if the LexicallyDeclaredNames of FunctionStatementList contains any duplicate entries.
• It is a Syntax Error if any element of the LexicallyDeclaredNames of FunctionStatementList also occurs in the VarDeclaredNames of FunctionStatementList.
• It is a Syntax Error if ContainsDuplicateLabels of FunctionStatementList with argument « » is true.
• It is a Syntax Error if ContainsUndefinedBreakTarget of FunctionStatementList with argument « » is true.
• It is a Syntax Error if ContainsUndefinedContinueTarget of FunctionStatementList with arguments « » and « » is true.

FunctionBody : FunctionStatementList

1. If the Directive Prologue of FunctionBody contains a Use Strict Directive, return true; otherwise, return false.

With parameters functionObject and argumentsList (a List).

FunctionBody : FunctionStatementList

1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
2. Return the result of evaluating FunctionStatementList.

With parameter scope.

FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody }

1. Let name be StringValue of BindingIdentifier.
2. Let sourceText be the source text matched by FunctionDeclaration.
3. Let F be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope).
4. Perform SetFunctionName(F, name).
5. Perform MakeConstructor(F).
6. Return F.

FunctionDeclaration : function ( FormalParameters ) { FunctionBody }

1. Let sourceText be the source text matched by FunctionDeclaration.
2. Let F be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope).
3. Perform SetFunctionName(F, "default").
4. Perform MakeConstructor(F).
5. Return F.

Note

An anonymous FunctionDeclaration can only occur as part of an export default declaration, and its function code is therefore always strict mode code.

With optional parameter name.

FunctionExpression : function ( FormalParameters ) { FunctionBody }

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by FunctionExpression.
4. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope).
5. Perform SetFunctionName(closure, name).
6. Perform MakeConstructor(closure).
7. Return closure.

FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody }

1. Assert: name is not present.
2. Set name to StringValue of BindingIdentifier.
3. Let scope be the running execution context's LexicalEnvironment.
4. Let funcEnv be NewDeclarativeEnvironment(scope).
5. Perform funcEnv.CreateImmutableBinding(name, false).
6. Let sourceText be the source text matched by FunctionExpression.
7. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, funcEnv).
8. Perform SetFunctionName(closure, name).
9. Perform MakeConstructor(closure).
10. Perform funcEnv.InitializeBinding(name, closure).
11. Return closure.

Note

The BindingIdentifier in a FunctionExpression can be referenced from inside the FunctionExpression's FunctionBody to allow the function to call itself recursively. However, unlike in a FunctionDeclaration, the BindingIdentifier in a FunctionExpression cannot be referenced from and does not affect the scope enclosing the FunctionExpression.

FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody }

1. Return NormalCompletion(empty).

Note 1

An alternative semantics is provided in B.3.3.

FunctionDeclaration : function ( FormalParameters ) { FunctionBody }

1. Return NormalCompletion(empty).

FunctionExpression : function BindingIdentifieropt ( FormalParameters ) { FunctionBody }

1. Return InstantiateOrdinaryFunctionExpression of FunctionExpression.

Note 2

A "prototype" property is automatically created for every function defined using a FunctionDeclaration or FunctionExpression, to allow for the possibility that the function will be used as a constructor.

FunctionStatementList : [empty]

1. Return NormalCompletion(undefined).

ArrowFunction : ArrowParameters => ConciseBody

• It is a Syntax Error if ArrowParameters Contains YieldExpression is true.
• It is a Syntax Error if ArrowParameters Contains AwaitExpression is true.
• It is a Syntax Error if ConciseBodyContainsUseStrict of ConciseBody is true and IsSimpleParameterList of ArrowParameters is false.
• It is a Syntax Error if any element of the BoundNames of ArrowParameters also occurs in the LexicallyDeclaredNames of ConciseBody.

ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList

• It is a Syntax Error if CoverParenthesizedExpressionAndArrowParameterList is not covering an ArrowFormalParameters.
• All early error rules for ArrowFormalParameters and its derived productions also apply to CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.

ConciseBody : ExpressionBody

1. Return false.

ConciseBody : { FunctionBody }

1. Return FunctionBodyContainsUseStrict of FunctionBody.

ArrowParameters : BindingIdentifier

1. Return this ArrowParameters.

CoverParenthesizedExpressionAndArrowParameterList : ( Expression ) ( Expression , ) ( ) ( ... BindingIdentifier ) ( ... BindingPattern ) ( Expression , ... BindingIdentifier ) ( Expression , ... BindingPattern )

1. Return the ArrowFormalParameters that is covered by CoverParenthesizedExpressionAndArrowParameterList.

With parameters functionObject and argumentsList (a List).

ConciseBody : ExpressionBody

1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
2. Return the result of evaluating ExpressionBody.

With optional parameter name.

ArrowFunction : ArrowParameters => ConciseBody

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by ArrowFunction.
4. Let parameters be CoveredFormalsList of ArrowParameters.
5. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, parameters, ConciseBody, lexical-this, scope).
6. Perform SetFunctionName(closure, name).
7. Return closure.

Note

An ArrowFunction does not define local bindings for arguments, super, this, or new.target. Any reference to arguments, super, this, or new.target within an ArrowFunction must resolve to a binding in a lexically enclosing environment. Typically this will be the Function Environment of an immediately enclosing function. Even though an ArrowFunction may contain references to super, the function object created in step 5 is not made into a method by performing MakeMethod. An ArrowFunction that references super is always contained within a non-ArrowFunction and the necessary state to implement super is accessible via the scope that is captured by the function object of the ArrowFunction.

ArrowFunction : ArrowParameters => ConciseBody

1. Return InstantiateArrowFunctionExpression of ArrowFunction.

ExpressionBody : AssignmentExpression

1. Let exprRef be the result of evaluating AssignmentExpression.
2. Let exprValue be ? GetValue(exprRef).
3. Return Completion { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }.

MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody }

• It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody 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 FunctionBody.

MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody }

• It is a Syntax Error if BoundNames of PropertySetParameterList contains any duplicate elements.
• It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true and IsSimpleParameterList of PropertySetParameterList is false.
• It is a Syntax Error if any element of the BoundNames of PropertySetParameterList also occurs in the LexicallyDeclaredNames of FunctionBody.

MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody }

1. If UniqueFormalParameters Contains SuperCall is true, return true.
2. Return FunctionBody Contains SuperCall.

MethodDefinition : get PropertyName ( ) { FunctionBody }

1. Return FunctionBody Contains SuperCall.

MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody }

1. If PropertySetParameterList Contains SuperCall is true, return true.
2. Return FunctionBody Contains SuperCall.

GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody }

1. If UniqueFormalParameters Contains SuperCall is true, return true.
2. Return GeneratorBody Contains SuperCall.

AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }

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

AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }

1. If UniqueFormalParameters Contains SuperCall is true, return true.
2. Return AsyncFunctionBody Contains SuperCall.

MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody }

1. Return false.

MethodDefinition : GeneratorMethod AsyncMethod AsyncGeneratorMethod get PropertyName ( ) { FunctionBody } set PropertyName ( PropertySetParameterList ) { FunctionBody }

1. Return true.

With parameter object and optional parameter functionPrototype.

MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the running execution context's LexicalEnvironment.
4. If functionPrototype is present, then
   1. Let prototype be functionPrototype.
5. Else,
   1. Let prototype be %Function.prototype%.
6. Let sourceText be the source text matched by MethodDefinition.
7. Let closure be OrdinaryFunctionCreate(prototype, sourceText, UniqueFormalParameters, FunctionBody, non-lexical-this, scope).
8. Perform MakeMethod(closure, object).
9. Return the Record { [[Key]]: propKey, [[Closure]]: closure }.

With parameters object and enumerable.

MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody }

1. Let methodDef be ? DefineMethod of MethodDefinition with argument object.
2. Perform SetFunctionName(methodDef.[[Closure]], methodDef.[[Key]]).
3. Let desc be the PropertyDescriptor { [[Value]]: methodDef.[[Closure]], [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
4. Return ? DefinePropertyOrThrow(object, methodDef.[[Key]], desc).

MethodDefinition : get PropertyName ( ) { FunctionBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the running execution context's LexicalEnvironment.
4. Let sourceText be the source text matched by MethodDefinition.
5. Let formalParameterList be an instance of the production FormalParameters : [empty].
6. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameterList, FunctionBody, non-lexical-this, scope).
7. Perform MakeMethod(closure, object).
8. Perform SetFunctionName(closure, propKey, "get").
9. Let desc be the PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
10. Return ? DefinePropertyOrThrow(object, propKey, desc).

MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the running execution context's LexicalEnvironment.
4. Let sourceText be the source text matched by MethodDefinition.
5. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, PropertySetParameterList, FunctionBody, non-lexical-this, scope).
6. Perform MakeMethod(closure, object).
7. Perform SetFunctionName(closure, propKey, "set").
8. Let desc be the PropertyDescriptor { [[Set]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
9. Return ? DefinePropertyOrThrow(object, propKey, desc).

GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the running execution context's LexicalEnvironment.
4. Let sourceText be the source text matched by GeneratorMethod.
5. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, UniqueFormalParameters, GeneratorBody, non-lexical-this, scope).
6. Perform MakeMethod(closure, object).
7. Perform SetFunctionName(closure, propKey).
8. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
9. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
10. Let desc be the PropertyDescriptor { [[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
11. Return ? DefinePropertyOrThrow(object, propKey, desc).

AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the running execution context's LexicalEnvironment.
4. Let sourceText be the source text matched by AsyncGeneratorMethod.
5. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, UniqueFormalParameters, AsyncGeneratorBody, non-lexical-this, scope).
6. Perform ! MakeMethod(closure, object).
7. Perform ! SetFunctionName(closure, propKey).
8. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
9. Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
10. Let desc be PropertyDescriptor { [[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
11. Return ? DefinePropertyOrThrow(object, propKey, desc).

AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let scope be the LexicalEnvironment of the running execution context.
4. Let sourceText be the source text matched by AsyncMethod.
5. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, UniqueFormalParameters, AsyncFunctionBody, non-lexical-this, scope).
6. Perform ! MakeMethod(closure, object).
7. Perform ! SetFunctionName(closure, propKey).
8. Let desc be the PropertyDescriptor { [[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
9. Return ? DefinePropertyOrThrow(object, propKey, desc).

GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody }

• It is a Syntax Error if HasDirectSuper of GeneratorMethod is true.
• It is a Syntax Error if UniqueFormalParameters Contains YieldExpression is true.
• It is a Syntax Error if FunctionBodyContainsUseStrict of GeneratorBody 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 GeneratorBody.

GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } function * ( FormalParameters ) { GeneratorBody } GeneratorExpression : function * BindingIdentifieropt ( FormalParameters ) { GeneratorBody }

• If the source code matching FormalParameters is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code, it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
• It is a Syntax Error if FunctionBodyContainsUseStrict of GeneratorBody 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 GeneratorBody.
• It is a Syntax Error if FormalParameters Contains YieldExpression is true.
• It is a Syntax Error if FormalParameters Contains SuperProperty is true.
• It is a Syntax Error if GeneratorBody Contains SuperProperty is true.
• It is a Syntax Error if FormalParameters Contains SuperCall is true.
• It is a Syntax Error if GeneratorBody Contains SuperCall is true.

With parameters functionObject and argumentsList (a List).

GeneratorBody : FunctionBody

1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
2. Let G be ? OrdinaryCreateFromConstructor(functionObject, "%GeneratorFunction.prototype.prototype%", « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] »).
3. Set G.[[GeneratorBrand]] to empty.
4. Perform GeneratorStart(G, FunctionBody).
5. Return Completion { [[Type]]: return, [[Value]]: G, [[Target]]: empty }.

With parameter scope.

GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody }

1. Let name be StringValue of BindingIdentifier.
2. Let sourceText be the source text matched by GeneratorDeclaration.
3. Let F be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope).
4. Perform SetFunctionName(F, name).
5. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
6. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
7. Return F.

GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }

1. Let sourceText be the source text matched by GeneratorDeclaration.
2. Let F be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope).
3. Perform SetFunctionName(F, "default").
4. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
5. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
6. Return F.

Note

An anonymous GeneratorDeclaration can only occur as part of an export default declaration, and its function code is therefore always strict mode code.

With optional parameter name.

GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by GeneratorExpression.
4. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope).
5. Perform SetFunctionName(closure, name).
6. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
7. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
8. Return closure.

GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody }

1. Assert: name is not present.
2. Set name to StringValue of BindingIdentifier.
3. Let scope be the running execution context's LexicalEnvironment.
4. Let funcEnv be NewDeclarativeEnvironment(scope).
5. Perform funcEnv.CreateImmutableBinding(name, false).
6. Let sourceText be the source text matched by GeneratorExpression.
7. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, funcEnv).
8. Perform SetFunctionName(closure, name).
9. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
10. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
11. Perform funcEnv.InitializeBinding(name, closure).
12. Return closure.

Note

The BindingIdentifier in a GeneratorExpression can be referenced from inside the GeneratorExpression's FunctionBody to allow the generator code to call itself recursively. However, unlike in a GeneratorDeclaration, the BindingIdentifier in a GeneratorExpression cannot be referenced from and does not affect the scope enclosing the GeneratorExpression.

GeneratorExpression : function * BindingIdentifieropt ( FormalParameters ) { GeneratorBody }

1. Return InstantiateGeneratorFunctionExpression of GeneratorExpression.

YieldExpression : yield

1. Return ? Yield(undefined).

YieldExpression : yield AssignmentExpression

1. Let exprRef be the result of evaluating AssignmentExpression.
2. Let value be ? GetValue(exprRef).
3. Return ? Yield(value).

YieldExpression : yield * AssignmentExpression

1. Let generatorKind be ! GetGeneratorKind().
2. Let exprRef be the result of evaluating AssignmentExpression.
3. Let value be ? GetValue(exprRef).
4. Let iteratorRecord be ? GetIterator(value, generatorKind).
5. Let iterator be iteratorRecord.[[Iterator]].
6. Let received be NormalCompletion(undefined).
7. Repeat,
   1. If received.[[Type]] is normal, then
      1. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
      2. If generatorKind is async, set innerResult to ? Await(innerResult).
      3. If Type(innerResult) is not Object, throw a TypeError exception.
      4. Let done be ? IteratorComplete(innerResult).
      5. If done is true, then
         1. Return ? IteratorValue(innerResult).
      6. If generatorKind is async, set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
      7. Else, set received to 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, 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, set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
         8. Else, set received to 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, perform ? IteratorClose(iteratorRecord, 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, then
         1. If generatorKind is async, 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, 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, set received to AsyncGeneratorYield(? IteratorValue(innerReturnResult)).
      10. Else, set received to GeneratorYield(innerReturnResult).

AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }

• 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 FunctionBodyContainsUseStrict 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.

AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } async function * ( FormalParameters ) { AsyncGeneratorBody } AsyncGeneratorExpression : async function * BindingIdentifieropt ( FormalParameters ) { AsyncGeneratorBody }

• If the source code matching FormalParameters is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code, it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
• It is a Syntax Error if FunctionBodyContainsUseStrict 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.

With parameters functionObject and argumentsList (a List).

AsyncGeneratorBody : FunctionBody

1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
2. Let generator be ? OrdinaryCreateFromConstructor(functionObject, "%AsyncGeneratorFunction.prototype.prototype%", « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] »).
3. Set generator.[[GeneratorBrand]] to empty.
4. Perform ! AsyncGeneratorStart(generator, FunctionBody).
5. Return Completion { [[Type]]: return, [[Value]]: generator, [[Target]]: empty }.

With parameter scope.

AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody }

1. Let name be StringValue of BindingIdentifier.
2. Let sourceText be the source text matched by AsyncGeneratorDeclaration.
3. Let F be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope).
4. Perform ! SetFunctionName(F, name).
5. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
6. Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
7. Return F.

AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody }

1. Let sourceText be the source text matched by AsyncGeneratorDeclaration.
2. Let F be OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope).
3. Perform SetFunctionName(F, "default").
4. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
5. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
6. Return F.

Note

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

With optional parameter name.

AsyncGeneratorExpression : async function * ( FormalParameters ) { AsyncGeneratorBody }

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by AsyncGeneratorExpression.
4. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope).
5. Perform SetFunctionName(closure, name).
6. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
7. Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
8. Return closure.

AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody }

1. Assert: name is not present.
2. Set name to StringValue of BindingIdentifier.
3. Let scope be the running execution context's LexicalEnvironment.
4. Let funcEnv be ! NewDeclarativeEnvironment(scope).
5. Perform ! funcEnv.CreateImmutableBinding(name, false).
6. Let sourceText be the source text matched by AsyncGeneratorExpression.
7. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, funcEnv).
8. Perform ! SetFunctionName(closure, name).
9. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
10. Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
11. Perform ! funcEnv.InitializeBinding(name, closure).
12. Return closure.

Note

The BindingIdentifier in an AsyncGeneratorExpression can be referenced from inside the AsyncGeneratorExpression's AsyncGeneratorBody to allow the generator code to call itself recursively. However, unlike in an AsyncGeneratorDeclaration, the BindingIdentifier in an AsyncGeneratorExpression cannot be referenced from and does not affect the scope enclosing the AsyncGeneratorExpression.

AsyncGeneratorExpression : async function * BindingIdentifieropt ( FormalParameters ) { AsyncGeneratorBody }

1. Return InstantiateAsyncGeneratorFunctionExpression of AsyncGeneratorExpression.

ClassTail : ClassHeritageopt { ClassBody }

• It is a Syntax Error if ClassHeritage is not present and the following algorithm evaluates to true:

  1. Let constructor be ConstructorMethod of ClassBody.
  2. If constructor is empty, return false.
  3. Return HasDirectSuper of constructor.

ClassBody : ClassElementList

• It is a Syntax Error if PrototypePropertyNameList of ClassElementList contains more than one occurrence of "constructor".

ClassElement : MethodDefinition

• It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true.
• It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true.

ClassElement : static MethodDefinition

• It is a Syntax Error if HasDirectSuper of MethodDefinition is true.
• It is a Syntax Error if PropName of MethodDefinition is "prototype".

ClassElement : MethodDefinition

1. If PropName of MethodDefinition is "constructor", return ConstructorMethod.
2. Return NonConstructorMethod.

ClassElement : static MethodDefinition

1. Return NonConstructorMethod.

ClassElement : ;

1. Return empty.

ClassElementList : ClassElement

1. If ClassElementKind of ClassElement is ConstructorMethod, return ClassElement.
2. Return empty.

ClassElementList : ClassElementList ClassElement

1. Let head be ConstructorMethod of ClassElementList.
2. If head is not empty, return head.
3. If ClassElementKind of ClassElement is ConstructorMethod, return ClassElement.
4. Return empty.

Note

Early Error rules ensure that there is only one method definition named "constructor" and that it is not an accessor property or generator definition.

ClassElement : MethodDefinition

1. Return false.

ClassElement : static MethodDefinition

1. Return true.

ClassElement : ;

1. Return false.

ClassElementList : ClassElement

1. If ClassElementKind of ClassElement is NonConstructorMethod, then
   1. Return a List whose sole element is ClassElement.
2. Return a new empty List.

ClassElementList : ClassElementList ClassElement

1. Let list be NonConstructorMethodDefinitions of ClassElementList.
2. If ClassElementKind of ClassElement is NonConstructorMethod, then
   1. Append ClassElement to the end of list.
3. Return list.

ClassElementList : ClassElement

1. If PropName of ClassElement is empty, return a new empty List.
2. If IsStatic of ClassElement is true, return a new empty List.
3. Return a List whose sole element is PropName of ClassElement.

ClassElementList : ClassElementList ClassElement

1. Let list be PrototypePropertyNameList of ClassElementList.
2. If PropName of ClassElement is empty, return list.
3. If IsStatic of ClassElement is true, return list.
4. Append PropName of ClassElement to the end of list.
5. Return list.

With parameters classBinding and className.

ClassTail : ClassHeritageopt { ClassBodyopt }

1. Let env be the LexicalEnvironment of the running execution context.
2. Let classScope be NewDeclarativeEnvironment(env).
3. If classBinding is not undefined, then
   1. Perform classScope.CreateImmutableBinding(classBinding, true).
4. If ClassHeritage_opt is not present, then
   1. Let protoParent be %Object.prototype%.
   2. Let constructorParent be %Function.prototype%.
5. Else,
   1. Set the running execution context's LexicalEnvironment to classScope.
   2. Let superclassRef be the result of evaluating ClassHeritage.
   3. Set the running execution context's LexicalEnvironment to env.
   4. Let superclass be ? GetValue(superclassRef).
   5. If superclass is null, then
      1. Let protoParent be null.
      2. Let constructorParent be %Function.prototype%.
   6. Else if IsConstructor(superclass) is false, throw a TypeError exception.
   7. Else,
      1. Let protoParent be ? Get(superclass, "prototype").
      2. If Type(protoParent) is neither Object nor Null, throw a TypeError exception.
      3. Let constructorParent be superclass.
6. Let proto be ! OrdinaryObjectCreate(protoParent).
7. If ClassBody_opt is not present, let constructor be empty.
8. Else, let constructor be ConstructorMethod of ClassBody.
9. Set the running execution context's LexicalEnvironment to classScope.
10. If constructor is empty, then
    1. Let steps be the algorithm steps defined in Default Constructor Functions.
    2. Let F be ! CreateBuiltinFunction(steps, 0, className, « [[ConstructorKind]], [[SourceText]] », empty, constructorParent).
11. Else,
    1. Let constructorInfo be ! DefineMethod of constructor with arguments proto and constructorParent.
    2. Let F be constructorInfo.[[Closure]].
    3. Perform ! MakeClassConstructor(F).
    4. Perform ! SetFunctionName(F, className).
12. Perform ! MakeConstructor(F, false, proto).
13. If ClassHeritage_opt is present, set F.[[ConstructorKind]] to derived.
14. Perform ! CreateMethodProperty(proto, "constructor", F).
15. If ClassBody_opt is not present, let methods be a new empty List.
16. Else, let methods be NonConstructorMethodDefinitions of ClassBody.
17. For each ClassElement m of methods, do
    1. If IsStatic of m is false, then
       1. Let status be PropertyDefinitionEvaluation of m with arguments proto and false.
    2. Else,
       1. Let status be PropertyDefinitionEvaluation of m with arguments F and false.
    3. If status is an abrupt completion, then
       1. Set the running execution context's LexicalEnvironment to env.
       2. Return Completion(status).
18. Set the running execution context's LexicalEnvironment to env.
19. If classBinding is not undefined, then
    1. Perform classScope.InitializeBinding(classBinding, F).
20. Return F.

ClassDeclaration : class BindingIdentifier ClassTail

1. Let className be StringValue of BindingIdentifier.
2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
3. Set value.[[SourceText]] to the source text matched by ClassDeclaration.
4. Let env be the running execution context's LexicalEnvironment.
5. Perform ? InitializeBoundName(className, value, env).
6. Return value.

ClassDeclaration : class ClassTail

1. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments undefined and "default".
2. Set value.[[SourceText]] to the source text matched by ClassDeclaration.
3. Return value.

Note

ClassDeclaration : class ClassTail only occurs as part of an ExportDeclaration and establishing its binding is handled as part of the evaluation action for that production. See 16.2.3.7.

ClassDeclaration : class BindingIdentifier ClassTail

1. Perform ? BindingClassDeclarationEvaluation of this ClassDeclaration.
2. Return NormalCompletion(empty).

Note

ClassDeclaration : class ClassTail only occurs as part of an ExportDeclaration and is never directly evaluated.

ClassExpression : class ClassTail

1. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments undefined and "".
2. Set value.[[SourceText]] to the source text matched by ClassExpression.
3. Return value.

ClassExpression : class BindingIdentifier ClassTail

1. Let className be StringValue of BindingIdentifier.
2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
3. Set value.[[SourceText]] to the source text matched by ClassExpression.
4. Return value.

AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }

• It is a Syntax Error if FunctionBodyContainsUseStrict of AsyncFunctionBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
• It is a Syntax Error if HasDirectSuper of AsyncMethod is true.
• It is a Syntax Error if UniqueFormalParameters Contains AwaitExpression is true.
• It is a Syntax Error if any element of the BoundNames of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody.

AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } async function ( FormalParameters ) { AsyncFunctionBody } AsyncFunctionExpression : async function BindingIdentifieropt ( FormalParameters ) { AsyncFunctionBody }

• It is a Syntax Error if FunctionBodyContainsUseStrict of AsyncFunctionBody is true and IsSimpleParameterList of FormalParameters is false.
• It is a Syntax Error if FormalParameters Contains AwaitExpression is true.
• If the source code matching FormalParameters is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code, it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
• It is a Syntax Error if any element of the BoundNames of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody.
• It is a Syntax Error if FormalParameters Contains SuperProperty is true.
• It is a Syntax Error if AsyncFunctionBody Contains SuperProperty is true.
• It is a Syntax Error if FormalParameters Contains SuperCall is true.
• It is a Syntax Error if AsyncFunctionBody Contains SuperCall is true.

With parameter scope.

AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }

1. Let name be StringValue of BindingIdentifier.
2. Let sourceText be the source text matched by AsyncFunctionDeclaration.
3. Let F be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncFunctionBody, non-lexical-this, scope).
4. Perform ! SetFunctionName(F, name).
5. Return F.

AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody }

1. Let sourceText be the source text matched by AsyncFunctionDeclaration.
2. Let F be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncFunctionBody, non-lexical-this, scope).
3. Perform ! SetFunctionName(F, "default").
4. Return F.

With optional parameter name.

AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody }

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by AsyncFunctionExpression.
4. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncFunctionBody, non-lexical-this, scope).
5. Perform SetFunctionName(closure, name).
6. Return closure.

AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }

1. Assert: name is not present.
2. Set name to StringValue of BindingIdentifier.
3. Let scope be the LexicalEnvironment of the running execution context.
4. Let funcEnv be ! NewDeclarativeEnvironment(scope).
5. Perform ! funcEnv.CreateImmutableBinding(name, false).
6. Let sourceText be the source text matched by AsyncFunctionExpression.
7. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncFunctionBody, non-lexical-this, funcEnv).
8. Perform ! SetFunctionName(closure, name).
9. Perform ! funcEnv.InitializeBinding(name, closure).
10. Return closure.

Note

The BindingIdentifier in an AsyncFunctionExpression can be referenced from inside the AsyncFunctionExpression's AsyncFunctionBody to allow the function to call itself recursively. However, unlike in a FunctionDeclaration, the BindingIdentifier in a AsyncFunctionExpression cannot be referenced from and does not affect the scope enclosing the AsyncFunctionExpression.

With parameters functionObject and argumentsList (a List).

AsyncFunctionBody : FunctionBody

1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
2. Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
3. If declResult is not an abrupt completion, then
   1. Perform ! AsyncFunctionStart(promiseCapability, FunctionBody).
4. Else,
   1. Perform ! Call(promiseCapability.[[Reject]], undefined, « declResult.[[Value]] »).
5. Return Completion { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }.

AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }

1. Return NormalCompletion(empty).

AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody }

1. Return NormalCompletion(empty).

AsyncFunctionExpression : async function BindingIdentifieropt ( FormalParameters ) { AsyncFunctionBody }

1. Return InstantiateAsyncFunctionExpression of AsyncFunctionExpression.

AwaitExpression : await UnaryExpression

1. Let exprRef be the result of evaluating UnaryExpression.
2. Let value be ? GetValue(exprRef).
3. Return ? Await(value).

AsyncArrowFunction : async AsyncArrowBindingIdentifier => AsyncConciseBody

• It is a Syntax Error if any element of the BoundNames of AsyncArrowBindingIdentifier also occurs in the LexicallyDeclaredNames of AsyncConciseBody.

AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody

• It is a Syntax Error if CoverCallExpressionAndAsyncArrowHead Contains YieldExpression is true.
• It is a Syntax Error if CoverCallExpressionAndAsyncArrowHead Contains AwaitExpression is true.
• It is a Syntax Error if CoverCallExpressionAndAsyncArrowHead is not covering an AsyncArrowHead.
• It is a Syntax Error if any element of the BoundNames of CoverCallExpressionAndAsyncArrowHead also occurs in the LexicallyDeclaredNames of AsyncConciseBody.
• It is a Syntax Error if AsyncConciseBodyContainsUseStrict of AsyncConciseBody is true and IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false.
• All Early Error rules for AsyncArrowHead and its derived productions apply to CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.

CoverCallExpressionAndAsyncArrowHead : MemberExpression Arguments

1. Return the AsyncArrowHead that is covered by CoverCallExpressionAndAsyncArrowHead.

AsyncConciseBody : ExpressionBody

1. Return false.

AsyncConciseBody : { AsyncFunctionBody }

1. Return FunctionBodyContainsUseStrict of AsyncFunctionBody.

With parameters functionObject and argumentsList (a List).

AsyncConciseBody : ExpressionBody

1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
2. Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
3. If declResult is not an abrupt completion, then
   1. Perform ! AsyncFunctionStart(promiseCapability, ExpressionBody).
4. Else,
   1. Perform ! Call(promiseCapability.[[Reject]], undefined, « declResult.[[Value]] »).
5. Return Completion { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }.

With optional parameter name.

AsyncArrowFunction : async AsyncArrowBindingIdentifier => AsyncConciseBody

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by AsyncArrowFunction.
4. Let parameters be AsyncArrowBindingIdentifier.
5. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, parameters, AsyncConciseBody, lexical-this, scope).
6. Perform SetFunctionName(closure, name).
7. Return closure.

AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody

1. If name is not present, set name to "".
2. Let scope be the LexicalEnvironment of the running execution context.
3. Let sourceText be the source text matched by AsyncArrowFunction.
4. Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
5. Let parameters be the ArrowFormalParameters of head.
6. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, parameters, AsyncConciseBody, lexical-this, scope).
7. Perform SetFunctionName(closure, name).
8. Return closure.

AsyncArrowFunction : async AsyncArrowBindingIdentifier => AsyncConciseBody CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody

1. Return InstantiateAsyncArrowFunctionExpression of AsyncArrowFunction.

The abstract operation IsInTailPosition takes argument call. It performs the following steps when called:

1. Assert: call is a Parse Node.
2. If the source code matching call is non-strict code, return false.
3. If call is not contained within a FunctionBody, ConciseBody, or AsyncConciseBody, return false.
4. Let body be the FunctionBody, ConciseBody, or AsyncConciseBody that most closely contains call.
5. If body is the FunctionBody of a GeneratorBody, return false.
6. If body is the FunctionBody of an AsyncFunctionBody, return false.
7. If body is the FunctionBody of an AsyncGeneratorBody, return false.
8. If body is an AsyncConciseBody, return false.
9. Return the result of HasCallInTailPosition of body with argument call.

Note

Tail Position calls are only defined in strict mode code because of a common non-standard language extension (see 10.2.4) that enables observation of the chain of caller contexts.

With parameter call.

Note

call is a Parse Node that represents a specific range of source text. When the following algorithms compare call to another Parse Node, it is a test of whether they represent the same source text.