JavaScript 2.0 Grammar

This LALR(1) grammar describes the syntax of the JavaScript 2.0 proposal. The starting nonterminal is Program. See also the description of the grammar notation.

Terminals

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

Reserved words: break case catch class const continue default delete do else eval extends false field final finally for function if import in instanceof new null package private protected public return super switch this throw true try typeof var while with

Future reserved words: abstract debugger enum export goto implements native static synchronized throws transient volatile

Non-reserved words: constructor getter method override setter traditional version

Expressions

Identifiers

Identifier ⇒

Identifier

| version

| override

| method

| getter

| setter

| traditional

| constructor

QualifiedIdentifier ⇒

Identifier

| QualifiedIdentifier :: Identifier

| ParenthesizedExpression :: Identifier

Primary Expressions

PrimaryExpression^normal ⇒

SimpleExpression

| FunctionExpression

| ObjectLiteral

PrimaryExpression^initial ⇒ SimpleExpression

SimpleExpression ⇒

null

| true

| false

| Number

| String

| this

| super

| QualifiedIdentifier

| RegularExpression

| ParenthesizedExpression

| ArrayLiteral

ParenthesizedExpression ⇒ ( Expression^{normal,allowIn} )

Function Expressions

FunctionExpression ⇒

AnonymousFunction

| NamedFunction

Object Literals

ObjectLiteral ⇒

{ }

| { FieldList }

FieldList ⇒

LiteralField

| FieldList , LiteralField

LiteralField ⇒ QualifiedIdentifier : AssignmentExpression^{normal,allowIn}

Array Literals

ArrayLiteral ⇒

[ ]

| [ ElementList ]

ElementList ⇒

LiteralElement

| ElementList , LiteralElement

LiteralElement ⇒ AssignmentExpression^{normal,allowIn}

Postfix Unary Operators

PostfixExpression^α ⇒

FullPostfixExpression^α

| ShortNewExpression

FullPostfixExpression^α ⇒

PrimaryExpression^α

| FullNewExpression

| FullPostfixExpression^α MemberOperator

| FullPostfixExpression^α Arguments

| PostfixExpression^α ++

| PostfixExpression^α --

| PostfixExpression^α !

| PostfixExpression^α ~

FullNewExpression ⇒ new FullNewSubexpression Arguments

ShortNewExpression ⇒ new ShortNewSubexpression

FullNewSubexpression ⇒

PrimaryExpression^normal

| FullNewSubexpression MemberOperator

| FullNewExpression

ShortNewSubexpression ⇒

FullNewSubexpression

| ShortNewExpression

MemberOperator ⇒

[ ArgumentList ]

| . QualifiedIdentifier

| . ParenthesizedExpression

Arguments ⇒ ( ArgumentList )

ArgumentList ⇒

«empty»

| ArgumentListPrefix

ArgumentListPrefix ⇒

AssignmentExpression^{normal,allowIn}

| ArgumentListPrefix , AssignmentExpression^{normal,allowIn}

Prefix Unary Operators

UnaryExpression^α ⇒

PostfixExpression^α

| delete PostfixExpression^normal

| typeof UnaryExpression^normal

| eval UnaryExpression^normal

| ++ PostfixExpression^normal

| -- PostfixExpression^normal

| + UnaryExpression^normal

| - UnaryExpression^normal

| ~ UnaryExpression^normal

| ! UnaryExpression^normal

Multiplicative Operators

MultiplicativeExpression^α ⇒

UnaryExpression^α

| MultiplicativeExpression^α * UnaryExpression^normal

| MultiplicativeExpression^α / UnaryExpression^normal

| MultiplicativeExpression^α % UnaryExpression^normal

Additive Operators

AdditiveExpression^α ⇒

MultiplicativeExpression^α

| AdditiveExpression^α + MultiplicativeExpression^normal

| AdditiveExpression^α - MultiplicativeExpression^normal

Bitwise Shift Operators

ShiftExpression^α ⇒

AdditiveExpression^α

| ShiftExpression^α << AdditiveExpression^normal

| ShiftExpression^α >> AdditiveExpression^normal

| ShiftExpression^α >>> AdditiveExpression^normal

Relational Operators

RelationalExpression^α,allowIn ⇒

ShiftExpression^α

| RelationalExpression^α,allowIn < ShiftExpression^normal

| RelationalExpression^α,allowIn > ShiftExpression^normal

| RelationalExpression^α,allowIn <= ShiftExpression^normal

| RelationalExpression^α,allowIn >= ShiftExpression^normal

| RelationalExpression^α,allowIn instanceof ShiftExpression^normal

| RelationalExpression^α,allowIn in ShiftExpression^normal

