1. Assert: Type(name) is String.
2. If environment is not undefined, then
   1. Let env be the EnvironmentRecord component of environment.
   2. Perform env.InitializeBinding(name, value).
   3. Return NormalCompletion(undefined).
3. Else,
   1. Let lhs be ResolveBinding(name).
   2. Return ? PutValue(lhs, value).

CoverParenthesizedExpressionAndArrowParameterList[Yield] : ( Expression[In, ?Yield] )

1. Return the result of parsing the lexical token stream matched by CoverParenthesizedExpressionAndArrowParameterList[Yield] using either ParenthesizedExpression or ParenthesizedExpression[Yield] as the goal symbol depending upon whether the _[Yield] grammar parameter was present when CoverParenthesizedExpressionAndArrowParameterList was matched.

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

1. Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
2. If IsFunctionDefinition of expr is false, return false.
3. Return HasName of expr.

PrimaryExpression : this IdentifierReference Literal ArrayLiteral ObjectLiteral RegularExpressionLiteral TemplateLiteral

1. Return false.

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

1. Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
2. Return IsFunctionDefinition of expr.

PrimaryExpression : IdentifierReference

1. Return true.

PrimaryExpression : this Literal ArrayLiteral ObjectLiteral FunctionExpression ClassExpression GeneratorExpression RegularExpressionLiteral TemplateLiteral CoverParenthesizedExpressionAndArrowParameterList

1. Return false.

PrimaryExpression : this Literal ArrayLiteral ObjectLiteral FunctionExpression ClassExpression GeneratorExpression RegularExpressionLiteral TemplateLiteral

1. Return false.

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

1. Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
2. Return IsValidSimpleAssignmentTarget of expr.

PrimaryExpression : this

1. Return ? ResolveThisBinding( ).

Literal : NullLiteral

1. Return null.

Literal : BooleanLiteral

1. Return false if BooleanLiteral is the token false.
2. Return true if BooleanLiteral is the token true.

Literal : NumericLiteral

1. Return the number whose value is MV of NumericLiteral as defined in 11.8.3.

Literal : StringLiteral

1. Return the StringValue of StringLiteral as defined in 11.8.4.2.

Elision : ,

1. Return the numeric value 1.

Elision : Elision ,

1. Let preceding be the ElisionWidth of Elision.
2. Return preceding+1.

With parameters array and nextIndex.

ElementList : Elisionopt AssignmentExpression

1. Let padding be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
2. Let initResult be the result of evaluating AssignmentExpression.
3. Let initValue be ? GetValue(initResult).
4. Let created be CreateDataProperty(array, ToString(ToUint32(nextIndex+padding)), initValue).
5. Assert: created is true.
6. Return nextIndex+padding+1.

ElementList : Elisionopt SpreadElement

1. Let padding be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
2. Return the result of performing ArrayAccumulation for SpreadElement with arguments array and nextIndex+padding.

ElementList : ElementList , Elisionopt AssignmentExpression

1. Let postIndex be the result of performing ArrayAccumulation for ElementList with arguments array and nextIndex.
2. ReturnIfAbrupt(postIndex).
3. Let padding be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
4. Let initResult be the result of evaluating AssignmentExpression.
5. Let initValue be ? GetValue(initResult).
6. Let created be CreateDataProperty(array, ToString(ToUint32(postIndex+padding)), initValue).
7. Assert: created is true.
8. Return postIndex+padding+1.

ElementList : ElementList , Elisionopt SpreadElement

1. Let postIndex be the result of performing ArrayAccumulation for ElementList with arguments array and nextIndex.
2. ReturnIfAbrupt(postIndex).
3. Let padding be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
4. Return the result of performing ArrayAccumulation for SpreadElement with arguments array and postIndex+padding.

SpreadElement : ... AssignmentExpression

1. Let spreadRef be the result of evaluating AssignmentExpression.
2. Let spreadObj be ? GetValue(spreadRef).
3. Let iterator be ? GetIterator(spreadObj).
4. Repeat
   1. Let next be ? IteratorStep(iterator).
   2. If next is false, return nextIndex.
   3. Let nextValue be ? IteratorValue(next).
   4. Let status be CreateDataProperty(array, ToString(ToUint32(nextIndex)), nextValue).
   5. Assert: status is true.
   6. Let nextIndex be nextIndex + 1.

Note

CreateDataProperty is used to ensure that own properties are defined for the array even if the standard built-in Array prototype object has been modified in a manner that would preclude the creation of new own properties using [[Set]].

ArrayLiteral : [ Elisionopt ]

1. Let array be ArrayCreate(0).
2. Let pad be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
3. Perform Set(array, "length", ToUint32(pad), false).
4. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
5. Return array.

ArrayLiteral : [ ElementList ]

1. Let array be ArrayCreate(0).
2. Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
3. ReturnIfAbrupt(len).
4. Perform Set(array, "length", ToUint32(len), false).
5. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
6. Return array.

ArrayLiteral : [ ElementList , Elisionopt ]

1. Let array be ArrayCreate(0).
2. Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
3. ReturnIfAbrupt(len).
4. Let padding be the ElisionWidth of Elision; if Elision is not present, use the numeric value zero.
5. Perform Set(array, "length", ToUint32(padding+len), false).
6. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
7. Return array.

PropertyDefinition : MethodDefinition

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

