Standardize grammar rule ordering: *_, *, *Opt.

[cycript.git] / Cycript.yy.in

diff --git a/Cycript.yy.in b/Cycript.yy.in
index 9c05469a3445eebc81fdba7f69e07e55e6934266..d8ec64a99c8fda07174b17c5e7bd0b4155700789 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -176,6 +176,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %token Percent "%"
 %token PercentEqual "%="
 %token Period "."
+%token PeriodPeriodPeriod "..."
 %token Pipe "|"
 %token PipeEqual "|="
 %token PipePipe "||"
@@ -318,23 +319,25 @@ int cylex(YYSTYPE *, cy::location *, void *);
 
 %type <expression_> AdditiveExpression
 %type <expression_> AdditiveExpressionNoBF
-%type <argument_> ArgumentList
 %type <argument_> ArgumentList_
+%type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <literal_> ArrayLiteral
 %type <expression_> AssigneeExpression
 %type <expression_> AssigneeExpressionNoBF
-%type <expression_> AssignmentExpression
 %type <assignment_> AssignmentExpression_
+%type <expression_> AssignmentExpression
 %type <expression_> AssignmentExpressionNoBF
 %type <expression_> AssignmentExpressionNoIn
+%type <identifier_> BindingIdentifier
 %type <expression_> BitwiseANDExpression
 %type <expression_> BitwiseANDExpressionNoBF
 %type <expression_> BitwiseANDExpressionNoIn
-%type <statement_> Block
 %type <statement_> Block_
+%type <statement_> Block
 %type <boolean_> BooleanLiteral
+%type <declaration_> BindingElement
 %type <expression_> BitwiseORExpression
 %type <expression_> BitwiseORExpressionNoBF
 %type <expression_> BitwiseORExpressionNoIn
@@ -342,6 +345,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> BitwiseXORExpressionNoBF
 %type <expression_> BitwiseXORExpressionNoIn
 %type <statement_> BreakStatement
+%type <statement_> BreakableStatement
 %type <expression_> CallExpression
 %type <expression_> CallExpressionNoBF
 %type <clause_> CaseBlock
@@ -354,6 +358,8 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> ConditionalExpressionNoBF
 %type <expression_> ConditionalExpressionNoIn
 %type <statement_> ContinueStatement
+%type <statement_> DebuggerStatement
+%type <statement_> Declaration
 %type <clause_> DefaultClause
 %type <statement_> DoWhileStatement
 %type <expression_> Element
@@ -365,12 +371,12 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> EqualityExpression
 %type <expression_> EqualityExpressionNoBF
 %type <expression_> EqualityExpressionNoIn
+%type <compound_> Expression_
 %type <expression_> Expression
 %type <expression_> ExpressionOpt
-%type <compound_> Expression_
 %type <expression_> ExpressionNoBF
-%type <expression_> ExpressionNoIn
 %type <compound_> ExpressionNoIn_
+%type <expression_> ExpressionNoIn
 %type <expression_> ExpressionNoInOpt
 %type <statement_> ExpressionStatement
 %type <finally_> FinallyOpt
@@ -379,8 +385,10 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <for_> ForStatementInitialiser
 %type <statement_> ForInStatement
 %type <forin_> ForInStatementInitialiser
-%type <functionParameter_> FormalParameterList
+%type <declaration_> FormalParameter
 %type <functionParameter_> FormalParameterList_
+%type <functionParameter_> FormalParameterList
+%type <functionParameter_> FormalParameterListOpt
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <expression_> FunctionExpression
@@ -396,7 +404,9 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <statement_> LabelledStatement
 %type <expression_> LeftHandSideExpression
 %type <expression_> LeftHandSideExpressionNoBF
-//%type <statement_> LetStatement
+//%type <expression_> LetExpression
+%type <statement_> LetStatement
+%type <statement_> LexicalDeclaration
 %type <literal_> Literal
 %type <literal_> LiteralNoRE
 %type <literal_> LiteralRE