RelationalExpression^α,noIn ⇒

ShiftExpression^α

| RelationalExpression^α,noIn < ShiftExpression^normal

| RelationalExpression^α,noIn > ShiftExpression^normal

| RelationalExpression^α,noIn <= ShiftExpression^normal

| RelationalExpression^α,noIn >= ShiftExpression^normal

| RelationalExpression^α,noIn instanceof ShiftExpression^normal

Equality Operators

EqualityExpression^α,β ⇒

RelationalExpression^α,β

| EqualityExpression^α,β == RelationalExpression^normal,β

| EqualityExpression^α,β != RelationalExpression^normal,β

| EqualityExpression^α,β === RelationalExpression^normal,β

| EqualityExpression^α,β !== RelationalExpression^normal,β

Binary Bitwise Operators

BitwiseAndExpression^α,β ⇒

EqualityExpression^α,β

| BitwiseAndExpression^α,β & EqualityExpression^normal,β

BitwiseXorExpression^α,β ⇒

BitwiseAndExpression^α,β

| BitwiseXorExpression^α,β ^ BitwiseAndExpression^normal,β

BitwiseOrExpression^α,β ⇒

BitwiseXorExpression^α,β

| BitwiseOrExpression^α,β | BitwiseXorExpression^normal,β

Binary Logical Operators

LogicalAndExpression^α,β ⇒

BitwiseOrExpression^α,β

| LogicalAndExpression^α,β && BitwiseOrExpression^normal,β

LogicalOrExpression^α,β ⇒

LogicalAndExpression^α,β

| LogicalOrExpression^α,β || LogicalAndExpression^normal,β

Conditional Operator

ConditionalExpression^α,β ⇒

LogicalOrExpression^α,β

| LogicalOrExpression^α,β ? AssignmentExpression^normal,β : AssignmentExpression^normal,β

NonAssignmentExpression^α,β ⇒

LogicalOrExpression^α,β

| LogicalOrExpression^α,β ? NonAssignmentExpression^normal,β : NonAssignmentExpression^normal,β

Assignment Operators

AssignmentExpression^α,β ⇒

ConditionalExpression^α,β

| PostfixExpression^α = AssignmentExpression^normal,β

| PostfixExpression^α CompoundAssignment AssignmentExpression^normal,β

CompoundAssignment ⇒

*=

| /=

| %=

| +=

| -=

| <<=

| >>=

| >>>=

| &=

| ^=

| |=

Expressions

Expression^α,β ⇒

AssignmentExpression^α,β

| Expression^α,β , AssignmentExpression^normal,β

OptionalExpression ⇒

Expression^{normal,allowIn}

| «empty»

Type Expressions

TypeExpression^α,β ⇒ NonAssignmentExpression^α,β

Statements

Statement^δ,ω ⇒

CodeStatement^ω

| Definition^δ,ω

CodeStatement^ω ⇒

EmptyStatement^ω

| ExpressionStatement Semicolon^ω

| Block^block

| LabeledStatement^ω

| IfStatement^ω

| SwitchStatement

| DoStatement Semicolon^ω

| WhileStatement^ω

| ForStatement^ω

| WithStatement^ω

| ContinueStatement Semicolon^ω

| BreakStatement Semicolon^ω

| ReturnStatement Semicolon^ω

| ThrowStatement Semicolon^ω

| TryStatement

| ImportStatement^ω

Semicolon^abbrev ⇒

;

| «empty»

Semicolon^{abbrevNonEmpty} ⇒

;

| «empty»

Semicolon^{abbrevNoShortIf} ⇒

;

| «empty»

Semicolon^full ⇒ ;

Empty Statement

EmptyStatement^abbrev ⇒

;

| «empty»

EmptyStatement^{abbrevNonEmpty} ⇒ ;

EmptyStatement^{abbrevNoShortIf} ⇒

;

| «empty»

EmptyStatement^full ⇒ ;

Expression Statement

ExpressionStatement ⇒ Expression^{initial,allowIn}

Block

Block^δ ⇒ { Statements^δ }

Statements^δ ⇒

Statement^δ,abbrev

| StatementsPrefix^δ Statement^{δ,abbrevNonEmpty}

StatementsPrefix^δ ⇒

Statement^δ,full

| StatementsPrefix^δ Statement^δ,full

Labeled Statements

LabeledStatement^ω ⇒ Identifier : CodeStatement^ω

If Statement

IfStatement^abbrev ⇒

if ParenthesizedExpression CodeStatement^abbrev

| if ParenthesizedExpression CodeStatement^{abbrevNoShortIf} else CodeStatement^abbrev

