ECMA-262 (12th Edition) ECMAScript 2021 Language Specification - page 25

The definition of the nonterminal

}

NOTE 2

A string literal stands for a value of the String type. The String value (SV) of the literal is described in terms of String
values contributed by the various parts of the string literal. As part of this process, some Unicode code points within
the string literal are interpreted as having a

mathematical value

(MV), as described below or in

12.8.3

The SV of

StringLiteral

is the empty String.

The SV of

StringLiteral

is the empty String.

The SV of

DoubleStringCharacters

DoubleStringCharacters

of the SV of

and the SV of

DoubleStringCharacters

The SV of

SingleStringCharacters

SingleStringCharacters

is the

the SV of

and the SV of

SingleStringCharacters

The SV of

but not one of

is the result of

performing

The SV of

<LS>

is the String value consisting of the code unit 0x2028 (LINE

SEPARATOR).
The SV of

<PS>

is the String value consisting of the code unit 0x2029 (PARAGRAPH

SEPARATOR).
The SV of

is the empty String.

The SV of

but not one of

is the result of

performing

The SV of

<LS>

is the String value consisting of the code unit 0x2028 (LINE

SEPARATOR).
The SV of

<PS>

is the String value consisting of the code unit 0x2029 (PARAGRAPH

SEPARATOR).
The SV of

is the empty String.

The SV of

<LF> and <CR> cannot appear in a string literal, except as part of a

is the String value consisting of the code unit 0x0000 (NULL).

CharacterEscapeSequence

to produce

the empty code points sequence. The proper way to include either in the String value of a string
literal is to use an escape sequence such as

\u000A

12.8.4.1 Static Semantics: SV

291

The SV of

SingleEscapeCharacter

is the String value consisting of the code unit

whose value is determined by the

SingleEscapeCharacter

according to

Table 36

Table 36: String Single Character Escape Sequences

Escape Sequence Code Unit Value

Unicode Character Name

Symbol

0x0008

BACKSPACE

<BS>

0x0009

CHARACTER TABULATION <HT>

0x000A

LINE FEED (LF)

<LF>

0x000B

LINE TABULATION

<VT>

0x000C

FORM FEED (FF)

<FF>

0x000D

CARRIAGE RETURN (CR)

<CR>

0x0022

QUOTATION MARK

0x0027

APOSTROPHE

0x005C

REVERSE SOLIDUS

The SV of

but not one of

is the result

The SV of

HexEscapeSequence

is the String value consisting of the code unit whose

The SV of

is the String value consisting of the code unit

whose value is the MV of

The SV of

}

is the result of performing

MV of

The MV of

is (16 times the MV of the first

) plus the MV of

the second

The MV of

is (0x1000

the MV of the first

) plus

(0x100

the MV of the second

) plus (0x10

the MV of the third

) plus the MV of the fourth

NOTE 1

A regular expression literal is an input element that is converted to a RegExp object (see

22.2

)

each time the literal is evaluated. Two regular expression literals in a program evaluate to regular
expression objects that never compare as

===

to each other even if the two literals' contents are

identical. A RegExp object may also be created at runtime by

new RegExp

or calling the

12.8.4.2 Static Semantics: MV

12.8.5 Regular Expression Literals

292

The productions below describe the syntax for a regular expression literal and are used by the input element scanner
to find the end of the regular expression literal. The source text comprising the

and the

are subsequently parsed again using the more stringent ECMAScript Regular Expression