@@ -407,13 +417,13 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> LogicalORExpressionNoBF
 %type <expression_> LogicalORExpressionNoIn
 %type <member_> MemberAccess
-%type <expression_> MemberExpression
 %type <expression_> MemberExpression_
+%type <expression_> MemberExpression
 %type <expression_> MemberExpressionNoBF
 %type <expression_> MultiplicativeExpression
 %type <expression_> MultiplicativeExpressionNoBF
-%type <expression_> NewExpression
 %type <expression_> NewExpression_
+%type <expression_> NewExpression
 %type <expression_> NewExpressionNoBF
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
@@ -425,44 +435,45 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> PrimaryExpressionNoRE
 %type <expression_> PrimaryExpressionBF
 %type <statement_> Program
-%type <propertyName_> PropertyName
+%type <statement_> ProgramBody
+%type <statement_> ProgramBodyOpt
 %type <propertyName_> PropertyName_
-%type <property_> PropertyNameAndValueList
+%type <propertyName_> PropertyName
 %type <property_> PropertyNameAndValueList_
+%type <property_> PropertyNameAndValueList
 %type <property_> PropertyNameAndValueListOpt
-%type <expression_> RelationalExpression
 %type <infix_> RelationalExpression_
+%type <expression_> RelationalExpression
 %type <expression_> RelationalExpressionNoBF
-%type <expression_> RelationalExpressionNoIn
 %type <infix_> RelationalExpressionNoIn_
+%type <expression_> RelationalExpressionNoIn
 %type <statement_> ReturnStatement
 %type <rubyProc_> RubyProcExpression
 %type <rubyProc_> RubyProcExpressionNoOA
-%type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameterList_
+%type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameters
 %type <functionParameter_> RubyProcParametersOpt
 %type <expression_> ShiftExpression
 %type <expression_> ShiftExpressionNoBF
-%type <statement_> SourceElement
-%type <statement_> SourceElement_
-%type <statement_> SourceElements
-%type <statement_> Statement
+%type <declaration_> SingleNameBinding
 %type <statement_> Statement_
+%type <statement_> Statement
 %type <statement_> StatementList
 %type <statement_> StatementListOpt
+%type <statement_> StatementListItem
 %type <statement_> SwitchStatement
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement
-%type <expression_> UnaryExpression
 %type <expression_> UnaryExpression_
+%type <expression_> UnaryExpression
 %type <expression_> UnaryExpressionNoBF
 %type <declaration_> VariableDeclaration
 %type <declaration_> VariableDeclarationNoIn
-%type <declarations_> VariableDeclarationList
 %type <declarations_> VariableDeclarationList_
-%type <declarations_> VariableDeclarationListNoIn
+%type <declarations_> VariableDeclarationList
 %type <declarations_> VariableDeclarationListNoIn_
+%type <declarations_> VariableDeclarationListNoIn
 %type <statement_> VariableStatement
 %type <statement_> WhileStatement
 %type <statement_> WithStatement
@@ -497,10 +508,10 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <messageParameter_> MessageParameterList
 %type <messageParameter_> MessageParameterListOpt
 %type <bool_> MessageScope
-%type <argument_> SelectorCall
 %type <argument_> SelectorCall_
-%type <selector_> SelectorExpression
+%type <argument_> SelectorCall
 %type <selector_> SelectorExpression_
+%type <selector_> SelectorExpression
 %type <selector_> SelectorExpressionOpt
 %type <argument_> SelectorList
 %type <word_> SelectorWordOpt
@@ -512,10 +523,10 @@ int cylex(YYSTYPE *, cy::location *, void *);
 
 @begin E4X
 %type <propertyIdentifier_> PropertyIdentifier_
-%type <selector_> PropertySelector
 %type <selector_> PropertySelector_
-%type <identifier_> QualifiedIdentifier
+%type <selector_> PropertySelector
 %type <identifier_> QualifiedIdentifier_
+%type <identifier_> QualifiedIdentifier
 %type <identifier_> WildcardIdentifier
 %type <identifier_> XMLComment
 %type <identifier_> XMLCDATA