In addition to describing an actual object initializer the ObjectLiteral productions are also used as a cover grammar for ObjectAssignmentPattern. and may be recognized as part of a CoverParenthesizedExpressionAndArrowParameterList. When ObjectLiteral appears in a context where ObjectAssignmentPattern is required the following Early Error rules are not applied. In addition, they are not applied when initially parsing a CoverParenthesizedExpressionAndArrowParameterList.

PropertyDefinition : CoverInitializedName

• Always throw a Syntax Error if code matches this production.

Note

This production exists so that ObjectLiteral can serve as a cover grammar for ObjectAssignmentPattern. It cannot occur in an actual object initializer.

With parameter symbol.

PropertyName : LiteralPropertyName

1. Return false.

PropertyName : ComputedPropertyName

1. Return the result of ComputedPropertyName Contains symbol.

With parameter symbol.

PropertyDefinition : MethodDefinition

1. If symbol is MethodDefinition, return true.
2. Return the result of ComputedPropertyContains for MethodDefinition with argument symbol.

Note

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

LiteralPropertyName : IdentifierName

1. If symbol is a ReservedWord, return false.
2. If symbol is an Identifier and StringValue of symbol is the same value as the StringValue of IdentifierName, return true.
3. Return false.

PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition

1. If HasComputedPropertyKey of PropertyDefinitionList is true, return true.
2. Return HasComputedPropertyKey of PropertyDefinition.

PropertyDefinition : IdentifierReference

1. Return false.

PropertyDefinition : PropertyName : AssignmentExpression

1. Return IsComputedPropertyKey of PropertyName.

PropertyName : LiteralPropertyName

1. Return false.

PropertyName : ComputedPropertyName

1. Return true.

PropertyDefinition : IdentifierReference

1. Return StringValue of IdentifierReference.

PropertyDefinition : PropertyName : AssignmentExpression

1. Return PropName of PropertyName.

LiteralPropertyName : IdentifierName

1. Return StringValue of IdentifierName.

LiteralPropertyName : StringLiteral

1. Return a String value whose code units are the SV of the StringLiteral.

LiteralPropertyName : NumericLiteral

1. Let nbr be the result of forming the value of the NumericLiteral.
2. Return ! ToString(nbr).

ComputedPropertyName : [ AssignmentExpression ]

1. Return empty.

PropertyDefinitionList : PropertyDefinition

1. If PropName of PropertyDefinition is empty, return a new empty List.
2. Return a new List containing PropName of PropertyDefinition.

PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition

1. Let list be PropertyNameList of PropertyDefinitionList.
2. If PropName of PropertyDefinition is empty, return list.
3. Append PropName of PropertyDefinition to the end of list.
4. Return list.

ObjectLiteral : { }

1. Return ObjectCreate(%ObjectPrototype%).

ObjectLiteral : { PropertyDefinitionList } { PropertyDefinitionList , }

1. Let obj be ObjectCreate(%ObjectPrototype%).
2. Let status be the result of performing PropertyDefinitionEvaluation of PropertyDefinitionList with arguments obj and true.
3. ReturnIfAbrupt(status).
4. Return obj.

LiteralPropertyName : IdentifierName

1. Return StringValue of IdentifierName.

LiteralPropertyName : StringLiteral

1. Return a String value whose code units are the SV of the StringLiteral.

LiteralPropertyName : NumericLiteral

1. Let nbr be the result of forming the value of the NumericLiteral.
2. Return ! ToString(nbr).

ComputedPropertyName : [ AssignmentExpression ]

1. Let exprValue be the result of evaluating AssignmentExpression.
2. Let propName be ? GetValue(exprValue).
3. Return ? ToPropertyKey(propName).

With parameters object and enumerable.

PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition

1. Let status be the result of performing PropertyDefinitionEvaluation of PropertyDefinitionList with arguments object and enumerable.
2. ReturnIfAbrupt(status).
3. Return the result of performing PropertyDefinitionEvaluation of PropertyDefinition with arguments object and enumerable.

PropertyDefinition : IdentifierReference

1. Let propName be StringValue of IdentifierReference.
2. Let exprValue be the result of evaluating IdentifierReference.
3. Let propValue be ? GetValue(exprValue).
4. Assert: enumerable is true.
5. Return CreateDataPropertyOrThrow(object, propName, propValue).

PropertyDefinition : PropertyName : AssignmentExpression

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let exprValueRef be the result of evaluating AssignmentExpression.
4. Let propValue be ? GetValue(exprValueRef).
5. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
   1. Let hasNameProperty be ? HasOwnProperty(propValue, "name").
   2. If hasNameProperty is false, perform SetFunctionName(propValue, propKey).
6. Assert: enumerable is true.
7. Return CreateDataPropertyOrThrow(object, propKey, propValue).

Note

An alternative semantics for this production is given in B.3.1.

PrimaryExpression : RegularExpressionLiteral

• It is a Syntax Error if BodyText of RegularExpressionLiteral cannot be recognized using the goal symbol Pattern of the ECMAScript RegExp grammar specified in 21.2.1.
• It is a Syntax Error if FlagText of RegularExpressionLiteral contains any code points other than "g", "i", "m", "u", or "y", or if it contains the same code point more than once.

PrimaryExpression : RegularExpressionLiteral

1. Let pattern be the String value consisting of the UTF16Encoding of each code point of BodyText of RegularExpressionLiteral.
2. Let flags be the String value consisting of the UTF16Encoding of each code point of FlagText of RegularExpressionLiteral.
3. Return RegExpCreate(pattern, flags).