grammar (

22.2.1

An implementation may extend the ECMAScript Regular Expression grammar defined in

22.2.1

, but it must not

extend the

and

RegularExpressionLiteral

productions defined below or the productions used by

these productions.

RegularExpressionFirstChar

RegularExpressionChars

[empty]

RegularExpressionChars

RegularExpressionChar

RegularExpressionFirstChar

RegularExpressionBackslashSequence
RegularExpressionClass

but not one of

[

RegularExpressionChar

RegularExpressionBackslashSequence
RegularExpressionClass

but not one of

[

RegularExpressionBackslashSequence

but not

RegularExpressionClassChars

RegularExpressionClass

[

]

RegularExpressionClassChars

[empty]

RegularExpressionClassChars

RegularExpressionClassChar

RegularExpressionBackslashSequence

but not one of

]

[empty]

Syntax

293

IdentifierPart

NOTE 2

contains a Unicode escape sequence.

IdentifierPart

It is a Syntax Error if

IdentifierPart

RegularExpressionLiteral

1. Return the source text that was recognized as

RegularExpressionLiteral

1. Return the source text that was recognized as

NoSubstitutionTemplate
TemplateHead

Template

NoSubstitutionTemplate

TemplateSubstitutionTail

TemplateMiddle
TemplateTail

}

}

Regular expression literals may not be empty; instead of representing an empty regular
expression literal, the code unit sequence

starts a single-line comment. To specify an empty

regular expression, use:

/(?:)/

12.8.5.1 Static Semantics: Early Errors

12.8.5.2 Static Semantics: BodyText

12.8.5.3 Static Semantics: FlagText

12.8.6 Template Literal Lexical Components

Syntax

294