@@ -576,14 +587,14 @@ Terminator_
     | "\n" StrictSemi
     ;
 
-TerminatorOpt
+Terminator
     : Terminator_
-    | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
+    | error { if (yychar != 0 && yychar != cy::parser::token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
     ;
 
-Terminator
+TerminatorOpt
     : Terminator_
-    | error { if (yychar != 0 && yychar != cy::parser::token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
+    | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
     ;
 
 /*CommaOpt
@@ -597,11 +608,6 @@ NewLineOpt
     |
     ;
 
-WordOpt
-    : Word { $$ = $1; }
-    | { $$ = NULL; }
-    ;
-
 Word
     : Identifier { $$ = $1; }
     | "break" NewLineOpt { $$ = $1; }
@@ -642,6 +648,11 @@ Word
     | "with" { $$ = $1; }
     ;
 
+WordOpt
+    : Word { $$ = $1; }
+    | { $$ = NULL; }
+    ;
+
 PrimaryExpressionNo
     : "@" LiteralNoRE { $$ = CYNew CYBox($2); }
     | "@" ArrayLiteral { $$ = CYNew CYBox($2); }
@@ -678,7 +689,7 @@ Identifier
     | "transient" { $$ = $1; }
     | "volatile" { $$ = $1; }
 
-    | "let" { $$ = $1; }
+    // XXX: is this allowed?! | "let" { $$ = $1; }
     | "yield" { $$ = $1; }
 
     | "each" { $$ = $1; }
@@ -755,15 +766,15 @@ ElementOpt
     | LexSetRegExp { $$ = NULL; }
     ;
 
-ElementListOpt
-    : ElementList { $$ = $1; }
-    | LexSetRegExp { $$ = NULL; }
-    ;
-
 ElementList
     : ElementOpt "," ElementListOpt { $$ = CYNew CYElement($1, $3); }
     | Element { $$ = CYNew CYElement($1, NULL); }
     ;
+
+ElementListOpt
+    : ElementList { $$ = $1; }
+    | LexSetRegExp { $$ = NULL; }
+    ;
 /* }}} */
 /* 11.1.5 Object Initialiser {{{ */
 ObjectLiteral
@@ -775,15 +786,15 @@ PropertyNameAndValueList_
     | { $$ = NULL; }
     ;
 
+PropertyNameAndValueList
+    : PropertyName ":" AssignmentExpression PropertyNameAndValueList_ { $$ = CYNew CYProperty($1, $3, $4); }
+    ;
+
 PropertyNameAndValueListOpt
     : PropertyNameAndValueList { $$ = $1; }
     | { $$ = NULL; }
     ;
 
-PropertyNameAndValueList
-    : PropertyName ":" AssignmentExpression PropertyNameAndValueList_ { $$ = CYNew CYProperty($1, $3, $4); }
-    ;
-
 PropertyName_
     : Identifier { $$ = $1; }
     | StringLiteral { $$ = $1; }
@@ -796,16 +807,16 @@ PropertyName
 /* }}} */
 
 /* 11.2 Left-Hand-Side Expressions {{{ */
-MemberExpression_
-    : "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($2, $3); }
-    ;
-
 MemberAccess
     : "[" Expression "]" { $$ = CYNew CYDirectMember(NULL, $2); }
     | "." Identifier { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
     | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
     ;
 
+MemberExpression_
+    : "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($2, $3); }
+    ;
+
 MemberExpression
     : PrimaryExpression { $$ = $1; }
     | LexSetRegExp FunctionExpression { $$ = $2; }
@@ -874,15 +885,15 @@ ArgumentList_
     | { $$ = NULL; }
     ;
 
+ArgumentList
+    : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }
+    ;
+
 ArgumentListOpt
     : ArgumentList { $$ = $1; }
     | LexSetRegExp { $$ = NULL; }
     ;
 
-ArgumentList
-    : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }
-    ;
-
 Arguments
     : "(" ArgumentListOpt ")" { $$ = $2; }
     ;
@@ -1001,14 +1012,6 @@ ShiftExpressionNoBF
     ;
 /* }}} */
 /* 11.8 Relational Operators {{{ */
-RelationalExpressionNoIn_
-    : "<" ShiftExpression { $$ = CYNew CYLess(NULL, $2); }
-    | ">" ShiftExpression { $$ = CYNew CYGreater(NULL, $2); }
-    | "<=" ShiftExpression { $$ = CYNew CYLessOrEqual(NULL, $2); }
-    | ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual(NULL, $2); }
-    | "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf(NULL, $2); }
-    ;
-
 RelationalExpression_
     : RelationalExpressionNoIn_ { $$ = $1; }
     | "in" ShiftExpression { $$ = CYNew CYIn(NULL, $2); }
@@ -1019,6 +1022,14 @@ RelationalExpression
     | RelationalExpression RelationalExpression_ { $2->SetLeft($1); $$ = $2; }
     ;
 
+RelationalExpressionNoIn_
+    : "<" ShiftExpression { $$ = CYNew CYLess(NULL, $2); }
+    | ">" ShiftExpression { $$ = CYNew CYGreater(NULL, $2); }
+    | "<=" ShiftExpression { $$ = CYNew CYLessOrEqual(NULL, $2); }
+    | ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual(NULL, $2); }
+    | "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf(NULL, $2); }
+    ;
+
 RelationalExpressionNoIn
     : ShiftExpression { $$ = $1; }
     | RelationalExpressionNoIn RelationalExpressionNoIn_ { $2->SetLeft($1); $$ = $2; }
@@ -1216,9 +1227,8 @@ Expression_
     | { $$ = NULL; }
     ;
 
-ExpressionNoIn_
-    : "," ExpressionNoIn { $$ = CYNew CYCompound($2); }
-    | { $$ = NULL; }
+Expression
+    : AssignmentExpression Expression_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; }
     ;
 
 ExpressionOpt
