es6-grammar.md

ES6 Grammar

Generated using http://github.com/rbuckton/grammarkdown

SourceCharacter ::
any Unicode code point

InputElementDiv ::
WhiteSpace
LineTerminator
Comment
CommonToken
DivPunctuator
RightBracePunctuator

InputElementRegExp ::
WhiteSpace
LineTerminator
Comment
CommonToken
RightBracePunctuator
RegularExpressionLiteral

InputElementRegExpOrTemplateTail ::
WhiteSpace
LineTerminator
Comment
CommonToken
RegularExpressionLiteral
TemplateSubstitutionTail

InputElementTemplateTail ::
WhiteSpace
LineTerminator
Comment
CommonToken
DivPunctuator
TemplateSubstitutionTail

WhiteSpace ::
<TAB>
<VT>
<FF>
<SP>
<NBSP>
<ZWNBSP>
<USP>

LineTerminator ::
<LF>
<CR>
<LS>
<PS>

LineTerminatorSequence ::
<LF>
<CR> [lookahead ≠ <LF>]
<LS>
<PS>
<CR> <LF>

Comment ::
MultiLineComment
SingleLineComment

MultiLineComment ::
/* MultiLineCommentChars_opt */

MultiLineCommentChars ::
MultiLineNotAsteriskChar MultiLineCommentChars_opt
* PostAsteriskCommentChars_opt

PostAsteriskCommentChars ::
MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentChars_opt
* PostAsteriskCommentChars_opt

MultiLineNotAsteriskChar ::
SourceCharacter but not *

MultiLineNotForwardSlashOrAsteriskChar ::
SourceCharacter but not one of / or *

SingleLineComment ::
// SingleLineCommentChars_opt

SingleLineCommentChars ::
SingleLineCommentChar SingleLineCommentChars_opt

SingleLineCommentChar ::
SourceCharacter but not LineTerminator

CommonToken ::
IdentifierName
Punctuator
NumericLiteral
StringLiteral
Template

IdentifierName ::
IdentifierStart
IdentifierName IdentifierPart

IdentifierStart ::
UnicodeIDStart
$
_
\ UnicodeEscapeSequence

IdentifierPart ::
UnicodeIDContinue
$
_
\ UnicodeEscapeSequence
<ZWNJ>
<ZWJ>

UnicodeIDStart ::
any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"

UnicodeIDContinue ::
any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"

ReservedWord ::
Keyword
FutureReservedWord
NullLiteral
BooleanLiteral

Keyword :: one of

   break      do         in         typeof     case  
   else       instanceof var        catch      export  
   new        void       class      extends    return  
   while      const      finally    super      with  
   continue   for        switch     yield      debugger  
   function   this       default    if         throw  
   delete     import     try

FutureReservedWord :: one of

   enum       await      implements package    protected  
   interface  private    public

Punctuator :: one of

   {     }     (     )     [     ]     .     ;     ,     <  
   >     <=    >=    ==    !=    ===   !==   +     -     *  
   %     ++    --    <<    >>    >>>   &     |     ^     !  
   ~     &&    ||    ?      ::   =     +=    -=    *=    %=  
   <<=   >>=   >>>=  &=    |=    ^=    =>

DivPunctuator :: one of

   /     /=

RightBracePunctuator :: one of

NullLiteral ::
null

BooleanLiteral ::
true
false

NumericLiteral ::
DecimalLiteral
BinaryIntegerLiteral
OctalIntegerLiteral
HexIntegerLiteral

DecimalLiteral ::
DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt
. DecimalDigits ExponentPart_opt
DecimalIntegerLiteral ExponentPart_opt

DecimalIntegerLiteral ::
0
NonZeroDigit DecimalDigits_opt

DecimalDigits ::
DecimalDigit
DecimalDigits DecimalDigit

DecimalDigit :: one of

   0     1     2     3     4     5     6     7     8     9

NonZeroDigit :: one of

   1     2     3     4     5     6     7     8     9

ExponentPart ::
ExponentIndicator SignedInteger

ExponentIndicator :: one of

   e     E

SignedInteger ::
DecimalDigits
+ DecimalDigits
- DecimalDigits

BinaryIntegerLiteral ::
0b BinaryDigits
0B BinaryDigits

BinaryDigits ::
BinaryDigit
BinaryDigits BinaryDigit

BinaryDigit :: one of

   0     1