[lookahead

≠

{

]

LineContinuation
LineTerminatorSequence
SourceCharacter

but not one of

but not

[lookahead

∉

]

[lookahead

∉

]

[lookahead

∉

] [lookahead

≠

{

]

[lookahead

∉

]

[lookahead

∉

]

[lookahead

∉

]

{

[lookahead

∉

]

{

NotCodePoint

[lookahead

∉

]

{

[lookahead

∉

A conforming implementation must not use the extended definition of

] [lookahead

≠

}

]

> 0x10FFFF

≤

0x10FFFF

NOTE

A template literal component is interpreted as a sequence of Unicode code points. The Template Value (TV) of a literal
component is described in terms of String values (

12.8.4

) contributed by the various parts of the template literal

component. As part of this process, some Unicode code points within the template component are interpreted as
having a

mathematical value

(MV,

12.8.3

). In determining a TV, escape sequences are replaced by the UTF-16 code

unit(s) of the Unicode code point represented by the escape sequence. The Template Raw Value (TRV) is similar to a
Template Value with the difference that in TRVs escape sequences are interpreted literally.

The TV and TRV of

NoSubstitutionTemplate

is the empty String.

The TV and TRV of

TemplateHead

is the empty String.

The TV and TRV of

TemplateMiddle

}

is the empty String.

The TV and TRV of

TemplateTail

}

is the empty String.

The TV of

TemplateCharacters

TemplateSubstitutionTail

TemplateCharacters

undefined

if either the TV of

. Otherwise, it is the

string-

is used by the

InputElementTemplateTail

alternative lexical goal.

12.8.6.1 Static Semantics: TV and TRV

295

The TV of

but not one of

is the result of

performing

The TV of

is the String value consisting of the code unit 0x0024 (DOLLAR SIGN).

The TV of

is the

The TV of

undefined

The TV of

is the TRV of

The TV of

is the empty String.

The TRV of

is the

The TRV of

but not one of

is the result of

performing

The TRV of

is the String value consisting of the code unit 0x0024 (DOLLAR SIGN).

The TRV of

is the

of the code unit 0x005C

(REVERSE SOLIDUS) and the TRV of

The TRV of

is the

of the code unit 0x005C

(REVERSE SOLIDUS) and the TRV of

The TRV of

is the String value consisting of the code unit 0x0030 (DIGIT ZERO).

The TRV of

is the

of the code unit 0x0030 (DIGIT

ZERO) and the TRV of

The TRV of

[lookahead

∉

] is the String value consisting of the code unit

0x0078 (LATIN SMALL LETTER X).
The TRV of

[lookahead

∉

] is the

of the code

unit 0x0078 (LATIN SMALL LETTER X) and the TRV of

The TRV of

[lookahead

∉

] [lookahead

≠

{

] is the String value consisting of

the code unit 0x0075 (LATIN SMALL LETTER U).
The TRV of

[lookahead

∉

] is the

of the code

unit 0x0075 (LATIN SMALL LETTER U) and the TRV of

The TRV of

[lookahead

∉

] is the

the code unit 0x0075 (LATIN SMALL LETTER U), the TRV of the first

of the code unit 0x0075 (LATIN SMALL LETTER U), the TR V of the first

, and the TRV of the second

, the TRV of the

second

, and the TRV of the third

The TRV of

{

[lookahead

∉

] is the

of the code unit

0x0075 (LATIN SMALL LETTER U) and the code unit 0x007B (LEFT CURLY BRACKET).
The TRV of

{

NotCodePoint

[lookahead

∉

] is the

of the code unit 0x0075 (LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY

of the

code unit 0x0075 (LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY BRACKET), and the TRV of

BRACKET), and the TRV of

The TRV of

one of

is the result of performing

CharacterEscapeSequence

on the single code point matched by this production.
The TRV of

NonEscapeCharacter

NonEscapeCharacter

The TRV of

SingleEscapeCharacter

one of

is the result of performing

on the single code point matched by this production.

The TRV of

HexEscapeSequence

is the

of the code unit 0x0078

296

(LATIN SMALL LETTER X), the TRV of the first

, and the TRV of the second

The TRV of

of the code unit 0x0075 (LATIN

SMALL LETTER U) and the TRV of

The TRV of

}

of the code unit 0x0075

(LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY BRACKET), the TRV of

, and the

code unit 0x007D (RIGHT CURLY BRACKET).
The TRV of

of the TRV of the

, the TRV of the second

, the TRV of the third

, and the TRV of the fourth

The TRV of

is the

of the TRV of

The TRV of

one of

is the result of performing

on the single code point matched by this production.

The TRV of

of the code unit 0x005C

(REVERSE SOLIDUS) and the TRV of

The TRV of

<LF>

is the String value consisting of the code unit 0x000A (LINE

FEED).
The TRV of

<CR>

is the String value consisting of the code unit 0x000A (LINE

FEED).
The TRV of

<LS>

is the String value consisting of the code unit 0x2028 (LINE

SEPARATOR).
The TRV of

<PS>

is the String value consisting of the code unit 0x2029

(PARAGRAPH SEPARATOR).
The TRV of

In the following rules, “token” means the actual recognized lexical token determined using the current lexical

<CR>

<LF>

is the String value consisting of the code unit 0x000A

(LINE FEED).

NOTE

Most ECMAScript statements and declarations must be terminated with a semicolon. Such semicolons may always
appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in
certain situations. These situations are described by saying that semicolons are automatically inserted into the source
code token stream in those situations.

goal

symbol

as described in clause

There are three basic rules of semicolon insertion:

1. When, as the source text is parsed from left to right, a token (called the

offending token

) is encountered that is

not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending
token if one or more of the following conditions is true:

TV excludes the code units of

while TRV includes them. <CR><LF> and <CR>

s are normalized to <LF> for both TV and TRV. An explicit

is needed to include a <CR> or <CR><LF> sequence.

12.9 Automatic Semicolon Insertion

12.9.1 Rules of Automatic Semicolon Insertion

297

The offending token is separated from the previous token by at least one

terminal or nonterminal immediately following the annotation “[no

The offending token is

}}

The previous token is

))

and the inserted semicolon would then be parsed as the terminating semicolon

of a do-while statement (

14.7.2

2. When, as the source text is parsed from left to right, the end of the input stream of tokens is encountered and

the parser is unable to parse the input token stream as a single instance of the goal nonterminal, then a
semicolon is automatically inserted at the end of the input stream.

3. When, as the source text is parsed from left to right, a token is encountered that is allowed by some production

of the grammar, but the production is a

restricted production

and the token would be the first token for a

here]” within the restricted

production (and therefore such a token is called a restricted token), and the restricted token is separated from
the previous token by at least one

, then a semicolon is automatically inserted before the

restricted token.

However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted
automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of
the two semicolons in the header of a

for

statement (see

14.7.4

298

NOTE

This section is non-normative.

The source

The following are the only restricted productions in the grammar:

UpdateExpression

[Yield, Await]

LeftHandSideExpression

here]

LeftHandSideExpression

here]