@@ -1226,19 +1236,20 @@ ExpressionOpt
     | LexSetRegExp { $$ = NULL; }
     ;
 
-ExpressionNoInOpt
-    : ExpressionNoIn { $$ = $1; }
-    | LexSetRegExp { $$ = NULL; }
-    ;
-
-Expression
-    : AssignmentExpression Expression_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; }
+ExpressionNoIn_
+    : "," ExpressionNoIn { $$ = CYNew CYCompound($2); }
+    | { $$ = NULL; }
     ;
 
 ExpressionNoIn
     : AssignmentExpressionNoIn ExpressionNoIn_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; }
     ;
 
+ExpressionNoInOpt
+    : ExpressionNoIn { $$ = $1; }
+    | LexSetRegExp { $$ = NULL; }
+    ;
+
 ExpressionNoBF
     : AssignmentExpressionNoBF Expression_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; }
     ;
@@ -1251,20 +1262,30 @@ Statement_
     | EmptyStatement { $$ = $1; }
     | ExpressionStatement { $$ = $1; }
     | IfStatement { $$ = $1; }
-    | IterationStatement { $$ = $1; }
+    | BreakableStatement { $$ = $1; }
     | ContinueStatement { $$ = $1; }
     | BreakStatement { $$ = $1; }
     | ReturnStatement { $$ = $1; }
     | WithStatement { $$ = $1; }
     | LabelledStatement { $$ = $1; }
-    | SwitchStatement { $$ = $1; }
     | ThrowStatement { $$ = $1; }
     | TryStatement { $$ = $1; }
+    | DebuggerStatement { $$ = $1; }
     ;
 
 Statement
     : LexSetRegExp Statement_ { $$ = $2; }
     ;
+
+Declaration
+    : FunctionDeclaration { $$ = $1; }
+    | LexicalDeclaration { $$ = $1; }
+    ;
+
+BreakableStatement
+    : IterationStatement { $$ = $1; }
+    | SwitchStatement { $$ = $1; }
+    ;
 /* }}} */
 /* 12.1 Block {{{ */
 Block_
@@ -1276,15 +1297,37 @@ Block
     ;
 
 StatementList