OctalIntegerLiteral ::
0o OctalDigits
0O OctalDigits

OctalDigits ::
OctalDigit
OctalDigits OctalDigit

OctalDigit :: one of

   0     1     2     3     4     5     6     7

HexIntegerLiteral ::
0x HexDigits
0X HexDigits

HexDigits ::
HexDigit
HexDigits HexDigit

HexDigit :: one of

   0     1     2     3     4     5     6     7     8     9  
   a     b     c     d     e     f     A     B     C     D  
   E     F

StringLiteral ::
" DoubleStringCharacters_opt "
' SingleStringCharacters_opt '

DoubleStringCharacters ::
DoubleStringCharacter DoubleStringCharacters_opt

SingleStringCharacters ::
SingleStringCharacter SingleStringCharacters_opt

DoubleStringCharacter ::
SourceCharacter but not one of " or \ or LineTerminator
\ EscapeSequence
LineContinuation

SingleStringCharacter ::
SourceCharacter but not one of ' or \ or LineTerminator
\ EscapeSequence
LineContinuation

LineContinuation ::
\ LineTerminatorSequence

EscapeSequence ::
CharacterEscapeSequence
0 [lookahead ≠ DecimalDigit]
HexEscapeSequence
UnicodeEscapeSequence

CharacterEscapeSequence ::
SingleEscapeCharacter
NonEscapeCharacter

SingleEscapeCharacter :: one of

   '     "     \     b     f     n     r     t     v

NonEscapeCharacter ::
SourceCharacter but not one of EscapeCharacter or LineTerminator

EscapeCharacter ::
SingleEscapeCharacter
DecimalDigit
x
u

HexEscapeSequence ::
x HexDigit HexDigit

UnicodeEscapeSequence ::
u Hex4Digits
u{ HexDigits }

Hex4Digits ::
HexDigit HexDigit HexDigit HexDigit

RegularExpressionLiteral ::
/ RegularExpressionBody / RegularExpressionFlags

RegularExpressionBody ::
RegularExpressionFirstChar RegularExpressionChars

RegularExpressionChars ::
[empty]
RegularExpressionChars RegularExpressionChar

