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

and

, that describe how sequences of tokens form syntactically correct

independent components of ECMAScript programs.

When a stream of code points is to be parsed as an ECMAScript

, it is first converted to a stream of

input elements by repeated application of the lexical grammar; this stream of input elements is then parsed by a single
application of the syntactic grammar. The input stream is syntactically in error if the tokens in the stream of input
elements cannot be parsed as a single instance of the goal nonterminal (

), with no tokens left over.

When a parse is successful, it constructs a

parse tree

, a rooted tree structure in which each node is a

Parse Node

. Each

Parse Node is an

instance

of a symbol in the grammar; it represents a span of the source text that can be derived from

that symbol. The root node of the parse tree, representing the whole of the source text, is an instance of the parse's

goal symbol

. When a Parse Node is an instance of a nonterminal, it is also an instance of some production that has

that nonterminal as its left-hand side. Moreover, it has zero or more

children

, one for each symbol on the production's

right-hand side: each child is a Parse Node that is an instance of the corresponding symbol.

New Parse Nodes are instantiated for each invocation of the parser and never reused between parses even of identical
source text. Parse Nodes are considered

the same Parse Node

if and only if they represent the same span of source text,

are instances of the same grammar symbol, and resulted from the same parser invocation.

NOTE 1

NOTE 2

Productions of the syntactic grammar are distinguished by having just one colon “

” as punctuation.

The syntactic grammar as presented in clauses

through

is not a complete account of which token sequences are

accepted as a correct ECMAScript

. Certain additional token sequences are also accepted, namely,

those that would be described by the grammar if only semicolons were added to the sequence in certain places (such
as before line terminator characters). Furthermore, certain token sequences that are described by the grammar are not
considered acceptable if a line terminator character appears in certain “awkward” places.

Parsing the same String multiple times will lead to different Parse Nodes. For example, consider:

Each call to

eval

converts the value of

str

into an ECMAScript source text and performs an

independent parse that creates its own separate tree of Parse Nodes. The trees are distinct even
though each parse operates upon a source text that was derived from the same String value.

let

str =

"1 + 1;"

;

eval

(str);

eval

(str);

Parse Nodes are specification artefacts, and implementations are not required to use an
analogous data structure.

5.1.4 The Syntactic Grammar

In certain cases, in order to avoid ambiguities, the syntactic grammar uses generalized productions that permit token
sequences that do not form a valid ECMAScript

. For example, this technique is used for object literals

and object destructuring patterns. In such cases a more restrictive

supplemental grammar

is provided that further

restricts the acceptable token sequences. Typically, an

early error

rule will then define an error condition if "

is not

covering

", where

is a Parse Node (an instance of the generalized production) and

is a nonterminal from the

supplemental grammar. Here, the sequence of tokens originally matched by

is parsed again using

takes grammatical parameters, then they are set to the same values used when

was originally parsed.)

An error occurs if the sequence of tokens cannot be parsed as a single instance of

, with no tokens left over.

Subsequently, algorithms access the result of the parse using a phrase of the form "the

that is

covered

". This will

always be a Parse Node (an instance of

, unique for a given

), since any parsing failure would have been detected

by an

early error

rule.

Terminal symbols are shown in

fixed width

font, both in the productions of the grammars and throughout this

specification whenever the text directly refers to such a terminal symbol. These are to appear in a script exactly as
written. All terminal symbol code points specified in this way are to be understood as the appropriate Unicode code
points from the Basic Latin range, as opposed to any similar-looking code points from other Unicode ranges. A code
point in a terminal symbol cannot be expressed by a

UnicodeEscapeSequence

Nonterminal symbols are shown in

italic

type. The definition of a nonterminal (also called a “production”) is

introduced by the name of the nonterminal being defined followed by one or more colons. (The number of colons
indicates to which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal
then follow on succeeding lines. For example, the syntactic definition:

WhileStatement

while

(

)

states that the nonterminal

WhileStatement

represents the token

while

, followed by a left parenthesis token, followed

by an

, followed by a right parenthesis token, followed by a

. The occurrences of

and

are themselves nonterminals. As another example, the syntactic definition:

AssignmentExpression
ArgumentList

states that an

may represent either a single

or an

, followed by a

comma, followed by an

. This definition of

is recursive, that is, it is defined in terms

of itself. The result is that an

may contain any positive number of arguments, separated by commas,

where each argument expression is an

BindingIdentifier
BindingIdentifier

. Such recursive definitions of nonterminals are common.

The subscripted suffix “

opt

”, which may appear after a terminal or nonterminal, indicates an optional symbol. The

alternative containing the optional symbol actually specifies two right-hand sides, one that omits the optional element
and one that includes it. This means that:

VariableDeclaration

BindingIdentifier

Initializer

opt

is a convenient abbreviation for:

5.1.5 Grammar Notation

VariableDeclaration

Initializer

and that:

for

(

opt

;

opt

)

is a convenient abbreviation for:

for

(

;

)

for

(

;

opt

)

which in turn is an abbreviation for:

for

(

;

)

for

(

;

)

for

(

;

)

for

(

;

)

so, in this example, the nonterminal

actually has four alternative right-hand sides.

A production may be parameterized by a subscripted annotation of the form “

[parameters]

”, which may appear as a

suffix to the nonterminal symbol defined by the production. “

parameters

” may be either a single name or a comma

separated list of names. A parameterized production is shorthand for a set of productions defining all combinations of
the parameter names, preceded by an underscore, appended to the parameterized nonterminal symbol. This means
that:

StatementList

[Return]

is a convenient abbreviation for:

StatementList

StatementList_Return

and that:

StatementList

[Return, In]