IfStatement^{abbrevNonEmpty} ⇒

if ParenthesizedExpression CodeStatement^{abbrevNonEmpty}

| if ParenthesizedExpression CodeStatement^{abbrevNoShortIf} else CodeStatement^{abbrevNonEmpty}

IfStatement^full ⇒

if ParenthesizedExpression CodeStatement^full

| if ParenthesizedExpression CodeStatement^{abbrevNoShortIf} else CodeStatement^full

IfStatement^{abbrevNoShortIf} ⇒ if ParenthesizedExpression CodeStatement^{abbrevNoShortIf} else CodeStatement^{abbrevNoShortIf}

Switch Statement

SwitchStatement ⇒

switch ParenthesizedExpression { }

| switch ParenthesizedExpression { CaseGroups LastCaseGroup }

CaseGroups ⇒

«empty»

| CaseGroups CaseGroup

CaseGroup ⇒ CaseGuards CaseStatementsPrefix

LastCaseGroup ⇒ CaseGuards CaseStatements

CaseGuards ⇒

CaseGuard

| CaseGuards CaseGuard

CaseGuard ⇒

case Expression^{normal,allowIn} :

| default :

CaseStatements ⇒

CodeStatement^abbrev

| CaseStatementsPrefix CodeStatement^{abbrevNonEmpty}

CaseStatementsPrefix ⇒

CodeStatement^full

| CaseStatementsPrefix CodeStatement^full

Do-While Statement

DoStatement ⇒ do CodeStatement^{abbrevNonEmpty} while ParenthesizedExpression

While Statement

WhileStatement^ω ⇒ while ParenthesizedExpression CodeStatement^ω

For Statements

ForStatement^ω ⇒

for ( ForInitializer ; OptionalExpression ; OptionalExpression ) CodeStatement^ω

| for ( ForInBinding in Expression^{normal,allowIn} ) CodeStatement^ω

ForInitializer ⇒

«empty»

| Expression^normal,noIn

| VariableDefinitionKind VariableBindingList^noIn

ForInBinding ⇒

PostfixExpression^normal

| VariableDefinitionKind VariableBinding^noIn

With Statement

WithStatement^ω ⇒ with ParenthesizedExpression CodeStatement^ω

Continue and Break Statements

ContinueStatement ⇒ continue OptionalLabel

BreakStatement ⇒ break OptionalLabel

OptionalLabel ⇒

«empty»

| Identifier

Return Statement

ReturnStatement ⇒ return OptionalExpression

Throw Statement

ThrowStatement ⇒ throw Expression^{normal,allowIn}

Try Statement

TryStatement ⇒

try Block^block CatchClauses

| try Block^block FinallyClause

| try Block^block CatchClauses FinallyClause

CatchClauses ⇒

CatchClause

| CatchClauses CatchClause

CatchClause ⇒ catch ( TypedIdentifier^allowIn ) Block^block

FinallyClause ⇒ finally Block^block

Import Statement

ImportStatement^abbrev ⇒

import ImportList Semicolon^abbrev

| import ImportList Block^block

| import ImportList Block^block else CodeStatement^abbrev

ImportStatement^{abbrevNonEmpty} ⇒

import ImportList Semicolon^{abbrevNonEmpty}

| import ImportList Block^block

| import ImportList Block^block else CodeStatement^{abbrevNonEmpty}

ImportStatement^{abbrevNoShortIf} ⇒

import ImportList Semicolon^{abbrevNoShortIf}

| import ImportList Block^block else CodeStatement^{abbrevNoShortIf}

ImportStatement^full ⇒

import ImportList Semicolon^full

| import ImportList Block^block

| import ImportList Block^block else CodeStatement^full

ImportList ⇒

ImportItem

| ImportList , ImportItem

ImportItem ⇒

ImportSource

| Identifier = ImportSource

| protected Identifier = ImportSource

ImportSource ⇒

NonAssignmentExpression^normal,noIn

| NonAssignmentExpression^normal,noIn : Version

Definitions

Definition^δ,ω ⇒

Visibility GlobalDefinition^ω

| LocalDefinition^δ,ω

GlobalDefinition^ω ⇒

VersionDefinition Semicolon^ω

| VariableDefinition Semicolon^ω

| FunctionDefinition

| MemberDefinition^ω

| ClassDefinition

LocalDefinition^top,ω ⇒

VersionDefinition Semicolon^ω

| VariableDefinition Semicolon^ω

| FunctionDefinition

| ClassDefinition

LocalDefinition^class,ω ⇒

VariableDefinition Semicolon^ω

| FunctionDefinition

| MemberDefinition^ω

| ClassDefinition

LocalDefinition^block,ω ⇒