-    : Statement StatementListOpt { $1->SetNext($2); $$ = $1; }
+    : StatementListItem StatementListOpt { $1->SetNext($2); $$ = $1; }
     ;
 
 StatementListOpt
     : StatementList { $$ = $1; }
     | LexSetRegExp { $$ = NULL; }
     ;
+
+StatementListItem
+    : Statement { $$ = $1; }
+    | LexSetRegExp Declaration { $$ = $2; }
+    ;
 /* }}} */
-/* 12.2 Variable Statement {{{ */
+/* 12.2 Declarations {{{ */
+BindingIdentifier
+    : Identifier { $$ = $1; }
+    ;
+
+// XXX: BindingPattern
+/* }}} */
+/* 12.2.1 Let and Const Declarations {{{ */
+LexicalDeclaration
+    : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
+    ;
+
+LetOrConst
+    : "let"
+    | "const"
+    ;
+/* }}} */
+/* 12.2.2 Variable Statement {{{ */
 VariableStatement
     : "var" VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
     ;
@@ -1294,25 +1337,31 @@ VariableDeclarationList_
     | { $$ = NULL; }
     ;
 
+VariableDeclarationList
+    : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); }
+    ;
+
 VariableDeclarationListNoIn_
     : "," VariableDeclarationListNoIn { $$ = $2; }
     | { $$ = NULL; }
     ;
 
-VariableDeclarationList
-    : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); }
-    ;
-
 VariableDeclarationListNoIn
     : VariableDeclarationNoIn VariableDeclarationListNoIn_ { $$ = CYNew CYDeclarations($1, $2); }
     ;
 
 VariableDeclaration
-    : Identifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
+    : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
+    // XXX: | BindingPattern Initialiser { $$ = CYNew CYDeclaration($1, $2); }
     ;
 
 VariableDeclarationNoIn
-    : Identifier InitialiserNoInOpt { $$ = CYNew CYDeclaration($1, $2); }
+    : BindingIdentifier InitialiserNoInOpt { $$ = CYNew CYDeclaration($1, $2); }
+    // XXX: | BindingPattern InitialiserNoIn { $$ = CYNew CYDeclaration($1, $2); }
+    ;
+
+Initialiser
+    : "=" AssignmentExpression { $$ = $2; }
     ;
 
 InitialiserOpt
@@ -1320,17 +1369,24 @@ InitialiserOpt
     | { $$ = NULL; }
     ;
 
+InitialiserNoIn
+    : "=" AssignmentExpressionNoIn { $$ = $2; }
+    ;
+
 InitialiserNoInOpt
     : InitialiserNoIn { $$ = $1; }
     | { $$ = NULL; }
     ;
+/* }}} */
+/* 12.2.4 Destructuring Binding Patterns {{{ */
+// XXX: *
 
-Initialiser
-    : "=" AssignmentExpression { $$ = $2; }
+BindingElement
+    : SingleNameBinding { $$ = $1; }
     ;
 
-InitialiserNoIn
-    : "=" AssignmentExpressionNoIn { $$ = $2; }
+SingleNameBinding
+    : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
     ;
 /* }}} */
 /* 12.3 Empty Statement {{{ */
@@ -1379,7 +1435,7 @@ ForStatement
 
 ForStatementInitialiser
     : ExpressionNoInOpt { $$ = $1; }
-    | LexSetRegExp "var" VariableDeclarationListNoIn { $$ = $3; }
+    | LexSetRegExp "var" VariableDeclarationListNoIn { $$ = CYNew CYForDeclarations($3); }
     ;
 /* }}} */
 /* 12.6.4 The for-in Statement {{{ */
@@ -1423,16 +1479,16 @@ CaseBlock
     : Brace CaseClausesOpt "}" { $$ = $2; }
     ;
 
+CaseClause
+    : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); }
+    ;
+
 CaseClausesOpt
     : CaseClause CaseClausesOpt { $1->SetNext($2); $$ = $1; }
     | DefaultClause CaseClausesOpt { $1->SetNext($2); $$ = $1; }
     | { $$ = NULL; }
     ;
 