With parameter raw.

TemplateLiteral : NoSubstitutionTemplate

1. If raw is false, then
   1. Let string be the TV of NoSubstitutionTemplate.
2. Else,
   1. Let string be the TRV of NoSubstitutionTemplate.
3. Return a List containing the single element, string.

TemplateLiteral : TemplateHead Expression TemplateSpans

1. If raw is false, then
   1. Let head be the TV of TemplateHead.
2. Else,
   1. Let head be the TRV of TemplateHead.
3. Let tail be TemplateStrings of TemplateSpans with argument raw.
4. Return a List containing head followed by the elements, in order, of tail.

TemplateSpans : TemplateTail

1. If raw is false, then
   1. Let tail be the TV of TemplateTail.
2. Else,
   1. Let tail be the TRV of TemplateTail.
3. Return a List containing the single element, tail.

TemplateSpans : TemplateMiddleList TemplateTail

1. Let middle be TemplateStrings of TemplateMiddleList with argument raw.
2. If raw is false, then
   1. Let tail be the TV of TemplateTail.
3. Else,
   1. Let tail be the TRV of TemplateTail.
4. Return a List containing the elements, in order, of middle followed by tail.

TemplateMiddleList : TemplateMiddle Expression

1. If raw is false, then
   1. Let string be the TV of TemplateMiddle.
2. Else,
   1. Let string be the TRV of TemplateMiddle.
3. Return a List containing the single element, string.

TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression

1. Let front be TemplateStrings of TemplateMiddleList with argument raw.
2. If raw is false, then
   1. Let last be the TV of TemplateMiddle.
3. Else,
   1. Let last be the TRV of TemplateMiddle.
4. Append last as the last element of the List front.
5. Return front.

TemplateLiteral : NoSubstitutionTemplate

1. Let templateLiteral be this TemplateLiteral.
2. Let siteObj be GetTemplateObject(templateLiteral).
3. Return a List containing the one element which is siteObj.

TemplateLiteral : TemplateHead Expression TemplateSpans

1. Let templateLiteral be this TemplateLiteral.
2. Let siteObj be GetTemplateObject(templateLiteral).
3. Let firstSub be the result of evaluating Expression.
4. ReturnIfAbrupt(firstSub).
5. Let restSub be SubstitutionEvaluation of TemplateSpans.
6. ReturnIfAbrupt(restSub).
7. Assert: restSub is a List.
8. Return a List whose first element is siteObj, whose second elements is firstSub, and whose subsequent elements are the elements of restSub, in order. restSub may contain no elements.

The abstract operation GetTemplateObject is called with a grammar production, templateLiteral, as an argument. It performs the following steps:

1. Let rawStrings be TemplateStrings of templateLiteral with argument true.
2. Let realm be the current Realm Record.
3. Let templateRegistry be realm.[[TemplateMap]].
4. For each element e of templateRegistry, do
   1. If e.[[Strings]] and rawStrings contain the same values in the same order, then
      1. Return e.[[Array]].