RegularExpressionFirstChar ::
RegularExpressionNonTerminator but not one of * or \ or / or [
RegularExpressionBackslashSequence
RegularExpressionClass

RegularExpressionChar ::
RegularExpressionNonTerminator but not one of \ or / or [
RegularExpressionBackslashSequence
RegularExpressionClass

RegularExpressionBackslashSequence ::
\ RegularExpressionNonTerminator

RegularExpressionNonTerminator ::
SourceCharacter but not LineTerminator

RegularExpressionClass ::
[ RegularExpressionClassChars ]

RegularExpressionClassChars ::
[empty]
RegularExpressionClassChars RegularExpressionClassChar

RegularExpressionClassChar ::
RegularExpressionNonTerminator but not one of ] or \
RegularExpressionBackslashSequence

RegularExpressionFlags ::
[empty]
RegularExpressionFlags IdentifierPart

Template ::
NoSubstitutionTemplate
TemplateHead

NoSubstitutionTemplate ::
` TemplateCharacters_opt `

TemplateHead ::
` TemplateCharacters_opt ${

TemplateSubstitutionTail ::
TemplateMiddle
TemplateTail

TemplateMiddle ::
} TemplateCharacters_opt ${

TemplateTail ::
} TemplateCharacters_opt `

TemplateCharacters ::
TemplateCharacter TemplateCharacters_opt

TemplateCharacter ::
$ [lookahead ≠ {]
\ EscapeSequence
LineContinuation
LineTerminatorSequence
SourceCharacter but not one of ` or \ or $ or LineTerminator

IdentifierReference_[Yield] :
Identifier
[~Yield] yield

BindingIdentifier_[Yield] :
Identifier
[~Yield] yield

LabelIdentifier_[Yield] :
Identifier
[~Yield] yield

Identifier :
IdentifierName but not ReservedWord

PrimaryExpression_[Yield] :
this
IdentifierReference_[?Yield]
Literal
ArrayLiteral_[?Yield]
ObjectLiteral_[?Yield]
FunctionExpression
ClassExpression_[?Yield]
GeneratorExpression
RegularExpressionLiteral
TemplateLiteral_[?Yield]
CoverParenthesizedExpressionAndArrowParameterList_[?Yield]

CoverParenthesizedExpressionAndArrowParameterList_[Yield] :
( Expression_{[In, ?Yield]} )
( )
( ... BindingIdentifier_[?Yield] )
( Expression_{[In, ?Yield]} , ... BindingIdentifier_[?Yield] )

Literal :
NullLiteral
BooleanLiteral
NumericLiteral
StringLiteral

ArrayLiteral_[Yield] :
[ Elision_opt ]
[ ElementList_[?Yield] ]
[ ElementList_[?Yield] , Elision_opt ]

ElementList_[Yield] :
Elision_opt AssignmentExpression_{[In, ?Yield]}
Elision_opt SpreadElement_[?Yield]
ElementList_[?Yield] , Elision_opt AssignmentExpression_{[In, ?Yield]}
ElementList_[?Yield] , Elision_opt SpreadElement_[?Yield]

Elision :
,
Elision ,

SpreadElement_[Yield] :
... AssignmentExpression_{[In, ?Yield]}

ObjectLiteral_[Yield] :
{ }
{ PropertyDefinitionList_[?Yield] }
{ PropertyDefinitionList_[?Yield] , }

PropertyDefinitionList_[Yield] :
PropertyDefinition_[?Yield]
PropertyDefinitionList_[?Yield] , PropertyDefinition_[?Yield]

PropertyDefinition_[Yield] :
IdentifierReference_[?Yield]
CoverInitializedName_[?Yield]
PropertyName_[?Yield] : AssignmentExpression_{[In, ?Yield]}
MethodDefinition_[?Yield]

PropertyName_[Yield] :
LiteralPropertyName
ComputedPropertyName_[?Yield]

LiteralPropertyName :
IdentifierName
StringLiteral
NumericLiteral

ComputedPropertyName_[Yield] :
[ AssignmentExpression_{[In, ?Yield]} ]

CoverInitializedName_[Yield] :
IdentifierReference_[?Yield] Initializer_{[In, ?Yield]}

Initializer_{[In, Yield]} :
= AssignmentExpression_{[?In, ?Yield]}

TemplateLiteral_[Yield] :
NoSubstitutionTemplate
TemplateHead Expression_{[In, ?Yield]} TemplateSpans_[?Yield]

TemplateSpans_[Yield] :
TemplateTail
TemplateMiddleList_[?Yield] TemplateTail

TemplateMiddleList_[Yield] :
TemplateMiddle Expression_{[In, ?Yield]}
TemplateMiddleList_[?Yield] TemplateMiddle Expression_{[In, ?Yield]}

MemberExpression_[Yield] :
PrimaryExpression_[?Yield]
MemberExpression_[?Yield] [ Expression_{[In, ?Yield]} ]
MemberExpression_[?Yield] . IdentifierName
MemberExpression_[?Yield] TemplateLiteral_[?Yield]
SuperProperty_[?Yield]
MetaProperty
new MemberExpression_[?Yield] Arguments_[?Yield]

SuperProperty_[Yield] :
super [ Expression_{[In, ?Yield]} ]
super . IdentifierName

MetaProperty :
NewTarget

NewTarget :
new . target

NewExpression_[Yield] :
MemberExpression_[?Yield]
new NewExpression_[?Yield]

CallExpression_[Yield] :
MemberExpression_[?Yield] Arguments_[?Yield]
SuperCall_[?Yield]
CallExpression_[?Yield] Arguments_[?Yield]
CallExpression_[?Yield] [ Expression_{[In, ?Yield]} ]
CallExpression_[?Yield] . IdentifierName
CallExpression_[?Yield] TemplateLiteral_[?Yield]

SuperCall_[Yield] :
super Arguments_[?Yield]

Arguments_[Yield] :
( )
( ArgumentList_[?Yield] )

ArgumentList_[Yield] :
AssignmentExpression_{[In, ?Yield]}
... AssignmentExpression_{[In, ?Yield]}
ArgumentList_[?Yield] , AssignmentExpression_{[In, ?Yield]}
ArgumentList_[?Yield] , ... AssignmentExpression_{[In, ?Yield]}

LeftHandSideExpression_[Yield] :
NewExpression_[?Yield]
CallExpression_[?Yield]

PostfixExpression_[Yield] :
LeftHandSideExpression_[?Yield]
LeftHandSideExpression_[?Yield] [no LineTerminator here] ++
LeftHandSideExpression_[?Yield] [no LineTerminator here] --

UnaryExpression_[Yield] :
PostfixExpression_[?Yield]
delete UnaryExpression_[?Yield]
void UnaryExpression_[?Yield]
typeof UnaryExpression_[?Yield]
++ UnaryExpression_[?Yield]
-- UnaryExpression_[?Yield]
+ UnaryExpression_[?Yield]
- UnaryExpression_[?Yield]
~ UnaryExpression_[?Yield]
! UnaryExpression_[?Yield]

MultiplicativeExpression_[Yield] :
UnaryExpression_[?Yield]
MultiplicativeExpression_[?Yield] MultiplicativeOperator UnaryExpression_[?Yield]

MultiplicativeOperator : one of

   *     /     %

AdditiveExpression_[Yield] :
MultiplicativeExpression_[?Yield]
AdditiveExpression_[?Yield] + MultiplicativeExpression_[?Yield]
AdditiveExpression_[?Yield] - MultiplicativeExpression_[?Yield]

ShiftExpression_[Yield] :
AdditiveExpression_[?Yield]
ShiftExpression_[?Yield] << AdditiveExpression_[?Yield]
ShiftExpression_[?Yield] >> AdditiveExpression_[?Yield]
ShiftExpression_[?Yield] >>> AdditiveExpression_[?Yield]

RelationalExpression_{[In, Yield]} :
ShiftExpression_[?Yield]
RelationalExpression_{[?In, ?Yield]} < ShiftExpression_[?Yield]
RelationalExpression_{[?In, ?Yield]} > ShiftExpression_[?Yield]
RelationalExpression_{[?In, ?Yield]} <= ShiftExpression_[?Yield]
RelationalExpression_{[?In, ?Yield]} >= ShiftExpression_[?Yield]
RelationalExpression_{[?In, ?Yield]} instanceof ShiftExpression_[?Yield]
[+In] RelationalExpression_{[In, ?Yield]} in ShiftExpression_[?Yield]

EqualityExpression_{[In, Yield]} :
RelationalExpression_{[?In, ?Yield]}
EqualityExpression_{[?In, ?Yield]} == RelationalExpression_{[?In, ?Yield]}
EqualityExpression_{[?In, ?Yield]} != RelationalExpression_{[?In, ?Yield]}
EqualityExpression_{[?In, ?Yield]} === RelationalExpression_{[?In, ?Yield]}
EqualityExpression_{[?In, ?Yield]} !== RelationalExpression_{[?In, ?Yield]}

BitwiseANDExpression_{[In, Yield]} :
EqualityExpression_{[?In, ?Yield]}
BitwiseANDExpression_{[?In, ?Yield]} & EqualityExpression_{[?In, ?Yield]}

BitwiseXORExpression_{[In, Yield]} :
BitwiseANDExpression_{[?In, ?Yield]}
BitwiseXORExpression_{[?In, ?Yield]} ^ BitwiseANDExpression_{[?In, ?Yield]}

BitwiseORExpression_{[In, Yield]} :
BitwiseXORExpression_{[?In, ?Yield]}
BitwiseORExpression_{[?In, ?Yield]} | BitwiseXORExpression_{[?In, ?Yield]}

LogicalANDExpression_{[In, Yield]} :
BitwiseORExpression_{[?In, ?Yield]}
LogicalANDExpression_{[?In, ?Yield]} && BitwiseORExpression_{[?In, ?Yield]}

LogicalORExpression_{[In, Yield]} :
LogicalANDExpression_{[?In, ?Yield]}
LogicalORExpression_{[?In, ?Yield]} || LogicalANDExpression_{[?In, ?Yield]}

ConditionalExpression_{[In, Yield]} :
LogicalORExpression_{[?In, ?Yield]}
LogicalORExpression_{[?In, ?Yield]} ? AssignmentExpression_{[In, ?Yield]} : AssignmentExpression_{[?In, ?Yield]}

AssignmentExpression_{[In, Yield]} :
ConditionalExpression_{[?In, ?Yield]}
[+Yield] YieldExpression_[?In]
ArrowFunction_{[?In, ?Yield]}
LeftHandSideExpression_[?Yield] = AssignmentExpression_{[?In, ?Yield]}
LeftHandSideExpression_[?Yield] AssignmentOperator AssignmentExpression_{[?In, ?Yield]}

AssignmentOperator : one of

   *=    /=    %=    +=    -=    <<=   >>=   >>>=  &=    ^=  
   |=

Expression_{[In, Yield]} :
AssignmentExpression_{[?In, ?Yield]}
Expression_{[?In, ?Yield]} , AssignmentExpression_{[?In, ?Yield]}

Statement_{[Yield, Return]} :
BlockStatement_{[?Yield, ?Return]}
VariableStatement_[?Yield]
EmptyStatement
ExpressionStatement_[?Yield]
IfStatement_{[?Yield, ?Return]}
BreakableStatement_{[?Yield, ?Return]}
ContinueStatement_[?Yield]
BreakStatement_[?Yield]
[+Return] ReturnStatement_[?Yield]
WithStatement_{[?Yield, ?Return]}
LabelledStatement_{[?Yield, ?Return]}
ThrowStatement_[?Yield]
TryStatement_{[?Yield, ?Return]}
DebuggerStatement

Declaration_[Yield] :
HoistableDeclaration_[?Yield]
ClassDeclaration_[?Yield]
LexicalDeclaration_{[In, ?Yield]}

HoistableDeclaration_{[Yield, Default]} :
FunctionDeclaration_{[?Yield, ?Default]}
GeneratorDeclaration_{[?Yield, ?Default]}

BreakableStatement_{[Yield, Return]} :
IterationStatement_{[?Yield, ?Return]}
SwitchStatement_{[?Yield, ?Return]}

BlockStatement_{[Yield, Return]} :
Block_{[?Yield, ?Return]}

Block_{[Yield, Return]} :
{ StatementList_{[?Yield, ?Return]}_opt }

StatementList_{[Yield, Return]} :
StatementListItem_{[?Yield, ?Return]}
StatementList_{[?Yield, ?Return]} StatementListItem_{[?Yield, ?Return]}

StatementListItem_{[Yield, Return]} :
Statement_{[?Yield, ?Return]}
Declaration_[?Yield]

LexicalDeclaration_{[In, Yield]} :
LetOrConst BindingList_{[?In, ?Yield]} ;

LetOrConst :
let
const

BindingList_{[In, Yield]} :
LexicalBinding_{[?In, ?Yield]}
BindingList_{[?In, ?Yield]} , LexicalBinding_{[?In, ?Yield]}

LexicalBinding_{[In, Yield]} :
BindingIdentifier_[?Yield] Initializer_{[?In, ?Yield]}_opt
BindingPattern_[?Yield] Initializer_{[?In, ?Yield]}

VariableStatement_[Yield] :
var VariableDeclarationList_{[In, ?Yield]} ;

VariableDeclarationList_{[In, Yield]} :
VariableDeclaration_{[?In, ?Yield]}
VariableDeclarationList_{[?In, ?Yield]} , VariableDeclaration_{[?In, ?Yield]}

VariableDeclaration_{[In, Yield]} :
BindingIdentifier_[?Yield] Initializer_{[?In, ?Yield]}_opt
BindingPattern_[?Yield] Initializer_{[?In, ?Yield]}

BindingPattern_[Yield] :
ObjectBindingPattern_[?Yield]
ArrayBindingPattern_[?Yield]

ObjectBindingPattern_[Yield] :
{ }
{ BindingPropertyList_[?Yield] }
{ BindingPropertyList_[?Yield] , }

ArrayBindingPattern_[Yield] :
[ Elision_opt BindingRestElement_[?Yield]_opt ]
[ BindingElementList_[?Yield] ]
[ BindingElementList_[?Yield] , Elision_opt BindingRestElement_[?Yield]_opt ]

BindingPropertyList_[Yield] :
BindingProperty_[?Yield]
BindingPropertyList_[?Yield] , BindingProperty_[?Yield]

BindingElementList_[Yield] :
BindingElisionElement_[?Yield]
BindingElementList_[?Yield] , BindingElisionElement_[?Yield]

BindingElisionElement_[Yield] :
Elision_opt BindingElement_[?Yield]

BindingProperty_[Yield] :
SingleNameBinding_[?Yield]
PropertyName_[?Yield] : BindingElement_[?Yield]

BindingElement_[Yield] :
SingleNameBinding_[?Yield]
BindingPattern_[?Yield] Initializer_{[In, ?Yield]}_opt

SingleNameBinding_[Yield] :
BindingIdentifier_[?Yield] Initializer_{[In, ?Yield]}_opt

BindingRestElement_[Yield] :
... BindingIdentifier_[?Yield]

EmptyStatement :
;

ExpressionStatement_[Yield] :
[lookahead ∉ { {, function, class, let [ }] Expression_{[In, ?Yield]} ;

IfStatement_{[Yield, Return]} :
if ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]} else Statement_{[?Yield, ?Return]}
if ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

IterationStatement_{[Yield, Return]} :
do Statement_{[?Yield, ?Return]} while ( Expression_{[In, ?Yield]} ) ;
while ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( [lookahead ∉ { let [ }] Expression_[?Yield]_opt ; Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}
for ( var VariableDeclarationList_[?Yield] ; Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}
for ( LexicalDeclaration_[?Yield] Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}
for ( [lookahead ∉ { let [ }] LeftHandSideExpression_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( var ForBinding_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( ForDeclaration_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( [lookahead ≠ let] LeftHandSideExpression_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( var ForBinding_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
for ( ForDeclaration_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

ForDeclaration_[Yield] :
LetOrConst ForBinding_[?Yield]

ForBinding_[Yield] :
BindingIdentifier_[?Yield]
BindingPattern_[?Yield]

ContinueStatement_[Yield] :
continue ;
continue [no LineTerminator here] LabelIdentifier_[?Yield] ;

BreakStatement_[Yield] :
break ;
break [no LineTerminator here] LabelIdentifier_[?Yield] ;

ReturnStatement_[Yield] :
return ;
return [no LineTerminator here] Expression_{[In, ?Yield]} ;

WithStatement_{[Yield, Return]} :
with ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

SwitchStatement_{[Yield, Return]} :
switch ( Expression_{[In, ?Yield]} ) CaseBlock_{[?Yield, ?Return]}

CaseBlock_{[Yield, Return]} :
{ CaseClauses_{[?Yield, ?Return]}_opt }
{ CaseClauses_{[?Yield, ?Return]}_opt DefaultClause_{[?Yield, ?Return]} CaseClauses_{[?Yield, ?Return]}_opt }

CaseClauses_{[Yield, Return]} :
CaseClause_{[?Yield, ?Return]}
CaseClauses_{[?Yield, ?Return]} CaseClause_{[?Yield, ?Return]}

CaseClause_{[Yield, Return]} :
case Expression_{[In, ?Yield]} : StatementList_{[?Yield, ?Return]}_opt

DefaultClause_{[Yield, Return]} :
default : StatementList_{[?Yield, ?Return]}_opt

LabelledStatement_{[Yield, Return]} :
LabelIdentifier_[?Yield] : LabelledItem_{[?Yield, ?Return]}

LabelledItem_{[Yield, Return]} :
Statement_{[?Yield, ?Return]}
FunctionDeclaration_[?Yield]

ThrowStatement_[Yield] :
throw [no LineTerminator here] Expression_{[In, ?Yield]} ;

TryStatement_{[Yield, Return]} :
try Block_{[?Yield, ?Return]} Catch_{[?Yield, ?Return]}
try Block_{[?Yield, ?Return]} Finally_{[?Yield, ?Return]}
try Block_{[?Yield, ?Return]} Catch_{[?Yield, ?Return]} Finally_{[?Yield, ?Return]}

Catch_{[Yield, Return]} :
catch ( CatchParameter_[?Yield] ) Block_{[?Yield, ?Return]}

Finally_{[Yield, Return]} :
finally Block_{[?Yield, ?Return]}

CatchParameter_[Yield] :
BindingIdentifier_[?Yield]
BindingPattern_[?Yield]

DebuggerStatement :
debugger ;

FunctionDeclaration_{[Yield, Default]} :
function BindingIdentifier_[?Yield] ( FormalParameters ) { FunctionBody }
[+Default] function ( FormalParameters ) { FunctionBody }

FunctionExpression :
function BindingIdentifier_opt ( FormalParameters ) { FunctionBody }

StrictFormalParameters_[Yield] :
FormalParameters_[?Yield]

FormalParameters_[Yield] :
[empty]
FormalParameterList_[?Yield]

FormalParameterList_[Yield] :
FunctionRestParameter_[?Yield]
FormalsList_[?Yield]
FormalsList_[?Yield] , FunctionRestParameter_[?Yield]

FormalsList_[Yield] :
FormalParameter_[?Yield]
FormalsList_[?Yield] , FormalParameter_[?Yield]

FunctionRestParameter_[Yield] :
BindingRestElement_[?Yield]

FormalParameter_[Yield] :
BindingElement_[?Yield]

FunctionBody_[Yield] :
FunctionStatementList_[?Yield]

FunctionStatementList_[Yield] :
StatementList_{[?Yield, Return]}_opt

ArrowFunction_{[In, Yield]} :
ArrowParameters_[?Yield] [no LineTerminator here] => ConciseBody_[?In]

ArrowParameters_[Yield] :
BindingIdentifier_[?Yield]
CoverParenthesizedExpressionAndArrowParameterList_[?Yield]

ConciseBody_[In] :
[lookahead ≠ {] AssignmentExpression_[?In]
{ FunctionBody }

MethodDefinition_[Yield] :
PropertyName_[?Yield] ( StrictFormalParameters ) { FunctionBody }
GeneratorMethod_[?Yield]
get PropertyName_[?Yield] ( ) { FunctionBody }
set PropertyName_[?Yield] ( PropertySetParameterList ) { FunctionBody }

PropertySetParameterList :
FormalParameter

GeneratorMethod_[Yield] :
* PropertyName_[?Yield] ( StrictFormalParameters_[Yield] ) { GeneratorBody }

GeneratorDeclaration_{[Yield, Default]} :
function * BindingIdentifier_[?Yield] ( FormalParameters_[Yield] ) { GeneratorBody }
[+Default] function * ( FormalParameters_[Yield] ) { GeneratorBody }

GeneratorExpression :
function * BindingIdentifier_[Yield]_opt ( FormalParameters_[Yield] ) { GeneratorBody }

GeneratorBody :
FunctionBody_[Yield]

YieldExpression_[In] :
yield
yield [no LineTerminator here] AssignmentExpression_{[?In, Yield]}
yield [no LineTerminator here] * AssignmentExpression_{[?In, Yield]}

ClassDeclaration_{[Yield, Default]} :
class BindingIdentifier_[?Yield] ClassTail_[?Yield]
[+Default] class ClassTail_[?Yield]

ClassExpression_[Yield] :
class BindingIdentifier_[?Yield]_opt ClassTail_[?Yield]

ClassTail_[Yield] :
ClassHeritage_[?Yield]_opt { ClassBody_[?Yield]_opt }

ClassHeritage_[Yield] :
extends LeftHandSideExpression_[?Yield]

ClassBody_[Yield] :
ClassElementList_[?Yield]

ClassElementList_[Yield] :
ClassElement_[?Yield]
ClassElementList_[?Yield] ClassElement_[?Yield]

ClassElement_[Yield] :
MethodDefinition_[?Yield]
static MethodDefinition_[?Yield]
;

Script :
ScriptBody_opt

ScriptBody :
StatementList

Module :
ModuleBody_opt

ModuleBody :
ModuleItemList

ModuleItemList :
ModuleItem
ModuleItemList ModuleItem

ModuleItem :
ImportDeclaration
ExportDeclaration
StatementListItem

ImportDeclaration :
import ImportClause FromClause ;
import ModuleSpecifier ;

ImportClause :
ImportedDefaultBinding
NameSpaceImport
NamedImports
ImportedDefaultBinding , NameSpaceImport
ImportedDefaultBinding , NamedImports

ImportedDefaultBinding :
ImportedBinding

NameSpaceImport :
* as ImportedBinding

NamedImports :
{ }
{ ImportsList }
{ ImportsList , }

FromClause :
from ModuleSpecifier

ImportsList :
ImportSpecifier
ImportsList , ImportSpecifier

ImportSpecifier :
ImportedBinding
IdentifierName as ImportedBinding

ModuleSpecifier :
StringLiteral

ImportedBinding :
BindingIdentifier

ExportDeclaration :
export * FromClause ;
export ExportClause FromClause ;
export ExportClause ;
export VariableStatement
export Declaration
export default HoistableDeclaration_[Default]
export default ClassDeclaration_[Default]
export default [lookahead ∉ { function, class }] AssignmentExpression_[In] ;

ExportClause :
{ }
{ ExportsList }
{ ExportsList , }

ExportsList :
ExportSpecifier
ExportsList , ExportSpecifier

ExportSpecifier :
IdentifierName
IdentifierName as IdentifierName

rjmcguire/es6-grammar.md

ES6 Grammar