-CaseClause
-    : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); }
-    ;
-
 DefaultClause
     : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
     ;
@@ -1462,14 +1518,19 @@ FinallyOpt
     | { $$ = NULL; }
     ;
 /* }}} */
+/* 12.14 The debugger Statement {{{ */
+DebuggerStatement
+    : "debugger" Terminator { $$ = CYNew CYDebugger(); }
+    ;
+/* }}} */
 
 /* 13 Function Definition {{{ */
 FunctionDeclaration
-    : "function" Identifier "(" FormalParameterList ")" Brace FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
+    : "function" Identifier "(" FormalParameterListOpt ")" Brace FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
     ;
 
 FunctionExpression
-    : "function" IdentifierOpt "(" FormalParameterList ")" Brace FunctionBody "}" { $$ = CYNew CYFunctionExpression($2, $4, $7); }
+    : "function" IdentifierOpt "(" FormalParameterListOpt ")" Brace FunctionBody "}" { $$ = CYNew CYFunctionExpression($2, $4, $7); }
     ;
 
 FormalParameterList_
@@ -1478,31 +1539,39 @@ FormalParameterList_
     ;
 
 FormalParameterList
-    : Identifier FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
+    // XXX: : FunctionRestParameter { $$ = $1; }
+    : FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
+    ;
+
+FormalParameterListOpt
+    : FormalParameterList
     | { $$ = NULL; }
     ;
 
+/* XXX: FunctionRestParameter
+    : "..." BindingIdentifier { $$ = CYNew CYFunctionRestParameter($2); }
+    ;*/
+
+FormalParameter
+    : BindingElement { $$ = $1; }
+    ;
+
 FunctionBody
-    : SourceElements { $$ = $1; }
+    : StatementListOpt { $$ = $1; }
     ;
 /* }}} */
 /* 14 Program {{{ */
 Program
-    : SourceElements { driver.program_ = CYNew CYProgram($1); }
+    : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); }
     ;
 
-SourceElements
-    : SourceElement SourceElements { $1->SetNext($2); $$ = $1; }
-    | LexSetRegExp { $$ = NULL; }
-    ;
-
-SourceElement_
-    : Statement_ { $$ = $1; }
-    | FunctionDeclaration { $$ = $1; }
+ProgramBody
+    : StatementList { $$ = $1; }
     ;
 
-SourceElement
-    : LexSetRegExp SourceElement_ { $$ = $2; }
+ProgramBodyOpt
+    : ProgramBody { $$ = $1; }
+    | { $$ = NULL; }
     ;
 /* }}} */
 
@@ -1518,15 +1587,15 @@ ClassField
     : Expression Identifier ";"
     ;
 
+ClassFieldList
+    : Brace ClassFieldListOpt "}" { $$ = NULL; }
+    ;
+
 ClassFieldListOpt
     : ClassFieldListOpt ClassField
     |
     ;
 
-ClassFieldList
-    : Brace ClassFieldListOpt "}" { $$ = NULL; }
-    ;
-
 MessageScope
     : "+" { $$ = false; }
     | "-" { $$ = true; }
@@ -1542,15 +1611,15 @@ MessageParameter
     : Word ":" TypeOpt Identifier { $$ = CYNew CYMessageParameter($1, $3, $4); }
     ;
 
+MessageParameterList
+    : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; }
+    ;
+
 MessageParameterListOpt
     : MessageParameterList { $$ = $1; }
     | { $$ = NULL; }
     ;
 
-MessageParameterList
-    : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; }
-    ;
-
 MessageParameters
     : MessageParameterList { $$ = $1; }
     | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); }
@@ -1622,16 +1691,16 @@ VariadicCall
     | { $$ = NULL; }
     ;
 
-SelectorCall_
-    : SelectorCall { $$ = $1; }
-    | VariadicCall { $$ = $1; }
-    ;
-
 SelectorWordOpt
     : WordOpt { driver.contexts_.back().words_.push_back($1); } { $$ = $1; }
     | AutoComplete { driver.mode_ = CYDriver::AutoMessage; YYACCEPT; }
     ;
 