[Yield, Await]

continue

;

continue

[no

here]

LabelIdentifier

[?Yield, ?Await]

;

BreakStatement

[Yield, Await]

break

;

break

here]

;

[Yield, Await]

return

;

return

here]

Expression

[+In, ?Yield, ?Await]

;

ThrowStatement

[Yield, Await]

throw

here]

Expression

[+In, ?Yield, ?Await]

;

[no

here]

[In, Await]

yield

here]

AssignmentExpression

[?In, +Yield, ?Await]

yield

here]

AssignmentExpression

[?In, +Yield, ?Await]

The practical effect of these restricted productions is as follows:

When a

token is encountered where the parser would treat it as a postfix

operator, and at least one

occurred between the preceding token and the

token, then a semicolon is automatically inserted before the

token.

When a

continue

break

return

throw

, or

yield

token is encountered and a

is encountered before the next token, a semicolon is automatically inserted

after the

continue

break

return

throw

, or

yield

token.

The resulting practical advice to ECMAScript programmers is:

A postfix

operator should appear on the same line as its operand.

Expression

in a

return

throw

statement or an

AssignmentExpression

in a

yield

expression should start on the same line as the

return

throw

, or

yield

token.

LabelIdentifier

in a

break

continue

statement should be on the same line as the

break

continue

token.

12.9.2 Examples of Automatic Semicolon Insertion

299

NOTE 1

NOTE 2

AsyncGeneratorMethod

async

PropertyName

(

)

{

}

It is a Syntax Error if

AsyncGeneratorMethod

true

It is a Syntax Error if

YieldExpression

true

It is a Syntax Error if

FunctionBodyContainsUseStrict

AwaitExpression

true

It is a Syntax Error if

true

and

IsSimpleParameterList

false

It is a Syntax Error if any element of the

BoundNames

also occurs in the

LexicallyDeclaredNames

async

function

(

)

{

}

async

function

(

)

{

}

async

function

opt

(

)

{

}

If the source code matching

strict mode code

, the Early Error rules for

are applied.

is present and the source code matching

strict mode code

, it is a Syntax

Error if the

FunctionBodyContainsUseStrict

"eval"

"arguments"

It is a Syntax Error if

true

and

IsSimpleParameterList

false

It is a Syntax Error if any element of the

BoundNames

also occurs in the

LexicallyDeclaredNames

It is a Syntax Error if

YieldExpression

true

It is a Syntax Error if

AwaitExpression

true

It is a Syntax Error if

SuperProperty

true

It is a Syntax Error if

SuperProperty

true

It is a Syntax Error if

SuperCall

true

It is a Syntax Error if

SuperCall

true

With parameters

functionObject

and

argumentsList

FunctionDeclarationInstantiation

FunctionBody

1. Perform ?