5. Let cookedStrings be TemplateStrings of templateLiteral with argument false.
6. Let count be the number of elements in the List cookedStrings.
7. Let template be ArrayCreate(count).
8. Let rawObj be ArrayCreate(count).
9. Let index be 0.
10. Repeat while index < count
    1. Let prop be ! ToString(index).
    2. Let cookedValue be the String value cookedStrings[index].
    3. Call template.[[DefineOwnProperty]](prop, PropertyDescriptor{[[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}).
    4. Let rawValue be the String value rawStrings[index].
    5. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor{[[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}).
    6. Let index be index+1.
11. Perform SetIntegrityLevel(rawObj, "frozen").
12. Call template.[[DefineOwnProperty]]("raw", PropertyDescriptor{[[Value]]: rawObj, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}).
13. Perform SetIntegrityLevel(template, "frozen").
14. Append the Record{[[Strings]]: rawStrings, [[Array]]: template} to templateRegistry.
15. Return template.

Note 1

The creation of a template object cannot result in an abrupt completion.

Note 2

Each TemplateLiteral in the program code of a realm is associated with a unique template object that is used in the evaluation of tagged Templates (12.2.9.5). The template objects are frozen and the same template object is used each time a specific tagged Template is evaluated. Whether template objects are created lazily upon first evaluation of the TemplateLiteral or eagerly prior to first evaluation is an implementation choice that is not observable to ECMAScript code.

Note 3

Future editions of this specification may define additional non-enumerable properties of template objects.

TemplateSpans : TemplateTail

1. Return a new empty List.

TemplateSpans : TemplateMiddleList TemplateTail

1. Return the result of SubstitutionEvaluation of TemplateMiddleList.

TemplateMiddleList : TemplateMiddle Expression

1. Let sub be the result of evaluating Expression.
2. ReturnIfAbrupt(sub).
3. Return a List containing only sub.

TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression

1. Let preceding be the result of SubstitutionEvaluation of TemplateMiddleList.
2. ReturnIfAbrupt(preceding).
3. Let next be the result of evaluating Expression.
4. ReturnIfAbrupt(next).
5. Append next as the last element of the List preceding.
6. Return preceding.

TemplateLiteral : NoSubstitutionTemplate

1. Return the String value whose code units are the elements of the TV of NoSubstitutionTemplate as defined in 11.8.6.

TemplateLiteral : TemplateHead Expression TemplateSpans

1. Let head be the TV of TemplateHead as defined in 11.8.6.
2. Let sub be the result of evaluating Expression.
3. ReturnIfAbrupt(sub).
4. Let middle be ? ToString(sub).
5. Let tail be the result of evaluating TemplateSpans.
6. ReturnIfAbrupt(tail).
7. Return the String value whose code units are the elements of head followed by the elements of middle followed by the elements of tail.

Note 1

The string conversion semantics applied to the Expression value are like String.prototype.concat rather than the + operator.

TemplateSpans : TemplateTail

1. Let tail be the TV of TemplateTail as defined in 11.8.6.
2. Return the string consisting of the code units of tail.

TemplateSpans : TemplateMiddleList TemplateTail

1. Let head be the result of evaluating TemplateMiddleList.
2. ReturnIfAbrupt(head).
3. Let tail be the TV of TemplateTail as defined in 11.8.6.
4. Return the string whose code units are the elements of head followed by the elements of tail.

TemplateMiddleList : TemplateMiddle Expression

1. Let head be the TV of TemplateMiddle as defined in 11.8.6.
2. Let sub be the result of evaluating Expression.
3. ReturnIfAbrupt(sub).
4. Let middle be ? ToString(sub).
5. Return the sequence of code units consisting of the code units of head followed by the elements of middle.

Note 2

The string conversion semantics applied to the Expression value are like String.prototype.concat rather than the + operator.

TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression

1. Let rest be the result of evaluating TemplateMiddleList.
2. ReturnIfAbrupt(rest).
3. Let middle be the TV of TemplateMiddle as defined in 11.8.6.
4. Let sub be the result of evaluating Expression.
5. ReturnIfAbrupt(sub).
6. Let last be ? ToString(sub).
7. Return the sequence of code units consisting of the elements of rest followed by the code units of middle followed by the elements of last.

Note 3

The string conversion semantics applied to the Expression value are like String.prototype.concat rather than the + operator.

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

• It is a Syntax Error if the lexical token sequence matched by CoverParenthesizedExpressionAndArrowParameterList cannot be parsed with no tokens left over using ParenthesizedExpression as the goal symbol.
• All Early Errors rules for ParenthesizedExpression and its derived productions also apply to CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.

ParenthesizedExpression : ( Expression )

1. Return IsFunctionDefinition of Expression.

ParenthesizedExpression : ( Expression )

1. Return IsValidSimpleAssignmentTarget of Expression.

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

1. Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
2. Return the result of evaluating expr.

ParenthesizedExpression : ( Expression )

1. Return the result of evaluating Expression. This may be of type Reference.

Note

This algorithm does not apply GetValue to the result of evaluating Expression. The principal motivation for this is so that operators such as delete and typeof may be applied to parenthesized expressions.

With parameter symbol.

MemberExpression : MemberExpression . IdentifierName

1. If MemberExpression Contains symbol is true, return true.
2. If symbol is a ReservedWord, return false.
3. If symbol is an Identifier and StringValue of symbol is the same value as the StringValue of IdentifierName, return true.
4. Return false.

SuperProperty : super . IdentifierName

1. If symbol is the ReservedWord super, return true.
2. If symbol is a ReservedWord, return false.
3. If symbol is an Identifier and StringValue of symbol is the same value as the StringValue of IdentifierName, return true.
4. Return false.

CallExpression : CallExpression . IdentifierName

1. If CallExpression Contains symbol is true, return true.
2. If symbol is a ReservedWord, return false.
3. If symbol is an Identifier and StringValue of symbol is the same value as the StringValue of IdentifierName, return true.
4. Return false.

MemberExpression : MemberExpression [ Expression ] MemberExpression . IdentifierName MemberExpression TemplateLiteral SuperProperty MetaProperty new MemberExpression Arguments NewExpression : new NewExpression CallExpression : MemberExpression Arguments SuperCall CallExpression Arguments CallExpression [ Expression ] CallExpression . IdentifierName CallExpression TemplateLiteral

1. Return false.

MemberExpression : PrimaryExpression

1. If PrimaryExpression is either an ObjectLiteral or an ArrayLiteral, return true.
2. Return false.

MemberExpression : MemberExpression [ Expression ] MemberExpression . IdentifierName MemberExpression TemplateLiteral SuperProperty MetaProperty new MemberExpression Arguments NewExpression : new NewExpression CallExpression : MemberExpression Arguments SuperCall CallExpression Arguments CallExpression [ Expression ] CallExpression . IdentifierName CallExpression TemplateLiteral

1. Return false.

LeftHandSideExpression : CallExpression MemberExpression : MemberExpression [ Expression ] MemberExpression . IdentifierName MemberExpression TemplateLiteral SuperProperty MetaProperty new MemberExpression Arguments NewExpression : new NewExpression

1. Return false.

CallExpression : CallExpression [ Expression ] CallExpression . IdentifierName MemberExpression : MemberExpression [ Expression ] MemberExpression . IdentifierName SuperProperty

1. Return true.

CallExpression : MemberExpression Arguments SuperCall CallExpression Arguments CallExpression TemplateLiteral NewExpression : new NewExpression MemberExpression : MemberExpression TemplateLiteral new MemberExpression Arguments NewTarget : new . target

1. Return false.

MemberExpression : MemberExpression [ Expression ]

1. Let baseReference be the result of evaluating MemberExpression.
2. Let baseValue be ? GetValue(baseReference).
3. Let propertyNameReference be the result of evaluating Expression.
4. Let propertyNameValue be ? GetValue(propertyNameReference).
5. Let bv be ? RequireObjectCoercible(baseValue).
6. Let propertyKey be ? ToPropertyKey(propertyNameValue).
7. If the code matched by the syntactic production that is being evaluated is strict mode code, let strict be true, else let strict be false.
8. Return a value of type Reference whose base value is bv, whose referenced name is propertyKey, and whose strict reference flag is strict.

MemberExpression : MemberExpression . IdentifierName

1. Let baseReference be the result of evaluating MemberExpression.
2. Let baseValue be ? GetValue(baseReference).
3. Let bv be ? RequireObjectCoercible(baseValue).
4. Let propertyNameString be StringValue of IdentifierName.
5. If the code matched by the syntactic production that is being evaluated is strict mode code, let strict be true, else let strict be false.
6. Return a value of type Reference whose base value is bv, whose referenced name is propertyNameString, and whose strict reference flag is strict.

CallExpression : CallExpression [ Expression ]

Is evaluated in exactly the same manner as MemberExpression : MemberExpression [ Expression ] except that the contained CallExpression is evaluated in step 1.

CallExpression : CallExpression . IdentifierName

Is evaluated in exactly the same manner as MemberExpression : MemberExpression . IdentifierName except that the contained CallExpression is evaluated in step 1.

NewExpression : new NewExpression

1. Return ? EvaluateNew(NewExpression, empty).

MemberExpression : new MemberExpression Arguments

1. Return ? EvaluateNew(MemberExpression, Arguments).

CallExpression : MemberExpression Arguments

1. Let ref be the result of evaluating MemberExpression.
2. Let func be ? GetValue(ref).
3. If Type(ref) is Reference and IsPropertyReference(ref) is false and GetReferencedName(ref) is "eval", then
   1. If SameValue(func, %eval%) is true, then
      1. Let argList be ? ArgumentListEvaluation(Arguments).
      2. If argList has no elements, return undefined.
      3. Let evalText be the first element of argList.
      4. If the source code matching this CallExpression is strict code, let strictCaller be true. Otherwise let strictCaller be false.
      5. Let evalRealm be the current Realm Record.
      6. Return ? PerformEval(evalText, evalRealm, strictCaller, true).
4. If Type(ref) is Reference, then
   1. If IsPropertyReference(ref) is true, then
      1. Let thisValue be GetThisValue(ref).
   2. Else, the base of ref is an Environment Record
      1. Let refEnv be GetBase(ref).
      2. Let thisValue be refEnv.WithBaseObject().
5. Else Type(ref) is not Reference,
   1. Let thisValue be undefined.
6. Let thisCall be this CallExpression.
7. Let tailCall be IsInTailPosition(thisCall).
8. Return ? EvaluateDirectCall(func, thisValue, Arguments, tailCall).

A CallExpression evaluation that executes step 3.a.vi is a direct eval.

CallExpression : CallExpression Arguments

1. Let ref be the result of evaluating CallExpression.
2. Let thisCall be this CallExpression.
3. Let tailCall be IsInTailPosition(thisCall).
4. Return ? EvaluateCall(ref, Arguments, tailCall).

The abstract operation EvaluateCall takes as arguments a value ref, a syntactic grammar production arguments, and a Boolean argument tailPosition. It performs the following steps:

1. Let func be ? GetValue(ref).
2. If Type(ref) is Reference, then
   1. If IsPropertyReference(ref) is true, then
      1. Let thisValue be GetThisValue(ref).
   2. Else, the base of ref is an Environment Record
      1. Let refEnv be GetBase(ref).
      2. Let thisValue be refEnv.WithBaseObject().
3. Else Type(ref) is not Reference,
   1. Let thisValue be undefined.
4. Return ? EvaluateDirectCall(func, thisValue, arguments, tailPosition).

The abstract operation EvaluateDirectCall takes as arguments a value func, a value thisValue, a syntactic grammar production arguments, and a Boolean argument tailPosition. It performs the following steps:

1. Let argList be ? ArgumentListEvaluation(arguments).
2. If Type(func) is not Object, throw a TypeError exception.
3. If IsCallable(func) is false, throw a TypeError exception.
4. If tailPosition is true, perform PrepareForTailCall().
5. Let result be Call(func, thisValue, argList).
6. Assert: If tailPosition is true, the above call will not return here, but instead evaluation will continue as if the following return has already occurred.
7. Assert: If result is not an abrupt completion, then Type(result) is an ECMAScript language type.
8. Return result.

SuperProperty : super [ Expression ]

1. Let propertyNameReference be the result of evaluating Expression.
2. Let propertyNameValue be GetValue(propertyNameReference).
3. Let propertyKey be ? ToPropertyKey(propertyNameValue).
4. If the code matched by the syntactic production that is being evaluated is strict mode code, let strict be true, else let strict be false.
5. Return ? MakeSuperPropertyReference(propertyKey, strict).

SuperProperty : super . IdentifierName

1. Let propertyKey be StringValue of IdentifierName.
2. If the code matched by the syntactic production that is being evaluated is strict mode code, let strict be true, else let strict be false.
3. Return ? MakeSuperPropertyReference(propertyKey, strict).

SuperCall : super Arguments

1. Let newTarget be GetNewTarget().
2. If newTarget is undefined, throw a ReferenceError exception.
3. Let func be ? GetSuperConstructor().
4. Let argList be ArgumentListEvaluation of Arguments.
5. ReturnIfAbrupt(argList).
6. Let result be ? Construct(func, argList, newTarget).
7. Let thisER be GetThisEnvironment( ).
8. Return ? thisER.BindThisValue(result).

The abstract operation GetSuperConstructor performs the following steps:

1. Let envRec be GetThisEnvironment( ).
2. Assert: envRec is a function Environment Record.
3. Let activeFunction be envRec.[[FunctionObject]].
4. Let superConstructor be ? activeFunction.[[GetPrototypeOf]]().
5. If IsConstructor(superConstructor) is false, throw a TypeError exception.
6. Return superConstructor.

The abstract operation MakeSuperPropertyReference with arguments propertyKey and strict performs the following steps:

1. Let env be GetThisEnvironment( ).
2. If env.HasSuperBinding() is false, throw a ReferenceError exception.
3. Let actualThis be ? env.GetThisBinding().
4. Let baseValue be ? env.GetSuperBase().
5. Let bv be ? RequireObjectCoercible(baseValue).
6. Return a value of type Reference that is a Super Reference whose base value is bv, whose referenced name is propertyKey, whose thisValue is actualThis, and whose strict reference flag is strict.

Arguments : ( )

1. Return a new empty List.

ArgumentList : AssignmentExpression

1. Let ref be the result of evaluating AssignmentExpression.
2. Let arg be ? GetValue(ref).
3. Return a List whose sole item is arg.

ArgumentList : ... AssignmentExpression

1. Let list be a new empty List.
2. Let spreadRef be the result of evaluating AssignmentExpression.
3. Let spreadObj be ? GetValue(spreadRef).
4. Let iterator be ? GetIterator(spreadObj).
5. Repeat
   1. Let next be ? IteratorStep(iterator).
   2. If next is false, return list.
   3. Let nextArg be ? IteratorValue(next).
   4. Append nextArg as the last element of list.

ArgumentList : ArgumentList , AssignmentExpression

1. Let precedingArgs be the result of evaluating ArgumentList.
2. ReturnIfAbrupt(precedingArgs).
3. Let ref be the result of evaluating AssignmentExpression.
4. Let arg be ? GetValue(ref).
5. Append arg to the end of precedingArgs.
6. Return precedingArgs.

ArgumentList : ArgumentList , ... AssignmentExpression

1. Let precedingArgs be the result of evaluating ArgumentList.
2. Let spreadRef be the result of evaluating AssignmentExpression.
3. Let iterator be ? GetIterator(? GetValue(spreadRef)).
4. Repeat
   1. Let next be ? IteratorStep(iterator).
   2. If next is false, return precedingArgs.
   3. Let nextArg be ? IteratorValue(next).
   4. Append nextArg as the last element of precedingArgs.

MemberExpression : MemberExpression TemplateLiteral

1. Let tagRef be the result of evaluating MemberExpression.
2. Let thisCall be this MemberExpression.
3. Let tailCall be IsInTailPosition(thisCall).
4. Return ? EvaluateCall(tagRef, TemplateLiteral, tailCall).

CallExpression : CallExpression TemplateLiteral

1. Let tagRef be the result of evaluating CallExpression.
2. Let thisCall be this CallExpression.
3. Let tailCall be IsInTailPosition(thisCall).
4. Return ? EvaluateCall(tagRef, TemplateLiteral, tailCall).

NewTarget : new . target

1. Return GetNewTarget().

UpdateExpression : LeftHandSideExpression ++

1. Let lhs be the result of evaluating LeftHandSideExpression.
2. Let oldValue be ? ToNumber(? GetValue(lhs)).
3. Let newValue be the result of adding the value 1 to oldValue, using the same rules as for the + operator (see 12.8.5).
4. Perform ? PutValue(lhs, newValue).
5. Return oldValue.

UpdateExpression : LeftHandSideExpression --

1. Let lhs be the result of evaluating LeftHandSideExpression.
2. Let oldValue be ? ToNumber(? GetValue(lhs)).
3. Let newValue be the result of subtracting the value 1 from oldValue, using the same rules as for the - operator (see 12.8.5).
4. Perform ? PutValue(lhs, newValue).
5. Return oldValue.

UpdateExpression : ++ UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Let oldValue be ? ToNumber(? GetValue(expr)).
3. Let newValue be the result of adding the value 1 to oldValue, using the same rules as for the + operator (see 12.8.5).
4. Perform ? PutValue(expr, newValue).
5. Return newValue.

UpdateExpression : -- UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Let oldValue be ? ToNumber(? GetValue(expr)).
3. Let newValue be the result of subtracting the value 1 from oldValue, using the same rules as for the - operator (see 12.8.5).
4. Perform ? PutValue(expr, newValue).
5. Return newValue.

UnaryExpression : delete UnaryExpression

• It is a Syntax Error if the UnaryExpression is contained in strict mode code and the derived UnaryExpression is PrimaryExpression : IdentifierReference.

• It is a Syntax Error if the derived UnaryExpression is
  PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  and CoverParenthesizedExpressionAndArrowParameterList ultimately derives a phrase that, if used in place of UnaryExpression, would produce a Syntax Error according to these rules. This rule is recursively applied.

Note

The last rule means that expressions such as delete (((foo))) produce early errors because of recursive application of the first rule.

UnaryExpression : delete UnaryExpression

1. Let ref be the result of evaluating UnaryExpression.
2. ReturnIfAbrupt(ref).
3. If Type(ref) is not Reference, return true.
4. If IsUnresolvableReference(ref) is true, then
   1. Assert: IsStrictReference(ref) is false.
   2. Return true.
5. If IsPropertyReference(ref) is true, then
   1. If IsSuperReference(ref) is true, throw a ReferenceError exception.
   2. Let baseObj be ! ToObject(GetBase(ref)).
   3. Let deleteStatus be ? baseObj.[[Delete]](GetReferencedName(ref)).
   4. If deleteStatus is false and IsStrictReference(ref) is true, throw a TypeError exception.
   5. Return deleteStatus.
6. Else ref is a Reference to an Environment Record binding,
   1. Let bindings be GetBase(ref).
   2. Return ? bindings.DeleteBinding(GetReferencedName(ref)).

Note

When a delete operator occurs within strict mode code, a SyntaxError exception is thrown if its UnaryExpression is a direct reference to a variable, function argument, or function name. In addition, if a delete operator occurs within strict mode code and the property to be deleted has the attribute { [[Configurable]]: false }, a TypeError exception is thrown.

UnaryExpression : void UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Perform ? GetValue(expr).
3. Return undefined.

Note

GetValue must be called even though its value is not used because it may have observable side-effects.

UnaryExpression : typeof UnaryExpression

1. Let val be the result of evaluating UnaryExpression.
2. If Type(val) is Reference, then
   1. If IsUnresolvableReference(val) is true, return "undefined".
3. Let val be ? GetValue(val).
4. Return a String according to Table 35.

Type of val	Result
Undefined	"undefined"
Null	"object"
Boolean	"boolean"
Number	"number"
String	"string"
Symbol	"symbol"
Object (ordinary and does not implement [[Call]])	"object"
Object (standard exotic and does not implement [[Call]])	"object"
Object (implements [[Call]])	"function"
Object (non-standard exotic and does not implement [[Call]])	Implementation-defined. Must not be "undefined", "boolean", "function", "number", "symbol", or "string".

Note

Implementations are discouraged from defining new typeof result values for non-standard exotic objects. If possible "object" should be used for such objects.

UnaryExpression : + UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Return ? ToNumber(? GetValue(expr)).

UnaryExpression : - UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Let oldValue be ? ToNumber(? GetValue(expr)).
3. If oldValue is NaN, return NaN.
4. Return the result of negating oldValue; that is, compute a Number with the same magnitude but opposite sign.

UnaryExpression : ~ UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Let oldValue be ? ToInt32(? GetValue(expr)).
3. Return the result of applying bitwise complement to oldValue. The result is a signed 32-bit integer.

UnaryExpression : ! UnaryExpression

1. Let expr be the result of evaluating UnaryExpression.
2. Let oldValue be ToBoolean(? GetValue(expr)).
3. If oldValue is true, return false.
4. Return true.

The * MultiplicativeOperator performs multiplication, producing the product of its operands. Multiplication is commutative. Multiplication is not always associative in ECMAScript, because of finite precision.

The result of a floating-point multiplication is governed by the rules of IEEE 754-2008 binary double-precision arithmetic:

• If either operand is NaN, the result is NaN.
• The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
• Multiplication of an infinity by a zero results in NaN.
• Multiplication of an infinity by an infinity results in an infinity. The sign is determined by the rule already stated above.
• Multiplication of an infinity by a finite nonzero value results in a signed infinity. The sign is determined by the rule already stated above.
• In the remaining cases, where neither an infinity nor NaN is involved, the product is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the result is then a zero of appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.

The / MultiplicativeOperator performs division, producing the quotient of its operands. The left operand is the dividend and the right operand is the divisor. ECMAScript does not perform integer division. The operands and result of all division operations are double-precision floating-point numbers. The result of division is determined by the specification of IEEE 754-2008 arithmetic:

• If either operand is NaN, the result is NaN.
• The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
• Division of an infinity by an infinity results in NaN.
• Division of an infinity by a zero results in an infinity. The sign is determined by the rule already stated above.
• Division of an infinity by a nonzero finite value results in a signed infinity. The sign is determined by the rule already stated above.
• Division of a finite value by an infinity results in zero. The sign is determined by the rule already stated above.
• Division of a zero by a zero results in NaN; division of zero by any other finite value results in zero, with the sign determined by the rule already stated above.
• Division of a nonzero finite value by a zero results in a signed infinity. The sign is determined by the rule already stated above.
• In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the quotient is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows; the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the operation underflows and the result is a zero of the appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.

The % MultiplicativeOperator yields the remainder of its operands from an implied division; the left operand is the dividend and the right operand is the divisor.

Note

In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floating-point operands.

The result of a floating-point remainder operation as computed by the % operator is not the same as the “remainder” operation defined by IEEE 754-2008. The IEEE 754-2008 “remainder” operation computes the remainder from a rounding division, not a truncating division, and so its behaviour is not analogous to that of the usual integer remainder operator. Instead the ECMAScript language defines % on floating-point operations to behave in a manner analogous to that of the Java integer remainder operator; this may be compared with the C library function fmod.

The result of an ECMAScript floating-point remainder operation is determined by the rules of IEEE arithmetic:

• If either operand is NaN, the result is NaN.
• The sign of the result equals the sign of the dividend.
• If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
• If the dividend is finite and the divisor is an infinity, the result equals the dividend.
• If the dividend is a zero and the divisor is nonzero and finite, the result is the same as the dividend.
• In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the floating-point remainder r from a dividend n and a divisor d is defined by the mathematical relation r = n - (d × q) where q is an integer that is negative only if n/d is negative and positive only if n/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d. r is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.

Returns an implementation-dependent approximation of the result of raising base to the power exponent.

• If exponent is NaN, the result is NaN.
• If exponent is +0, the result is 1, even if base is NaN.
• If exponent is -0, the result is 1, even if base is NaN.
• If base is NaN and exponent is nonzero, the result is NaN.
• If abs(base) > 1 and exponent is +∞, the result is +∞.
• If abs(base) > 1 and exponent is -∞, the result is +0.
• If abs(base) is 1 and exponent is +∞, the result is NaN.
• If abs(base) is 1 and exponent is -∞, the result is NaN.
• If abs(base) < 1 and exponent is +∞, the result is +0.
• If abs(base) < 1 and exponent is -∞, the result is +∞.
• If base is +∞ and exponent > 0, the result is +∞.
• If base is +∞ and exponent < 0, the result is +0.
• If base is -∞ and exponent > 0 and exponent is an odd integer, the result is -∞.
• If base is -∞ and exponent > 0 and exponent is not an odd integer, the result is +∞.
• If base is -∞ and exponent < 0 and exponent is an odd integer, the result is -0.
• If base is -∞ and exponent < 0 and exponent is not an odd integer, the result is +0.
• If base is +0 and exponent > 0, the result is +0.
• If base is +0 and exponent < 0, the result is +∞.
• If base is -0 and exponent > 0 and exponent is an odd integer, the result is -0.
• If base is -0 and exponent > 0 and exponent is not an odd integer, the result is +0.
• If base is -0 and exponent < 0 and exponent is an odd integer, the result is -∞.
• If base is -0 and exponent < 0 and exponent is not an odd integer, the result is +∞.
• If base < 0 and base is finite and exponent is finite and exponent is not an integer, the result is NaN.

Note

The result of base ** exponent when base is 1 or -1 and exponent is +Infinity or -Infinity differs from IEEE 754-2008. The first edition of ECMAScript specified a result of NaN for this operation, whereas later versions of IEEE 754-2008 specified 1. The historical ECMAScript behaviour is preserved for compatibility reasons.

AdditiveExpression : AdditiveExpression + MultiplicativeExpression

1. Let lref be the result of evaluating AdditiveExpression.
2. Let lval be ? GetValue(lref).
3. Let rref be the result of evaluating MultiplicativeExpression.
4. Let rval be ? GetValue(rref).
5. Let lprim be ? ToPrimitive(lval).
6. Let rprim be ? ToPrimitive(rval).
7. If Type(lprim) is String or Type(rprim) is String, then
   1. Let lstr be ? ToString(lprim).
   2. Let rstr be ? ToString(rprim).
   3. Return the String that is the result of concatenating lstr and rstr.
8. Let lnum be ? ToNumber(lprim).
9. Let rnum be ? ToNumber(rprim).
10. Return the result of applying the addition operation to lnum and rnum. See the Note below 12.8.5.

Note 1

No hint is provided in the calls to ToPrimitive in steps 5 and 6. All standard objects except Date objects handle the absence of a hint as if the hint Number were given; Date objects handle the absence of a hint as if the hint String were given. Exotic objects may handle the absence of a hint in some other manner.

Note 2

Step 7 differs from step 5 of the Abstract Relational Comparison algorithm, by using the logical-or operation instead of the logical-and operation.

AdditiveExpression : AdditiveExpression - MultiplicativeExpression

1. Let lref be the result of evaluating AdditiveExpression.
2. Let lval be ? GetValue(lref).
3. Let rref be the result of evaluating MultiplicativeExpression.
4. Let rval be ? GetValue(rref).
5. Let lnum be ? ToNumber(lval).
6. Let rnum be ? ToNumber(rval).
7. Return the result of applying the subtraction operation to lnum and rnum. See the note below 12.8.5.

ShiftExpression : ShiftExpression << AdditiveExpression

1. Let lref be the result of evaluating ShiftExpression.
2. Let lval be ? GetValue(lref).
3. Let rref be the result of evaluating AdditiveExpression.
4. Let rval be ? GetValue(rref).
5. Let lnum be ? ToInt32(lval).
6. Let rnum be ? ToUint32(rval).
7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
8. Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer.

ShiftExpression : ShiftExpression >> AdditiveExpression

1. Let lref be the result of evaluating ShiftExpression.
2. Let lval be ? GetValue(lref).
3. Let rref be the result of evaluating AdditiveExpression.
4. Let rval be ? GetValue(rref).
5. Let lnum be ? ToInt32(lval).
6. Let rnum be ? ToUint32(rval).
7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
8. Return the result of performing a sign-extending right shift of lnum by shiftCount bits. The most significant bit is propagated. The result is a signed 32-bit integer.

ShiftExpression : ShiftExpression >>> AdditiveExpression

1. Let lref be the result of evaluating ShiftExpression.
2. Let lval be ? GetValue(lref).
3. Let rref be the result of evaluating AdditiveExpression.
4. Let rval be ? GetValue(rref).
5. Let lnum be ? ToUint32(lval).
6. Let rnum be ? ToUint32(rval).
7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
8. Return the result of performing a zero-filling right shift of lnum by shiftCount bits. Vacated bits are filled with zero. The result is an unsigned 32-bit integer.