+SelectorCall_
+    : SelectorCall { $$ = $1; }
+    | VariadicCall { $$ = $1; }
+    ;
+
 SelectorCall
     : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); }
     ;
@@ -1646,11 +1715,6 @@ MessageExpression
     | "[" LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" { $$ = CYNew CYSendSuper($5); }
     ;
 
-SelectorExpressionOpt
-    : SelectorExpression_ { $$ = $1; }
-    | { $$ = NULL; }
-    ;
-
 SelectorExpression_
     : WordOpt ":" SelectorExpressionOpt { $$ = CYNew CYSelectorPart($1, true, $3); }
     ;
@@ -1660,6 +1724,11 @@ SelectorExpression
     | Word { $$ = CYNew CYSelectorPart($1, false, NULL); }
     ;
 
+SelectorExpressionOpt
+    : SelectorExpression_ { $$ = $1; }
+    | { $$ = NULL; }
+    ;
+
 PrimaryExpressionNo
     : MessageExpression { $$ = $1; }
     | "@selector" "(" SelectorExpression ")" { $$ = CYNew CYSelector($3); }
@@ -1678,7 +1747,7 @@ ImportPath
     | StringLiteral
     ;
 
-SourceElement_
+StatementListItem
     : "@import" ImportPath { $$ = CYNew CYImport(); }
     ;
 /* }}} */
@@ -1895,16 +1964,16 @@ ForComprehension
     | "for" "each" "(" Identifier "in" Expression ")" { $$ = CYNew CYForEachInComprehension($4, $6); }
     ;
 
+ComprehensionList
+    : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; }
+    ;
+
 ComprehensionListOpt
     : ComprehensionList { $$ = $1; }
     | IfComprehension { $$ = $1; }
     | { $$ = NULL; }
     ;
 
-ComprehensionList
-    : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; }
-    ;
-
 PrimaryExpressionNo
     : "[" AssignmentExpression ComprehensionList "]" { $$ = CYNew CYArrayComprehension($2, $3); }
     ;
@@ -1914,26 +1983,25 @@ ForInStatement
     : "for" "each" "(" ForInStatementInitialiser "in" Expression ")" Statement { $$ = CYNew CYForEachIn($4, $6, $8); }
     ;
 /* }}} */
-/* JavaScript 1.7: let Statements {{{ *//*
+/* JavaScript 1.7: let Expressions {{{ */
+/*LetExpression
+    : "let" "(" VariableDeclarationList ")" Expression { $$ = CYNew CYLetExpression($3, $5); }
+    ;
+
+MemberExpression
+    : LexSetRegExp LetExpression { $$ = $2; }
+    ;*/
+/* }}} */
+/* JavaScript 1.7: let Statements {{{ */
 LetStatement
-    : "let" "(" VariableDeclarationList ")" Block_ { $$ = CYNew CYLet($3, $5); }
+    : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
     ;
 
 Statement_
     : LetStatement
     ;
-*//* }}} */
-
-/* JavaScript FTW: Function Statements {{{ */
-Statement
-    : LexSetRegExp FunctionDeclaration { driver.Warning(yylloc, "warning, FunctionDeclaration is a SourceElement, not a Statement"); } { $$ = $2; }
-    ;
-/* }}} */
-/* JavaScript FTW: Optional Arguments {{{ */
-FormalParameterList
-    : Identifier "=" AssignmentExpression FormalParameterList_ { $$ = CYNew CYOptionalFunctionParameter($1, $3, $4); }
-    ;
 /* }}} */
+
 /* JavaScript FTW: Ruby Blocks {{{ */
 RubyProcParameterList_
     : "," RubyProcParameterList { $$ = $2; }
@@ -1941,7 +2009,7 @@ RubyProcParameterList_
     ;
 
 RubyProcParameterList
-    : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
+    : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); }
     | { $$ = NULL; }
     ;