(

functionObject

argumentsList

2. Let

generator

be ?

OrdinaryCreateFromConstructor

functionObject

cannot be used within the

of an async

generator function because any expressions that are part of

are evaluated before

the resulting async generator object is in a resumable state.

Abstract operations

relating to async generator objects are defined in

27.6.3

15.6.1 Static Semantics: Early Errors

15.6.2 Runtime Semantics: EvaluateAsyncGeneratorBody

409

"%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

async

function

(

)

{

}

1. Let

name

2. Let

sourceText

be the source text matched by

3. Let

be !

sourceText

non-lexical-this

scope

4. Perform !

name

5. Let

prototype

be !

(

6. Perform !

(

"prototype"

, PropertyDescriptor { [[Value]]:

prototype

, [[Writable]]:

true

[[Enumerable]]:

false

, [[Configurable]]:

false

}).

7. Return

async

function

(

)

{

}

1. Let

sourceText

be the source text matched by

2. Let

sourceText

non-lexical-this

scope

3. Perform

"default"

4. Let

prototype

be !

(

5. Perform

(

"prototype"

, PropertyDescriptor { [[Value]]:

prototype

, [[Writable]]:

true

[[Enumerable]]:

false

, [[Configurable]]:

false

}).

6. Return

NOTE

With optional parameter

name

async

function

(

)

{

}

1. If

name

is not present, set

name

2. Let

scope

be the LexicalEnvironment of the

3. Let

sourceText

be the source text matched by

4. Let

closure

be !

(

sourceText

non-lexical-this

scope

5. Perform

closure

name

An anonymous

can only occur as part of an

export default

declaration.

15.6.3 Runtime Semantics: InstantiateAsyncGeneratorFunctionObject

15.6.4 Runtime Semantics: InstantiateAsyncGeneratorFunctionExpression

410

6. Let

prototype

be !

(

7. Perform !

(

closure

"prototype"

, PropertyDescriptor { [[Value]]:

prototype

, [[Writable]]:

true

, [[Enumerable]]:

false

, [[Configurable]]:

false

}).

8. Return

closure

async

function

(

)

{

}

Assert

name

is not present.

2. Set

name

3. Let

scope

be the

NewDeclarativeEnvironment

's LexicalEnvironment.

4. Let

funcEnv

be !

(

scope

5. Perform !

funcEnv

.CreateImmutableBinding(

name

false

6. Let

sourceText

be the source text matched by

7. Let

closure

be !

(

sourceText

non-lexical-this

funcEnv

8. Perform !

closure

name

9. Let

prototype

be !

(

10. Perform !

(

closure

"prototype"

, PropertyDescriptor { [[Value]]:

prototype

, [[Writable]]:

true

, [[Enumerable]]:

false

, [[Configurable]]:

false

}).

11. Perform !

funcEnv

.InitializeBinding(

name

closure

12. Return

closure

NOTE

async

function

opt

(

)

{

InstantiateAsyncGeneratorFunctionExpression

}

1. Return

ClassDeclaration

[Yield, Await, Default]

class

[?Yield, ?Await]

ClassTail

[+Default]

class

[?Yield, ?Await]

class

[?Yield, ?Await]

opt

[?Yield, ?Await]

[?Yield, ?Await]

opt

{

opt

}

The

in an

can be referenced from inside the

to allow the generator code to call itself

recursively. However, unlike in an

, the

in an

cannot be referenced from and does not affect the scope enclosing the

15.6.5 Runtime Semantics: Evaluation

15.7 Class Definitions

Syntax

411

[Yield, Await]

extends

LeftHandSideExpression

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

static

;

NOTE

{

}

It is a Syntax Error if

is not present and the following algorithm evaluates to

true

1. Let

constructor

ConstructorMethod

2. If

constructor

empty

, return

false

3. Return

constructor

PrototypePropertyNameList

It is a Syntax Error if

contains more than one occurrence of

"constructor"

It is a Syntax Error if

is not

"constructor"

and

true

It is a Syntax Error if

"constructor"

and

true

static

It is a Syntax Error if

A class definition is always

true

It is a Syntax Error if

"prototype"

1. If

"constructor"

, return

ConstructorMethod

2. Return

NonConstructorMethod

strict mode code

15.7.1 Static Semantics: Early Errors

15.7.2 Static Semantics: ClassElementKind

412

static

1. Return

NonConstructorMethod

;

1. Return

empty

1. If

ConstructorMethod

, return

2. Return

empty

1. Let

head

ConstructorMethod

2. If

head

is not

empty

, return

head

3. If

ClassElementKind

ConstructorMethod

, return

4. Return

empty

NOTE

1. Return

false

static

1. Return

true

;

1. Return

false

1. If

NonConstructorMethod

, then

a. Return a

whose sole element is

2. Return a new empty

NonConstructorMethodDefinitions

1. Let

list

2. If

ClassElementKind

NonConstructorMethod

, then

a. Append

to the end of

list

3. Return

list

Early Error rules ensure that there is only one method definition named

"constructor"

and that it

is not an

accessor property

or generator definition.

15.7.3 Static Semantics: ConstructorMethod

15.7.4 Static Semantics: IsStatic

15.7.5 Static Semantics: NonConstructorMethodDefinitions

413

1. If

empty

, return a new empty

2. If

IsStatic

true

, return a new empty

3. Return a

PrototypePropertyNameList

whose sole element is

1. Let

list

2. If

empty

, return

list

3. If

IsStatic

true

, return

list

4. Append

to the end of

list

5. Return

list

With parameters

classBinding

and

className

{

}

1. Let

env

be the LexicalEnvironment of the

NewDeclarativeEnvironment

2. Let

classScope

(

env

3. If

classBinding

is not

undefined

, then

a. Perform

classScope

.CreateImmutableBinding(

classBinding

true

4. If

opt

is not present, then

a. Let

protoParent

%Object.prototype%

b. Let

constructorParent

%Function.prototype%

5. Else,

a. Set the

's LexicalEnvironment to

classScope

b. Let

superclassRef

be the result of evaluating

c. Set the

's LexicalEnvironment to

env

d. Let

superclass

be ?

GetValue

(

superclassRef

e. If

superclass

null

, then

i. Let

protoParent

null

ii. Let

constructorParent

%Function.prototype%

f. Else if

IsConstructor

(

superclass

) is

false

, throw a

TypeError

exception.

g. Else,

i. Let

protoParent

be ?

Get

superclass

"prototype"

ii. If

Type

(

protoParent

) is neither Object nor Null, throw a

TypeError

exception.

iii. Let

constructorParent

superclass

6. Let

proto

be !

(

protoParent

7. If

opt

is not present, let

constructor

empty

8. Else, let

constructor

ConstructorMethod

9. Set the

Default Constructor Functions

's LexicalEnvironment to

classScope

10. If

constructor

empty

, then

a. Let

steps

be the algorithm steps defined in

b. Let

be !

CreateBuiltinFunction

steps

, 0,

className

, « [[ConstructorKind]], [[SourceText]] »,

empty

constructorParent

15.7.6 Static Semantics: PrototypePropertyNameList

15.7.7 Runtime Semantics: ClassDefinitionEvaluation

414

11. Else,

a. Let

constructorInfo

be !

DefineMethod

constructor

with arguments

proto

and

constructorParent

b. Let

constructorInfo

.[[Closure]].

c. Perform !

d. Perform !

className

12. Perform !

MakeConstructor

(

false

proto

13. If

opt

is present, set

.[[ConstructorKind]] to

derived

14. Perform !

CreateMethodProperty

proto

"constructor"

15. If

opt

is not present, let

methods

be a new empty

NonConstructorMethodDefinitions

16. Else, let

methods

17. For each

PropertyDefinitionEvaluation

methods

, do

a. If

IsStatic

false

, then

i. Let

status

with arguments

proto

and

false

b. Else,

i. Let

status

PropertyDefinitionEvaluation

with arguments

and

false

c. If

status

is an

abrupt completion

, then

i. Set the

's LexicalEnvironment to

env

ii. Return

Completion

(

status

18. Set the

's LexicalEnvironment to

env

19. If

classBinding

is not

undefined

, then

a. Perform

classScope

.InitializeBinding(

classBinding

20. Return

When a Default

Constructor

Function is called with zero or more arguments which form the rest parameter ...

args

, the

following steps are taken:

1. If NewTarget is

undefined

, throw a

TypeError

exception.

2. Let

be the

active function object

3. If

.[[ConstructorKind]] is

derived

, then

a. NOTE: This branch behaves similarly to

constructor(...args) { super(...args); }

The most notable distinction is that while the aforementioned ECMAScript source text observably calls
the

@@iterator

method on

%Array.prototype%

, a Default

Constructor

Function does not.

b. Let

func

be !

.[[GetPrototypeOf]]().

c. If

IsConstructor

OrdinaryCreateFromConstructor

func

) is

false

, throw a

TypeError

exception.

d. Return ?

Construct

(

func

args

, NewTarget).

4. Else,

a. NOTE: This branch behaves similarly to

constructor() {}

b. Return ?

(NewTarget,

"%Object.prototype%"

The

"length"

property of a default

constructor

function is

𝔽

ClassDeclaration

class

ClassTail

1. Let

className