VariableDefinition Semicolon^ω

| FunctionDefinition

Visibility Specifications

Visibility ⇒

private

| package

| public VersionsAndRenames

VersionsAndRenames ⇒

«empty»

| < VersionRangesAndAliases >

VersionRangesAndAliases ⇒

«empty»

| VersionRangesAndAliasesPrefix

VersionRangesAndAliasesPrefix ⇒

VersionRangeAndAlias

| VersionRangesAndAliasesPrefix , VersionRangeAndAlias

VersionRangeAndAlias ⇒

VersionRange

| VersionRange : Identifier

VersionRange ⇒

Version

| OptionalVersion .. OptionalVersion

Versions

OptionalVersion ⇒

Version

| «empty»

Version ⇒

Number

| String

Version Definition

VersionDefinition ⇒

version Version

| version Version > VersionList

VersionList ⇒

Version

| VersionList , Version

Variable Definition

VariableDefinition ⇒ VariableDefinitionKind VariableBindingList^allowIn

VariableDefinitionKind ⇒

var

| const

VariableBindingList^β ⇒

VariableBinding^β

| VariableBindingList^β , VariableBinding^β

VariableBinding^β ⇒ TypedIdentifier^β VariableInitializer^β

TypedIdentifier^β ⇒

Identifier

| TypeExpression^normal,β Identifier

VariableInitializer^β ⇒

«empty»

| = AssignmentExpression^normal,β

Function Definition

FunctionDefinition ⇒

NamedFunction

| getter NamedFunction

| setter NamedFunction

| TraditionalFunction

AnonymousFunction ⇒ function FunctionSignature Block^block

NamedFunction ⇒ function Identifier FunctionSignature Block^block

FunctionSignature ⇒ ParameterSignature ResultSignature

ParameterSignature ⇒ ( Parameters )

Parameters ⇒

«empty»

| RestParameter

| RequiredParameters

| OptionalParameters

| RequiredParameters , RestParameter

| OptionalParameters , RestParameter

RequiredParameters ⇒

RequiredParameter

| RequiredParameters , RequiredParameter

OptionalParameters ⇒

OptionalParameter

| RequiredParameters , OptionalParameter

| OptionalParameters , OptionalParameter

RequiredParameter ⇒ TypedIdentifier^allowIn

OptionalParameter ⇒

TypedIdentifier^allowIn =

| TypedIdentifier^allowIn = AssignmentExpression^{normal,allowIn}

RestParameter ⇒

...

| ... Identifier

ResultSignature ⇒

«empty»

| TypeExpression^{initial,allowIn}

TraditionalFunction ⇒ traditional function Identifier ( TraditionalParameterList ) Block^block

TraditionalParameterList ⇒

«empty»

| TraditionalParameterListPrefix

TraditionalParameterListPrefix ⇒

Identifier

| TraditionalParameterListPrefix , Identifier

Class Member Definitions

MemberDefinition^ω ⇒

FieldDefinition Semicolon^ω

| MethodDefinition^ω

| ConstructorDefinition

FieldDefinition ⇒ field VariableBindingList^allowIn

MethodDefinition^ω ⇒

ConcreteMethodDefinition

| AbstractMethodDefinition^ω

ConcreteMethodDefinition ⇒ MethodPrefix Identifier FunctionSignature Block^block

AbstractMethodDefinition^ω ⇒ MethodPrefix Identifier FunctionSignature Semicolon^ω

MethodPrefix ⇒

MethodKind

| override MethodKind

| final MethodKind

| final override MethodKind

MethodKind ⇒

method

| getter method

| setter method

ConstructorDefinition ⇒ constructor ConstructorName ParameterSignature Block^block

ConstructorName ⇒

new

| Identifier

Class Definition

ClassDefinition ⇒

class Identifier Superclasses Block^class

| class extends TypeExpression^{initial,allowIn} Block^class

Terminals

Expressions

Identifiers

Primary Expressions

Function Expressions

Object Literals

Array Literals

Postfix Unary Operators

Prefix Unary Operators

Multiplicative Operators

Additive Operators

Bitwise Shift Operators

Relational Operators

Equality Operators

Binary Bitwise Operators

Binary Logical Operators

Conditional Operator

Assignment Operators

Expressions

Type Expressions

Statements

Empty Statement

Expression Statement

Block

Labeled Statements

If Statement

Switch Statement

Do-While Statement

While Statement

For Statements

With Statement

Continue and Break Statements

Return Statement

Throw Statement

Try Statement

Import Statement

Definitions

Visibility Specifications

Versions

Version Definition

Variable Definition

Function Definition

Class Member Definitions

Class Definition

Programs