Use Lex rules to force "let of" to parse as CYLet.

[cycript.git] / Parser.ypp.in

diff --git a/Parser.ypp.in b/Parser.ypp.in
index 26d73c84bcf9852d25ce7ddcbaa822bb64bb0cbd..0c7b505e2c3d41a8600f8f7cbebdc923ed7eb7a4 100644 (file)
--- a/Parser.ypp.in
+++ b/Parser.ypp.in
@@ -42,11 +42,13 @@
 
 %union { bool bool_; }
 
 
 %union { bool bool_; }
 

+%union { CYMember *access_; }

 %union { CYArgument *argument_; }
 %union { CYAssignment *assignment_; }
 %union { CYBoolean *boolean_; }
 %union { CYClause *clause_; }
 %union { cy::Syntax::Catch *catch_; }
 %union { CYArgument *argument_; }
 %union { CYAssignment *assignment_; }
 %union { CYBoolean *boolean_; }
 %union { CYClause *clause_; }
 %union { cy::Syntax::Catch *catch_; }

+%union { CYClassTail *classTail_; }

 %union { CYComprehension *comprehension_; }
 %union { CYDeclaration *declaration_; }
 %union { CYDeclarations *declarations_; }
 %union { CYComprehension *comprehension_; }
 %union { CYDeclaration *declaration_; }
 %union { CYDeclarations *declarations_; }


@@ -61,7 +63,7 @@
 %union { CYIdentifier *identifier_; }
 %union { CYInfix *infix_; }
 %union { CYLiteral *literal_; }
 %union { CYIdentifier *identifier_; }
 %union { CYInfix *infix_; }
 %union { CYLiteral *literal_; }

-%union { CYMember *member_; }
+%union { CYMethod *method_; }

 %union { CYModule *module_; }
 %union { CYNull *null_; }
 %union { CYNumber *number_; }
 %union { CYModule *module_; }
 %union { CYNull *null_; }
 %union { CYNumber *number_; }


@@ -72,6 +74,7 @@
 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }
 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }

+%union { CYTarget *target_; }

 %union { CYThis *this_; }
 %union { CYTrue *true_; }
 %union { CYWord *word_; }
 %union { CYThis *this_; }
 %union { CYTrue *true_; }
 %union { CYWord *word_; }


@@ -84,10 +87,9 @@
 @end
 
 @begin ObjectiveC
 @end
 
 @begin ObjectiveC

-%union { CYClassName *className_; }
-%union { CYClassField *classField_; }

 %union { CYMessage *message_; }
 %union { CYMessageParameter *messageParameter_; }
 %union { CYMessage *message_; }
 %union { CYMessageParameter *messageParameter_; }

+%union { CYImplementationField *implementationField_; }

 %union { CYProtocol *protocol_; }
 %union { CYSelectorPart *selector_; }
 @end
 %union { CYProtocol *protocol_; }
 %union { CYSelectorPart *selector_; }
 @end


@@ -111,6 +113,8 @@ int cylex(YYSTYPE *, CYLocation *, void *);
 
 %code {
 
 
 %code {
 

+typedef cy::parser::token tk;
+

 #undef yylex
 _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) {
     if (driver.mark_ == CYMarkIgnore);
 #undef yylex
 _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) {
     if (driver.mark_ == CYMarkIgnore);


@@ -122,27 +126,87 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
         return cy::parser::token::MarkModule;
     }
 
         return cy::parser::token::MarkModule;
     }
 

+  lex:
+    if (driver.newline_ == CYDriver::NewLineHere)
+        driver.newline_ = CYDriver::NewLineLast;
+    else if (driver.newline_ == CYDriver::NewLineLast)
+        driver.newline_ = CYDriver::NewLineNone;
+

     YYSTYPE data;
     int token(cylex(&data, location, driver.scanner_));
     *semantic = data.semantic_;
     YYSTYPE data;
     int token(cylex(&data, location, driver.scanner_));
     *semantic = data.semantic_;

+
+    switch (token) {
+        case tk::OpenBrace:
+        case tk::OpenBracket:
+        case tk::OpenParen:
+            driver.in_.push(false);
+        break;
+
+        case tk::_in_:
+            if (driver.in_.top())
+                token = tk::_in__;
+        break;
+
+        case tk::CloseBrace:
+        case tk::CloseBracket:
+        case tk::CloseParen:
+            driver.in_.pop();
+        break;
+
+
+        case tk::_yield_:
+            if (driver.yield_.top())
+                token = tk::_yield__;
+        break;
+
+        case tk::NewLine:
+            driver.newline_ = CYDriver::NewLineHere;
+            if (!driver.next_)
+                goto lex;
+        break;
+    }
+
+    driver.next_ = false;

     return token;
 }
 
     return token;
 }
 

+#define CYLEX() do if (yyla.empty()) { \
+    YYCDEBUG << "Mapping a token: "; \
+    yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, driver)); \
+    YY_SYMBOL_PRINT("Next token is", yyla); \
+} while (false)
+

 #define CYMAP(to, from) do { \
 #define CYMAP(to, from) do { \

-    if (yyla.empty()) \
-        yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, driver)); \
+    CYLEX(); \

     if (yyla.type == yytranslate_(token::from)) \
         yyla.type = yytranslate_(token::to); \
 } while (false)
 
     if (yyla.type == yytranslate_(token::from)) \
         yyla.type = yytranslate_(token::to); \
 } while (false)
 

+#define CYLIN(from) do { \
+    CYLEX(); \
+    if (yyla.type == yytranslate_(token::from) && driver.newline_ == CYDriver::NewLineLast) \
+        yyla.type = yytranslate_(token::from ## _); \
+} while (false)
+

 #define CYERR(location, message) do { \
     error(location, message); \
     YYABORT; \
 } while (false)
 
 #define CYERR(location, message) do { \
     error(location, message); \
     YYABORT; \
 } while (false)
 

+#define CYEOK() do { \
+    yyerrok; \
+    driver.errors_.pop_back(); \
+} while (false)
+

 #define CYNOT(location) \
     CYERR(location, "unimplemented feature")
 
 #define CYNOT(location) \
     CYERR(location, "unimplemented feature")
 

+#define CYMPT(location) do { \
+    if (!yyla.empty() && yyla.type_get() != yyeof_) \
+        CYERR(location, "unexpected lookahead"); \
+} while (false)
+

 }
 
 %name-prefix "cy"
 }
 
 %name-prefix "cy"


@@ -253,9 +317,11 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token OpenBrace "{"
 %token OpenBrace_ "\n{"
 %token OpenBrace__ ";{"
 %token OpenBrace "{"
 %token OpenBrace_ "\n{"
 %token OpenBrace__ ";{"

+%token OpenBrace_let "let {"

 %token CloseBrace "}"
 
 %token OpenBracket "["
 %token CloseBrace "}"
 
 %token OpenBracket "["

+%token OpenBracket_let "let ["

 %token CloseBracket "]"
 
 %token At_error_ "@error"
 %token CloseBracket "]"
 
 %token At_error_ "@error"


@@ -316,12 +382,13 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token _import_ "import"
 %token _in_ "in"
 %token _in__ "!in"
 %token _import_ "import"
 %token _in_ "in"
 %token _in__ "!in"

+%token _Infinity_ "Infinity"

 %token _instanceof_ "instanceof"
 %token _new_ "new"
 %token _return_ "return"
 %token _instanceof_ "instanceof"
 %token _new_ "new"
 %token _return_ "return"

-%token _return__ "!return"

 %token _super_ "super"
 %token _switch_ "switch"
 %token _super_ "super"
 %token _switch_ "switch"

+%token _target_ "target"

 %token _this_ "this"
 %token _throw_ "throw"
 %token _try_ "try"
 %token _this_ "this"
 %token _throw_ "throw"
 %token _try_ "try"


@@ -336,7 +403,9 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token _boolean_ "boolean"
 %token _byte_ "byte"
 %token _char_ "char"
 %token _boolean_ "boolean"
 %token _byte_ "byte"
 %token _char_ "char"

+%token _constructor_ "constructor"

 %token _double_ "double"
 %token _double_ "double"

+%token _eval_ "eval"

 %token _final_ "final"
 %token _float_ "float"
 %token _from_ "from"
 %token _final_ "final"
 %token _float_ "float"
 %token _from_ "from"


@@ -346,11 +415,13 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token _int_ "int"
 %token _interface_ "interface"
 %token _let_ "let"
 %token _int_ "int"
 %token _interface_ "interface"
 %token _let_ "let"

+%token _let__ "!let"

 %token _long_ "long"
 %token _native_ "native"
 %token _package_ "package"
 %token _private_ "private"
 %token _protected_ "protected"
 %token _long_ "long"
 %token _native_ "native"
 %token _package_ "package"
 %token _private_ "private"
 %token _protected_ "protected"

+%token _prototype_ "prototype"

 %token _public_ "public"
 %token _set_ "set"
 %token _short_ "short"
 %token _public_ "public"
 %token _set_ "set"
 %token _short_ "short"


@@ -376,6 +447,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token _auto_ "auto"
 %token _each_ "each"
 %token _of_ "of"
 %token _auto_ "auto"
 %token _each_ "each"
 %token _of_ "of"

+%token _of__ "!of"

 
 @begin E4X
 %token _namespace_ "namespace"
 
 @begin E4X
 %token _namespace_ "namespace"


@@ -388,19 +460,20 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %token <identifier_> Identifier_
 %token <number_> NumericLiteral
 %token <string_> StringLiteral
 %token <identifier_> Identifier_
 %token <number_> NumericLiteral
 %token <string_> StringLiteral

-%token <literal_> RegularExpressionLiteral
+%token <literal_> RegularExpressionLiteral_

 
 %token <string_> NoSubstitutionTemplate
 %token <string_> TemplateHead
 %token <string_> TemplateMiddle
 %token <string_> TemplateTail
 
 
 %token <string_> NoSubstitutionTemplate
 %token <string_> TemplateHead
 %token <string_> TemplateMiddle
 %token <string_> TemplateTail
 

+%type <target_> AccessExpression

 %type <expression_> AdditiveExpression
 %type <argument_> ArgumentList_
 %type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <expression_> AdditiveExpression
 %type <argument_> ArgumentList_
 %type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments

-%type <expression_> ArrayComprehension
+%type <target_> ArrayComprehension

 %type <literal_> ArrayLiteral
 %type <expression_> ArrowFunction
 %type <functionParameter_> ArrowParameters
 %type <literal_> ArrayLiteral
 %type <expression_> ArrowFunction
 %type <functionParameter_> ArrowParameters


@@ -420,19 +493,22 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %type <statement_> BreakStatement
 %type <statement_> BreakableStatement
 %type <expression_> CallExpression_
 %type <statement_> BreakStatement
 %type <statement_> BreakableStatement
 %type <expression_> CallExpression_

-%type <expression_> CallExpression
+%type <target_> CallExpression

 %type <clause_> CaseBlock
 %type <clause_> CaseClause
 %type <clause_> CaseClausesOpt
 %type <catch_> Catch
 %type <identifier_> CatchParameter
 %type <statement_> ClassDeclaration
 %type <clause_> CaseBlock
 %type <clause_> CaseClause
 %type <clause_> CaseClausesOpt
 %type <catch_> Catch
 %type <identifier_> CatchParameter
 %type <statement_> ClassDeclaration

-%type <expression_> ClassExpression
-%type <expression_> Comprehension
+%type <target_> ClassExpression
+%type <classTail_> ClassHeritage
+%type <classTail_> ClassHeritageOpt
+%type <classTail_> ClassTail
+%type <target_> Comprehension

 %type <comprehension_> ComprehensionFor
 %type <comprehension_> ComprehensionIf
 %type <comprehension_> ComprehensionTail
 %type <comprehension_> ComprehensionFor
 %type <comprehension_> ComprehensionIf
 %type <comprehension_> ComprehensionTail

-%type <expression_> ComputedPropertyName
+%type <propertyName_> ComputedPropertyName

 %type <expression_> ConditionalExpression
 %type <statement_> ContinueStatement
 %type <statement_> ConciseBody
 %type <expression_> ConditionalExpression
 %type <statement_> ContinueStatement
 %type <statement_> ConciseBody


@@ -445,14 +521,15 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt
 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt

-%type <statement_> EmptyStatement
+%type <for_> EmptyStatement

 %type <expression_> EqualityExpression
 %type <expression_> Expression
 %type <expression_> ExpressionOpt
 %type <expression_> EqualityExpression
 %type <expression_> Expression
 %type <expression_> ExpressionOpt

+%type <for_> ExpressionStatement_

 %type <statement_> ExpressionStatement
 %type <finally_> Finally
 %type <declaration_> ForBinding
 %type <statement_> ExpressionStatement
 %type <finally_> Finally
 %type <declaration_> ForBinding

-%type <declaration_> ForDeclaration
+%type <forin_> ForDeclaration

 %type <forin_> ForInStatementInitializer
 %type <for_> ForStatementInitializer
 %type <declaration_> FormalParameter
 %type <forin_> ForInStatementInitializer
 %type <for_> ForStatementInitializer
 %type <declaration_> FormalParameter


@@ -461,48 +538,55 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %type <functionParameter_> FormalParameters
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <functionParameter_> FormalParameters
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration

-%type <expression_> FunctionExpression
+%type <target_> FunctionExpression

 %type <statement_> FunctionStatementList
 %type <statement_> GeneratorBody
 %type <statement_> GeneratorDeclaration
 %type <statement_> FunctionStatementList
 %type <statement_> GeneratorBody
 %type <statement_> GeneratorDeclaration

-%type <expression_> GeneratorExpression
-%type <property_> GeneratorMethod
+%type <target_> GeneratorExpression
+%type <method_> GeneratorMethod

 %type <statement_> HoistableDeclaration
 %type <identifier_> Identifier
 %type <statement_> HoistableDeclaration
 %type <identifier_> Identifier

+%type <identifier_> IdentifierNoOf

 %type <identifier_> IdentifierType
 %type <identifier_> IdentifierType

+%type <identifier_> IdentifierTypeNoOf

 %type <word_> IdentifierName
 %type <variable_> IdentifierReference
 %type <statement_> IfStatement
 %type <word_> IdentifierName
 %type <variable_> IdentifierReference
 %type <statement_> IfStatement

+%type <target_> IndirectExpression

 %type <expression_> Initializer
 %type <expression_> InitializerOpt
 %type <statement_> IterationStatement
 %type <identifier_> LabelIdentifier
 %type <statement_> LabelledItem
 %type <statement_> LabelledStatement
 %type <expression_> Initializer
 %type <expression_> InitializerOpt
 %type <statement_> IterationStatement
 %type <identifier_> LabelIdentifier
 %type <statement_> LabelledItem
 %type <statement_> LabelledStatement

-%type <expression_> LeftHandSideExpression
-%type <statement_> LetStatement
+%type <assignment_> LeftHandSideAssignment
+%type <target_> LeftHandSideExpression
+%type <bool_> LetOrConst

 %type <declaration_> LexicalBinding
 %type <declaration_> LexicalBinding

+%type <for_> LexicalDeclaration_

 %type <statement_> LexicalDeclaration
 %type <literal_> Literal
 %type <propertyName_> LiteralPropertyName
 %type <expression_> LogicalANDExpression
 %type <expression_> LogicalORExpression
 %type <statement_> LexicalDeclaration
 %type <literal_> Literal
 %type <propertyName_> LiteralPropertyName
 %type <expression_> LogicalANDExpression
 %type <expression_> LogicalORExpression

-%type <member_> MemberAccess
-%type <expression_> MemberExpression
-%type <property_> MethodDefinition
+%type <access_> MemberAccess
+%type <target_> MemberExpression
+%type <method_> MethodDefinition

 %type <module_> ModulePath
 %type <expression_> MultiplicativeExpression
 %type <module_> ModulePath
 %type <expression_> MultiplicativeExpression

-%type <expression_> NewExpression
+%type <target_> NewExpression

 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %type <expression_> PostfixExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %type <expression_> PostfixExpression

-%type <expression_> PrimaryExpression
+%type <target_> PrimaryExpression

 %type <propertyName_> PropertyName
 %type <property_> PropertyDefinition
 %type <property_> PropertyDefinitionList_
 %type <property_> PropertyDefinitionList
 %type <property_> PropertyDefinitionListOpt
 %type <declaration_> PropertySetParameterList
 %type <propertyName_> PropertyName
 %type <property_> PropertyDefinition
 %type <property_> PropertyDefinitionList_
 %type <property_> PropertyDefinitionList
 %type <property_> PropertyDefinitionListOpt
 %type <declaration_> PropertySetParameterList

+%type <literal_> RegularExpressionLiteral
+%type <bool_> RegularExpressionSlash

 %type <expression_> RelationalExpression
 %type <statement_> ReturnStatement
 %type <rubyProc_> RubyProcExpression
 %type <expression_> RelationalExpression
 %type <statement_> ReturnStatement
 %type <rubyProc_> RubyProcExpression


@@ -522,8 +606,10 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %type <statement_> StatementListOpt
 %type <statement_> StatementListItem
 %type <functionParameter_> StrictFormalParameters
 %type <statement_> StatementListOpt
 %type <statement_> StatementListItem
 %type <functionParameter_> StrictFormalParameters

+%type <target_> SuperCall
+%type <target_> SuperProperty

 %type <statement_> SwitchStatement
 %type <statement_> SwitchStatement

-%type <expression_> TemplateLiteral
+%type <target_> TemplateLiteral

 %type <span_> TemplateSpans
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement
 %type <span_> TemplateSpans
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement


@@ -532,6 +618,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 %type <declaration_> VariableDeclaration
 %type <declarations_> VariableDeclarationList_
 %type <declarations_> VariableDeclarationList
 %type <declaration_> VariableDeclaration
 %type <declarations_> VariableDeclarationList_
 %type <declarations_> VariableDeclarationList

+%type <for_> VariableStatement_

 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word
 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word


@@ -556,19 +643,20 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 @end
 
 @begin ObjectiveC
 @end
 
 @begin ObjectiveC

+%type <expression_> AssignmentExpressionClassic

 %type <expression_> BoxableExpression
 %type <statement_> CategoryStatement
 %type <expression_> BoxableExpression
 %type <statement_> CategoryStatement

-%type <classField_> ClassFieldListOpt
-%type <classField_> ClassFields
-%type <statement_> ClassStatement

 %type <expression_> ClassSuperOpt
 %type <expression_> ClassSuperOpt

+%type <expression_> ConditionalExpressionClassic
+%type <implementationField_> ImplementationFieldListOpt
+%type <implementationField_> ImplementationFields

 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt
 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt

-%type <className_> ClassName

 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt
 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt

-%type <expression_> MessageExpression
+%type <statement_> ImplementationStatement
+%type <target_> MessageExpression

 %type <messageParameter_> MessageParameter
 %type <messageParameter_> MessageParameters
 %type <messageParameter_> MessageParameterList
 %type <messageParameter_> MessageParameter
 %type <messageParameter_> MessageParameters
 %type <messageParameter_> MessageParameterList


@@ -607,9 +695,6 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY
 @end
 /* }}} */
 /* Token Priorities {{{ */
 @end
 /* }}} */
 /* Token Priorities {{{ */

-%nonassoc ""
-%left "++" "--" "{"
-

 %nonassoc "if"
 %nonassoc "else"
 /* }}} */
 %nonassoc "if"
 %nonassoc "else"
 /* }}} */


@@ -633,16 +718,20 @@ LexPopIn: { driver.in_.pop(); };
 LexPushReturnOn: { driver.return_.push(true); };
 LexPopReturn: { driver.return_.pop(); };
 
 LexPushReturnOn: { driver.return_.push(true); };
 LexPopReturn: { driver.return_.pop(); };
 

+LexPushSuperOn: { driver.super_.push(true); };
+LexPushSuperOff: { driver.super_.push(false); };
+LexPopSuper: { driver.super_.pop(); };
+

 LexPushYieldOn: { driver.yield_.push(true); };
 LexPushYieldOff: { driver.yield_.push(false); };
 LexPopYield: { driver.yield_.pop(); };
 
 LexSetRegExp
 LexPushYieldOn: { driver.yield_.push(true); };
 LexPushYieldOff: { driver.yield_.push(false); };
 LexPopYield: { driver.yield_.pop(); };
 
 LexSetRegExp

-    : { driver.SetCondition(CYDriver::RegExpCondition); }
+    :

     ;
 
 LexNewLine
     ;
 
 LexNewLine

-    : { if (!yyla.empty() && yyla.type_get() != yyeof_) CYERR(@$, "unexpected lookahead"); driver.next_ = true; }
+    : { CYMPT(@$); driver.next_ = true; }

     ;
 
 LexNoStar
     ;
 
 LexNoStar


@@ -690,12 +779,12 @@ NewLineOpt
     ;
 
 Word
     ;
 
 Word

-    : Identifier { $$ = $1; }
+    : IdentifierNoOf { $$ = $1; }

     | "auto" { $$ = CYNew CYWord("auto"); }
     | "break" { $$ = CYNew CYWord("break"); }
     | "case" { $$ = CYNew CYWord("case"); }
     | "catch" { $$ = CYNew CYWord("catch"); }
     | "auto" { $$ = CYNew CYWord("auto"); }
     | "break" { $$ = CYNew CYWord("break"); }
     | "case" { $$ = CYNew CYWord("case"); }
     | "catch" { $$ = CYNew CYWord("catch"); }

-    | "class" { $$ = CYNew CYWord("class"); }
+    | "class" LexOf { $$ = CYNew CYWord("class"); }

     | ";class" { $$ = CYNew CYWord("class"); }
     | "const" { $$ = CYNew CYWord("const"); }
     | "continue" { $$ = CYNew CYWord("continue"); }
     | ";class" { $$ = CYNew CYWord("class"); }
     | "const" { $$ = CYNew CYWord("const"); }
     | "continue" { $$ = CYNew CYWord("continue"); }


@@ -709,14 +798,14 @@ Word
     | "extends" { $$ = CYNew CYWord("extends"); }
     | "false" { $$ = CYNew CYWord("false"); }
     | "finally" { $$ = CYNew CYWord("finally"); }
     | "extends" { $$ = CYNew CYWord("extends"); }
     | "false" { $$ = CYNew CYWord("false"); }
     | "finally" { $$ = CYNew CYWord("finally"); }

-    | "function" { $$ = CYNew CYWord("function"); }
+    | "function" LexOf { $$ = CYNew CYWord("function"); }

     | "if" { $$ = CYNew CYWord("if"); }
     | "import" { $$ = CYNew CYWord("import"); }
     | "!in" { $$ = CYNew CYWord("in"); }
     | "if" { $$ = CYNew CYWord("if"); }
     | "import" { $$ = CYNew CYWord("import"); }
     | "!in" { $$ = CYNew CYWord("in"); }

+    | "!of" { $$ = CYNew CYWord("of"); }

     | "new" LexSetRegExp { $$ = CYNew CYWord("new"); }
     | "null" { $$ = CYNew CYWord("null"); }
     | "return" { $$ = CYNew CYWord("return"); }
     | "new" LexSetRegExp { $$ = CYNew CYWord("new"); }
     | "null" { $$ = CYNew CYWord("null"); }
     | "return" { $$ = CYNew CYWord("return"); }

-    | "!return" { $$ = CYNew CYWord("return"); }

     | "super" { $$ = CYNew CYWord("super"); }
     | "switch" { $$ = CYNew CYWord("switch"); }
     | "this" { $$ = CYNew CYWord("this"); }
     | "super" { $$ = CYNew CYWord("super"); }
     | "switch" { $$ = CYNew CYWord("switch"); }
     | "this" { $$ = CYNew CYWord("this"); }


@@ -731,9 +820,6 @@ Word
     | "yield" { $$ = CYNew CYIdentifier("yield"); }
 
     | Yield LexSetRegExp NewLineOpt { $$ = CYNew CYIdentifier("yield"); }
     | "yield" { $$ = CYNew CYIdentifier("yield"); }
 
     | Yield LexSetRegExp NewLineOpt { $$ = CYNew CYIdentifier("yield"); }

-
-    // XXX: should be Identifier
-    | "let" { $$ = CYNew CYIdentifier("let"); }

     ;
 
 @begin ObjectiveC
     ;
 
 @begin ObjectiveC


@@ -754,6 +840,16 @@ BooleanLiteral
     | "false" { $$ = CYNew CYFalse(); }
     ;
 /* }}} */
     | "false" { $$ = CYNew CYFalse(); }
     ;
 /* }}} */

+/* 11.8.5 Regular Expression Literals {{{ */
+RegularExpressionSlash
+    : "/" { $$ = false; }
+    | "/=" { $$ = true; }
+    ;
+
+RegularExpressionLiteral
+    : RegularExpressionSlash { CYMPT(@$); driver.SetRegEx($1); } RegularExpressionLiteral_ { $$ = $3; }
+    ;
+/* }}} */

 
 /* 11.9 Automatic Semicolon Insertion {{{ */
 StrictSemi
 
 /* 11.9 Automatic Semicolon Insertion {{{ */
 StrictSemi


@@ -767,7 +863,7 @@ TerminatorSoft
 
 Terminator
     : ";"
 
 Terminator
     : ";"

-    | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) { CYERR(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
+    | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && driver.newline_ == CYDriver::NewLineNone) CYERR(@1, "required semi-colon"); else CYEOK(); } StrictSemi

     ;
 
 TerminatorOpt
     ;
 
 TerminatorOpt


@@ -783,7 +879,8 @@ IdentifierReference
     ;
 
 BindingIdentifier
     ;
 
 BindingIdentifier

-    : Identifier { $$ = $1; }
+    : IdentifierNoOf { $$ = $1; }
+    | "!of" { $$ = CYNew CYIdentifier("of"); }

     | "yield" { $$ = CYNew CYIdentifier("yield"); }
     ;
 
     | "yield" { $$ = CYNew CYIdentifier("yield"); }
     ;
 


@@ -797,29 +894,38 @@ LabelIdentifier
     | "yield" { $$ = CYNew CYIdentifier("yield"); }
     ;
 
     | "yield" { $$ = CYNew CYIdentifier("yield"); }
     ;
 

-IdentifierType
+IdentifierTypeNoOf

     : Identifier_ { $$ = $1; }
     | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
     | "await" { $$ = CYNew CYIdentifier("await"); }
     | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
     | "byte" { $$ = CYNew CYIdentifier("byte"); }
     : Identifier_ { $$ = $1; }
     | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
     | "await" { $$ = CYNew CYIdentifier("await"); }
     | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
     | "byte" { $$ = CYNew CYIdentifier("byte"); }

+    | "constructor" { $$ = CYNew CYIdentifier("constructor"); }

     | "double" { $$ = CYNew CYIdentifier("double"); }
     | "each" { $$ = CYNew CYIdentifier("each"); }
     | "double" { $$ = CYNew CYIdentifier("double"); }
     | "each" { $$ = CYNew CYIdentifier("each"); }

+    | "eval" { $$ = CYNew CYIdentifier("eval"); }

     | "final" { $$ = CYNew CYIdentifier("final"); }
     | "float" { $$ = CYNew CYIdentifier("float"); }
     | "final" { $$ = CYNew CYIdentifier("final"); }
     | "float" { $$ = CYNew CYIdentifier("float"); }

+    | "from" { $$ = CYNew CYIdentifier("from"); }
+    | "get" { $$ = CYNew CYIdentifier("get"); }

     | "goto" { $$ = CYNew CYIdentifier("goto"); }
     | "implements" { $$ = CYNew CYIdentifier("implements"); }
     | "goto" { $$ = CYNew CYIdentifier("goto"); }
     | "implements" { $$ = CYNew CYIdentifier("implements"); }

+    | "Infinity" { $$ = CYNew CYIdentifier("Infinity"); }

     | "interface" { $$ = CYNew CYIdentifier("interface"); }
     | "interface" { $$ = CYNew CYIdentifier("interface"); }

+    | "let" { $$ = CYNew CYIdentifier("let"); }
+    | "!let" LexBind { $$ = CYNew CYIdentifier("let"); }

     | "native" { $$ = CYNew CYIdentifier("native"); }
     | "native" { $$ = CYNew CYIdentifier("native"); }

-    | "of" { $$ = CYNew CYIdentifier("of"); }

     | "package" { $$ = CYNew CYIdentifier("package"); }
     | "private" { $$ = CYNew CYIdentifier("private"); }
     | "protected" { $$ = CYNew CYIdentifier("protected"); }
     | "package" { $$ = CYNew CYIdentifier("package"); }
     | "private" { $$ = CYNew CYIdentifier("private"); }
     | "protected" { $$ = CYNew CYIdentifier("protected"); }

+    | "prototype" { $$ = CYNew CYIdentifier("prototype"); }

     | "public" { $$ = CYNew CYIdentifier("public"); }
     | "public" { $$ = CYNew CYIdentifier("public"); }

-    | "static" { $$ = CYNew CYIdentifier("static"); }
+    | "set" { $$ = CYNew CYIdentifier("set"); }

     | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); }
     | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); }

+    | "target" { $$ = CYNew CYIdentifier("target"); }

     | "throws" { $$ = CYNew CYIdentifier("throws"); }
     | "transient" { $$ = CYNew CYIdentifier("transient"); }
     | "throws" { $$ = CYNew CYIdentifier("throws"); }
     | "transient" { $$ = CYNew CYIdentifier("transient"); }

+    | "undefined" { $$ = CYNew CYIdentifier("undefined"); }

 @begin ObjectiveC
     | "bool" { $$ = CYNew CYIdentifier("bool"); }
     | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); }
 @begin ObjectiveC
     | "bool" { $$ = CYNew CYIdentifier("bool"); }
     | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); }


@@ -828,16 +934,18 @@ IdentifierType
 @end
     ;
 
 @end
     ;
 

-Identifier
-    : IdentifierType
+IdentifierType
+    : IdentifierTypeNoOf { $$ = $1; }
+    | "of" { $$ = CYNew CYIdentifier("of"); }
+    ;
+
+IdentifierNoOf
+    : IdentifierTypeNoOf

     | "char" { $$ = CYNew CYIdentifier("char"); }
     | "char" { $$ = CYNew CYIdentifier("char"); }

-    | "from" { $$ = CYNew CYIdentifier("from"); }
-    | "get" { $$ = CYNew CYIdentifier("get"); }

     | "int" { $$ = CYNew CYIdentifier("int"); }
     | "long" { $$ = CYNew CYIdentifier("long"); }
     | "int" { $$ = CYNew CYIdentifier("int"); }
     | "long" { $$ = CYNew CYIdentifier("long"); }

-    | "set" { $$ = CYNew CYIdentifier("set"); }

     | "short" { $$ = CYNew CYIdentifier("short"); }
     | "short" { $$ = CYNew CYIdentifier("short"); }

-    | "undefined" { $$ = CYNew CYIdentifier("undefined"); }
+    | "static" { $$ = CYNew CYIdentifier("static"); }

     | "volatile" { $$ = CYNew CYIdentifier("volatile"); }
 @begin C
     | "extern" { $$ = CYNew CYIdentifier("extern"); }
     | "volatile" { $$ = CYNew CYIdentifier("volatile"); }
 @begin C
     | "extern" { $$ = CYNew CYIdentifier("extern"); }


@@ -852,6 +960,11 @@ Identifier
     | "YES" { $$ = CYNew CYIdentifier("YES"); }
 @end
     ;
     | "YES" { $$ = CYNew CYIdentifier("YES"); }
 @end
     ;

+
+Identifier
+    : IdentifierNoOf { $$ = $1; }
+    | "of" { $$ = CYNew CYIdentifier("of"); }
+    ;

 /* }}} */
 /* 12.2 Primary Expression {{{ */
 PrimaryExpression
 /* }}} */
 /* 12.2 Primary Expression {{{ */
 PrimaryExpression


@@ -870,10 +983,10 @@ PrimaryExpression
     ;
 
 CoverParenthesizedExpressionAndArrowParameterList
     ;
 
 CoverParenthesizedExpressionAndArrowParameterList

-    : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }
-    | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }
-    | "(" LexPushInOff LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); }
-    | "(" LexPushInOff Expression "," LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); }
+    : "(" Expression ")" { $$ = CYNew CYParenthetical($2); }
+    | "(" LexSetRegExp ")" { $$ = NULL; }
+    | "(" LexSetRegExp "..." BindingIdentifier ")" { CYNOT(@$); }
+    | "(" Expression "," LexSetRegExp "..." BindingIdentifier ")" { CYNOT(@$); }

     ;
 /* }}} */
 /* 12.2.4 Literals {{{ */
     ;
 /* }}} */
 /* 12.2.4 Literals {{{ */


@@ -886,7 +999,7 @@ Literal
 /* }}} */
 /* 12.2.5 Array Initializer {{{ */
 ArrayLiteral
 /* }}} */
 /* 12.2.5 Array Initializer {{{ */
 ArrayLiteral

-    : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
+    : "[" ElementListOpt "]" { $$ = CYNew CYArray($2); }

     ;
 
 ElementList
     ;
 
 ElementList


@@ -902,7 +1015,7 @@ ElementListOpt
 /* }}} */
 /* 12.2.6 Object Initializer {{{ */
 ObjectLiteral
 /* }}} */
 /* 12.2.6 Object Initializer {{{ */
 ObjectLiteral

-    : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); }
+    : BRACE PropertyDefinitionListOpt "}" { $$ = CYNew CYObject($2); }

     ;
 
 PropertyDefinitionList_
     ;
 
 PropertyDefinitionList_


@@ -920,15 +1033,15 @@ PropertyDefinitionListOpt
     ;
 
 PropertyDefinition
     ;
 
 PropertyDefinition

-    : IdentifierReference { $$ = CYNew CYProperty($1->name_, $1); }
+    : IdentifierReference { $$ = CYNew CYPropertyValue($1->name_, $1); }

     | CoverInitializedName { CYNOT(@$); }
     | CoverInitializedName { CYNOT(@$); }

-    | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); }
+    | PropertyName ":" AssignmentExpression { $$ = CYNew CYPropertyValue($1, $3); }

     | MethodDefinition { $$ = $1; }
     ;
 
 PropertyName
     : LiteralPropertyName { $$ = $1; }
     | MethodDefinition { $$ = $1; }
     ;
 
 PropertyName
     : LiteralPropertyName { $$ = $1; }

-    | ComputedPropertyName { CYNOT(@$); /* $$ = $1; */ }
+    | ComputedPropertyName { $$ = $1; }

     ;
 
 LiteralPropertyName
     ;
 
 LiteralPropertyName


@@ -938,7 +1051,7 @@ LiteralPropertyName
     ;
 
 ComputedPropertyName
     ;
 
 ComputedPropertyName

-    : "[" AssignmentExpression "]" { $$ = $2; }
+    : "[" AssignmentExpression "]" { $$ = CYNew CYComputed($2); }

     ;
 
 CoverInitializedName
     ;
 
 CoverInitializedName


@@ -968,7 +1081,7 @@ TemplateSpans
 
 /* 12.3 Left-Hand-Side Expressions {{{ */
 MemberAccess
 
 /* 12.3 Left-Hand-Side Expressions {{{ */
 MemberAccess

-    : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
+    : "[" Expression "]" { $$ = CYNew CYDirectMember(NULL, $2); }

     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
     | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
     | TemplateLiteral { CYNOT(@$); }
     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
     | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
     | TemplateLiteral { CYNOT(@$); }


@@ -977,14 +1090,14 @@ MemberAccess
 MemberExpression
     : LexSetRegExp PrimaryExpression { $$ = $2; }
     | MemberExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
 MemberExpression
     : LexSetRegExp PrimaryExpression { $$ = $2; }
     | MemberExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }

-    | SuperProperty { CYNOT(@$); }
+    | SuperProperty { $$ = $1; }

     | MetaProperty { CYNOT(@$); }
     | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); }
     ;
 
 SuperProperty
     | MetaProperty { CYNOT(@$); }
     | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); }
     ;
 
 SuperProperty

-    : LexSetRegExp "super" "[" Expression "]"
-    | LexSetRegExp "super" "." IdentifierName
+    : LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } "[" Expression "]" { $$ = CYNew CYSuperAccess($5); }
+    | LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } "." IdentifierName { $$ = CYNew CYSuperAccess(CYNew CYString($5)); }

     ;
 
 MetaProperty
     ;
 
 MetaProperty


@@ -1001,22 +1114,22 @@ NewExpression
     ;
 
 CallExpression_
     ;
 
 CallExpression_

-    : MemberExpression
-    | CallExpression
+    : MemberExpression { $$ = $1; }
+    | CallExpression { $$ = $1; }

     ;
 
 CallExpression
     ;
 
 CallExpression

-    : CallExpression_ Arguments { $$ = CYNew CYCall($1, $2); }
-    | SuperCall { CYNOT(@$); }
+    : CallExpression_ Arguments { if (!$1->Eval()) $$ = CYNew CYCall($1, $2); else $$ = CYNew CYEval($2); }
+    | SuperCall { $$ = $1; }

     | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
     ;
 
 SuperCall
     | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
     ;
 
 SuperCall

-    : LexSetRegExp "super" Arguments
+    : LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } Arguments { $$ = CYNew CYSuperCall($4); }

     ;
 
 Arguments
     ;
 
 Arguments

-    : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; }
+    : "(" ArgumentListOpt ")" { $$ = $2; }

     ;
 
 ArgumentList_
     ;
 
 ArgumentList_


@@ -1034,16 +1147,25 @@ ArgumentListOpt
     | LexSetRegExp { $$ = NULL; }
     ;
 
     | LexSetRegExp { $$ = NULL; }
     ;
 

-LeftHandSideExpression
+AccessExpression

     : NewExpression { $$ = $1; }
     | CallExpression { $$ = $1; }
     ;
     : NewExpression { $$ = $1; }
     | CallExpression { $$ = $1; }
     ;

+
+LeftHandSideExpression
+    : AccessExpression LexCrement { $$ = $1; }
+    | LexSetRegExp IndirectExpression { $$ = $2; }
+    ;

 /* }}} */
 /* 12.4 Postfix Expressions {{{ */
 /* }}} */
 /* 12.4 Postfix Expressions {{{ */

+LexCrement
+    : { CYLIN(PlusPlus); CYLIN(HyphenHyphen); }
+    ;
+

 PostfixExpression
 PostfixExpression

-    : %prec "" LeftHandSideExpression { $$ = $1; }
-    | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); }
-    | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); }
+    : AccessExpression LexCrement { $$ = $1; }
+    | AccessExpression LexCrement "++" { $$ = CYNew CYPostIncrement($1); }
+    | AccessExpression LexCrement "--" { $$ = CYNew CYPostDecrement($1); }

     ;
 /* }}} */
 /* 12.5 Unary Operators {{{ */
     ;
 /* }}} */
 /* 12.5 Unary Operators {{{ */


@@ -1062,7 +1184,7 @@ UnaryExpression_
     ;
 
 UnaryExpression
     ;
 
 UnaryExpression

-    : PostfixExpression { $$ = $1; }
+    : PostfixExpression LexOpenBrace { $$ = $1; }

     | LexSetRegExp UnaryExpression_ { $$ = $2; }
     ;
 /* }}} */
     | LexSetRegExp UnaryExpression_ { $$ = $2; }
     ;
 /* }}} */


@@ -1137,28 +1259,46 @@ LogicalORExpression
     ;
 /* }}} */
 /* 12.13 Conditional Operator ( ? : ) {{{ */
     ;
 /* }}} */
 /* 12.13 Conditional Operator ( ? : ) {{{ */

+@begin ObjectiveC
+ConditionalExpressionClassic
+    : LogicalORExpression { $$ = $1; }
+    | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpressionClassic { $$ = CYNew CYCondition($1, $4, $7); }
+    ;
+@end
+

 ConditionalExpression
     : LogicalORExpression { $$ = $1; }
     | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
     ;
 /* }}} */
 /* 12.14 Assignment Operators {{{ */
 ConditionalExpression
     : LogicalORExpression { $$ = $1; }
     | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
     ;
 /* }}} */
 /* 12.14 Assignment Operators {{{ */

+LeftHandSideAssignment
+    : LeftHandSideExpression "=" { $$ = CYNew CYAssign($1, NULL); }
+    | LeftHandSideExpression "*=" { $$ = CYNew CYMultiplyAssign($1, NULL); }
+    | LeftHandSideExpression "/=" { $$ = CYNew CYDivideAssign($1, NULL); }
+    | LeftHandSideExpression "%=" { $$ = CYNew CYModulusAssign($1, NULL); }
+    | LeftHandSideExpression "+=" { $$ = CYNew CYAddAssign($1, NULL); }
+    | LeftHandSideExpression "-=" { $$ = CYNew CYSubtractAssign($1, NULL); }
+    | LeftHandSideExpression "<<=" { $$ = CYNew CYShiftLeftAssign($1, NULL); }
+    | LeftHandSideExpression ">>=" { $$ = CYNew CYShiftRightSignedAssign($1, NULL); }
+    | LeftHandSideExpression ">>>=" { $$ = CYNew CYShiftRightUnsignedAssign($1, NULL); }
+    | LeftHandSideExpression "&=" { $$ = CYNew CYBitwiseAndAssign($1, NULL); }
+    | LeftHandSideExpression "^=" { $$ = CYNew CYBitwiseXOrAssign($1, NULL); }
+    | LeftHandSideExpression "|=" { $$ = CYNew CYBitwiseOrAssign($1, NULL); }
+    ;
+
+@begin ObjectiveC
+AssignmentExpressionClassic
+    : ConditionalExpressionClassic { $$ = $1; }
+    | LeftHandSideAssignment AssignmentExpressionClassic { $1->SetRight($2); $$ = $1; }
+    ;
+@end
+

 AssignmentExpression
     : ConditionalExpression { $$ = $1; }
     | LexSetRegExp YieldExpression { $$ = $2; }
     | ArrowFunction { $$ = $1; }
 AssignmentExpression
     : ConditionalExpression { $$ = $1; }
     | LexSetRegExp YieldExpression { $$ = $2; }
     | ArrowFunction { $$ = $1; }

-    | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
-    | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
-    | LeftHandSideExpression "/=" AssignmentExpression { $$ = CYNew CYDivideAssign($1, $3); }
-    | LeftHandSideExpression "%=" AssignmentExpression { $$ = CYNew CYModulusAssign($1, $3); }
-    | LeftHandSideExpression "+=" AssignmentExpression { $$ = CYNew CYAddAssign($1, $3); }
-    | LeftHandSideExpression "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign($1, $3); }
-    | LeftHandSideExpression "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign($1, $3); }
-    | LeftHandSideExpression ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign($1, $3); }
-    | LeftHandSideExpression ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign($1, $3); }
-    | LeftHandSideExpression "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign($1, $3); }
-    | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
-    | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
+    | LeftHandSideAssignment AssignmentExpression { $1->SetRight($2); $$ = $1; }

     ;
 
 AssignmentExpressionOpt
     ;
 
 AssignmentExpressionOpt


@@ -1201,17 +1341,17 @@ Statement_
     ;
 
 Statement
     ;
 
 Statement

-    : LexSetStatement Statement_ { $$ = $2; }
+    : LexSetStatement LexLet Statement_ { $$ = $3; }

     ;
 
 Declaration__
     : HoistableDeclaration { $$ = $1; }
     | ClassDeclaration { $$ = $1; }
     ;
 
 Declaration__
     : HoistableDeclaration { $$ = $1; }
     | ClassDeclaration { $$ = $1; }

-    | LexicalDeclaration { $$ = $1; }

     ;
 
 Declaration_
     ;
 
 Declaration_

-    : LexSetRegExp Declaration__ { $$ = $2; }
+    : LexLet LexSetRegExp Declaration__ { $$ = $3; }
+    | LexicalDeclaration { $$ = $1; }

     ;
 
 Declaration
     ;
 
 Declaration


@@ -1243,7 +1383,7 @@ StatementList
 
 StatementListOpt
     : StatementList { $$ = $1; }
 
 StatementListOpt
     : StatementList { $$ = $1; }

-    | LexSetStatement LexSetRegExp { $$ = NULL; }
+    | LexSetStatement LexLet LexSetRegExp { $$ = NULL; }

     ;
 
 StatementListItem
     ;
 
 StatementListItem


@@ -1252,17 +1392,33 @@ StatementListItem
     ;
 /* }}} */
 /* 13.3 Let and Const Declarations {{{ */
     ;
 /* }}} */
 /* 13.3 Let and Const Declarations {{{ */

+LexicalDeclaration_
+    : LetOrConst BindingList { $$ = CYNew CYLet($1, $2); }
+    ;
+

 LexicalDeclaration
 LexicalDeclaration

-    : LetOrConst BindingList Terminator { $$ = CYNew CYVar($2); }
+    : LexicalDeclaration_ Terminator { $$ = $1; }
+    ;
+
+LexLet
+    : { CYMAP(_let__, _let_); }
+    ;
+
+LexOf
+    : { CYMAP(_of__, _of_); }
+    ;
+
+LexBind
+    : { CYMAP(OpenBrace_let, OpenBrace); CYMAP(OpenBracket_let, OpenBracket); } LexOf

     ;
 
 LetOrConst
     ;
 
 LetOrConst

-    : "let"
-    | "const"
+    : LexLet LexSetRegExp "!let" LexBind { $$ = false; }
+    | LexLet LexSetRegExp "const" { $$ = true; }

     ;
 
 BindingList_
     ;
 
 BindingList_

-    : "," BindingList { $$ = $2; }
+    : "," LexBind BindingList { $$ = $3; }

     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 


@@ -1276,8 +1432,12 @@ LexicalBinding
     ;
 /* }}} */
 /* 13.3.2 Variable Statement {{{ */
     ;
 /* }}} */
 /* 13.3.2 Variable Statement {{{ */

+VariableStatement_
+    : Var_ VariableDeclarationList { $$ = CYNew CYVar($2); }
+    ;
+

 VariableStatement
 VariableStatement

-    : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
+    : VariableStatement_ Terminator { $$ = $1; }

     ;
 
 VariableDeclarationList_
     ;
 
 VariableDeclarationList_


@@ -1286,7 +1446,7 @@ VariableDeclarationList_
     ;
 
 VariableDeclarationList
     ;
 
 VariableDeclarationList

-    : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); }
+    : LexBind VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($2, $3); }

     ;
 
 VariableDeclaration
     ;
 
 VariableDeclaration


@@ -1301,11 +1461,11 @@ BindingPattern
     ;
 
 ObjectBindingPattern
     ;
 
 ObjectBindingPattern

-    : BRACE BindingPropertyListOpt "}"
+    : "let {" BindingPropertyListOpt "}"

     ;
 
 ArrayBindingPattern
     ;
 
 ArrayBindingPattern

-    : "[" { CYNOT(@$); }
+    : "let [" { CYNOT(@$); }

     ;
 
 BindingPropertyList_
     ;
 
 BindingPropertyList_


@@ -1328,8 +1488,8 @@ BindingProperty
     ;
 
 BindingElement
     ;
 
 BindingElement

-    : SingleNameBinding { $$ = $1; }
-    | BindingPattern InitializerOpt { CYNOT(@$); }
+    : LexBind SingleNameBinding { $$ = $2; }
+    | LexBind BindingPattern InitializerOpt { CYNOT(@$); }

     ;
 
 SingleNameBinding
     ;
 
 SingleNameBinding


@@ -1346,8 +1506,11 @@ EmptyStatement
     ;
 /* }}} */
 /* 13.5 Expression Statement {{{ */
     ;
 /* }}} */
 /* 13.5 Expression Statement {{{ */

+ExpressionStatement_
+    : Expression { $$ = CYNew CYExpress($1); }
+

 ExpressionStatement
 ExpressionStatement

-    : Expression Terminator { $$ = CYNew CYExpress($1); }
+    : ExpressionStatement_ Terminator { $$ = $1; }

     ;
 /* }}} */
 /* 13.6 The if Statement {{{ */
     ;
 /* }}} */
 /* 13.6 The if Statement {{{ */


@@ -1364,25 +1527,28 @@ IfStatement
 IterationStatement
     : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
     | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
 IterationStatement
     : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
     | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }

-    | "for" "(" LexPushInOn ForStatementInitializer ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
+    | "for" "(" LexPushInOn ForStatementInitializer LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $6, $8, $10); }
+    | "for" "(" LexPushInOn LexLet LexSetRegExp Var_ LexBind BindingIdentifier Initializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForInitialized(CYNew CYDeclaration($8, $9), $12, $14); }

     | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
     | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }

-    | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }
+    | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn AssignmentExpression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }

     ;
 
 ForStatementInitializer
     ;
 
 ForStatementInitializer

-    : ExpressionOpt { $$ = $1; }
-    | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
-    | LexSetRegExp LexicalDeclaration { CYNOT(@$); }
+    : LexLet LexSetRegExp EmptyStatement { $$ = $3; }
+    | LexLet ExpressionStatement_ ";" { $$ = $2; }
+    | LexLet LexSetRegExp VariableStatement_ ";" { $$ = $3; }
+    | LexicalDeclaration_ ";" { $$ = $1; }

     ;
 
 ForInStatementInitializer
     ;
 
 ForInStatementInitializer

-    : LeftHandSideExpression { $$ = $1; }
-    | LexSetRegExp Var_ ForBinding { $$ = $3; }
-    | LexSetRegExp ForDeclaration { $$ = $2; }
+    : LexLet AccessExpression LexCrement { $$ = $2; }
+    | LexLet LexSetRegExp IndirectExpression { $$ = $3; }
+    | LexLet LexSetRegExp Var_ LexBind ForBinding { $$ = CYNew CYForVariable($5); }
+    | ForDeclaration { $$ = $1; }

     ;
 
 ForDeclaration
     ;
 
 ForDeclaration

-    : LetOrConst ForBinding { $$ = $2; }
+    : LetOrConst ForBinding { $$ = CYNew CYForLexical($1, $2); }

     ;
 
 ForBinding
     ;
 
 ForBinding


@@ -1412,7 +1578,7 @@ BreakStatement
 /* }}} */
 /* 13.10 The return Statement {{{ */
 Return
 /* }}} */
 /* 13.10 The return Statement {{{ */
 Return

-    : "!return" LexNewLine
+    : "return" { if (!driver.return_.top()) CYERR(@1, "invalid return"); } LexNewLine

     ;
 
 ReturnStatement
     ;
 
 ReturnStatement


@@ -1456,7 +1622,7 @@ LabelledStatement
 
 LabelledItem
     : Statement { $$ = $1; }
 
 LabelledItem
     : Statement { $$ = $1; }

-    | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; }
+    | LexSetStatement LexLet LexSetRegExp FunctionDeclaration { $$ = $4; }

     ;
 /* }}} */
 /* 13.14 The throw Statement {{{ */
     ;
 /* }}} */
 /* 13.14 The throw Statement {{{ */


@@ -1477,7 +1643,7 @@ TryStatement
     ;
 
 Catch
     ;
 
 Catch

-    : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); }
+    : "catch" "(" LexBind CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($4, $6); }

     ;
 
 Finally
     ;
 
 Finally


@@ -1497,11 +1663,11 @@ DebuggerStatement
 
 /* 14.1 Function Definitions {{{ */
 FunctionDeclaration
 
 /* 14.1 Function Definitions {{{ */
 FunctionDeclaration

-    : ";function" BindingIdentifier "(" FormalParameters ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
+    : ";function" LexOf BindingIdentifier "(" FormalParameters ")" BRACE LexPushSuperOff FunctionBody "}" LexPopSuper { $$ = CYNew CYFunctionStatement($3, $5, $9); }

     ;
 
 FunctionExpression
     ;
 
 FunctionExpression

-    : "function" BindingIdentifierOpt "(" LexPushInOff FormalParameters ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); }
+    : "function" LexOf BindingIdentifierOpt "(" FormalParameters ")" BRACE LexPushSuperOff FunctionBody "}" LexPopSuper { $$ = CYNew CYFunctionExpression($3, $5, $9); }

     ;
 
 StrictFormalParameters
     ;
 
 StrictFormalParameters


@@ -1509,7 +1675,7 @@ StrictFormalParameters
     ;
 
 FormalParameters
     ;
 
 FormalParameters

-    : { $$ = NULL; }
+    : LexBind { $$ = NULL; }

     | FormalParameterList
     ;
 
     | FormalParameterList
     ;
 


@@ -1519,7 +1685,7 @@ FormalParameterList_
     ;
 
 FormalParameterList
     ;
 
 FormalParameterList

-    : FunctionRestParameter { CYNOT(@$); }
+    : LexBind FunctionRestParameter { CYNOT(@$); }

     | FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
     ;
 
     | FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
     ;
 


@@ -1540,26 +1706,30 @@ FunctionStatementList
     ;
 /* }}} */
 /* 14.2 Arrow Function Definitions {{{ */
     ;
 /* }}} */
 /* 14.2 Arrow Function Definitions {{{ */

+LexEqualRight
+    : { CYLIN(EqualRight); }
+    ;
+

 ArrowFunction
 ArrowFunction

-    : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
+    : LexSetRegExp ArrowParameters LexEqualRight "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $6); }

     ;
 
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
     ;
 
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }

-    | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) CYERR(@1, "invalid parameter list"); }
+    | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) $$ = NULL; else { $$ = $1->expression_->Parameter(); if ($$ == NULL) CYERR(@1, "invalid parameter list"); } }

     ;
 
 ConciseBody
     : AssignmentExpression { $$ = CYNew CYReturn($1); }
     ;
 
 ConciseBody
     : AssignmentExpression { $$ = CYNew CYReturn($1); }

-    | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }
+    | LexSetRegExp ";{" FunctionBody "}" { $$ = $3; }

     ;
 /* }}} */
 /* 14.3 Method Definitions {{{ */
 MethodDefinition
     ;
 /* }}} */
 /* 14.3 Method Definitions {{{ */
 MethodDefinition

-    : PropertyName "(" StrictFormalParameters ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYFunctionMethod($1, $3, $6); */ }
+    : PropertyName "(" StrictFormalParameters ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertyMethod($1, $3, $6); }

     | GeneratorMethod { $$ = $1; }
     | GeneratorMethod { $$ = $1; }

-    | "get" PropertyName "(" ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodGet($2, $6); */ }
-    | "set" PropertyName "(" PropertySetParameterList ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodSet($2, $4); */ }
+    | "get" PropertyName "(" ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertyGetter($2, $6); }
+    | "set" PropertyName "(" PropertySetParameterList ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertySetter($2, CYNew CYFunctionParameter($4), $7); }

     ;
 
 PropertySetParameterList
     ;
 
 PropertySetParameterList


@@ -1572,11 +1742,11 @@ GeneratorMethod
     ;
 
 GeneratorDeclaration
     ;
 
 GeneratorDeclaration

-    : ";function" "*" BindingIdentifier "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($3, $5, $8); */ }
+    : ";function" LexOf "*" LexOf BindingIdentifier "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($3, $5, $8); */ }

     ;
 
 GeneratorExpression
     ;
 
 GeneratorExpression

-    : "function" "*" BindingIdentifierOpt "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($3, $5, $8); */ }
+    : "function" LexOf "*" LexOf BindingIdentifierOpt "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($3, $5, $8); */ }

     ;
 
 GeneratorBody
     ;
 
 GeneratorBody


@@ -1588,31 +1758,31 @@ Yield
     ;
 
 YieldExpression
     ;
 
 YieldExpression

-    : Yield LexSetRegExp "\n" { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ }
+    : Yield LexSetRegExp NewLineOpt { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ }

     | Yield AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldValue($2); */ }
     | Yield LexSetRegExp YieldStar AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($4); */ }
     ;
 /* }}} */
 /* 14.5 Class Definitions {{{ */
 ClassDeclaration
     | Yield AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldValue($2); */ }
     | Yield LexSetRegExp YieldStar AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($4); */ }
     ;
 /* }}} */
 /* 14.5 Class Definitions {{{ */
 ClassDeclaration

-    : ";class" BindingIdentifier ClassTail { CYNOT(@$); }
+    : ";class" LexOf BindingIdentifier ClassTail { $$ = CYNew CYClassStatement($3, $4); }

     ;
 
 ClassExpression
     ;
 
 ClassExpression

-    : "class" BindingIdentifierOpt ClassTail { CYNOT(@$); }
+    : "class" LexOf BindingIdentifierOpt ClassTail { $$ = CYNew CYClassExpression($3, $4); }

     ;
 
 ClassTail
     ;
 
 ClassTail

-    : ClassHeritageOpt BRACE ClassBodyOpt "}"
+    : ClassHeritageOpt { driver.class_.push($1); } BRACE LexPushSuperOn ClassBodyOpt "}" LexPopSuper { driver.class_.pop(); $$ = $1; }

     ;
 
 ClassHeritage
     ;
 
 ClassHeritage

-    : "extends" LeftHandSideExpression
+    : "extends" AccessExpression { $$ = CYNew CYClassTail($2); }

     ;
 
 ClassHeritageOpt
     ;
 
 ClassHeritageOpt

-    : ClassHeritage
-    |
+    : ClassHeritage { $$ = $1; }
+    | { $$ = CYNew CYClassTail(NULL); }

     ;
 
 ClassBody
     ;
 
 ClassBody


@@ -1634,8 +1804,8 @@ ClassElementListOpt
     ;
 
 ClassElement
     ;
 
 ClassElement

-    : MethodDefinition
-    | "static" MethodDefinition
+    : MethodDefinition { if (CYFunctionExpression *constructor = $1->Constructor()) driver.class_.top()->constructor_ = constructor; else driver.class_.top()->instance_->*$1; }
+    | "static" MethodDefinition { driver.class_.top()->static_->*$2; }

     | ";"
     ;
 /* }}} */
     | ";"
     ;
 /* }}} */


@@ -1651,7 +1821,7 @@ ScriptBody
 
 ScriptBodyOpt
     : ScriptBody { $$ = $1; }
 
 ScriptBodyOpt
     : ScriptBody { $$ = $1; }

-    | LexSetStatement LexSetRegExp { $$ = NULL; }
+    | LexSetStatement LexLet LexSetRegExp { $$ = NULL; }

     ;
 /* }}} */
 /* 15.2 Modules {{{ */
     ;
 /* }}} */
 /* 15.2 Modules {{{ */


@@ -1678,8 +1848,8 @@ ModuleItemListOpt
     ;
 
 ModuleItem
     ;
 
 ModuleItem

-    : LexSetStatement LexSetRegExp ImportDeclaration
-    | LexSetStatement LexSetRegExp ExportDeclaration
+    : LexSetStatement LexLet LexSetRegExp ImportDeclaration
+    | LexSetStatement LexLet LexSetRegExp ExportDeclaration

     | StatementListItem
     ;
 /* }}} */
     | StatementListItem
     ;
 /* }}} */


@@ -1752,7 +1922,7 @@ ExportDeclaration_
     ;
 
 ExportDeclaration
     ;
 
 ExportDeclaration

-    : "export" LexSetStatement LexSetRegExp ExportDeclaration_
+    : "export" LexSetStatement LexLet LexSetRegExp ExportDeclaration_

     | "export" Declaration
     ;
 
     | "export" Declaration
     ;
 


@@ -1784,14 +1954,14 @@ ExportSpecifier
 /* Cycript (C): Type Encoding {{{ */
 TypeSignifier
     : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); }
 /* Cycript (C): Type Encoding {{{ */
 TypeSignifier
     : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); }

-    | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; }
+    | "(" "*" TypeQualifierRight ")" { $$ = $3; }

     ;
 
 SuffixedType
     : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }
     ;
 
 SuffixedType
     : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }

-    | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }
-    | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); }
-    | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); }
+    | "(" "^" TypeQualifierRight ")" "(" TypedParameterListOpt ")" { $$ = $3; $$->modifier_ = CYNew CYTypeBlockWith($6, $$->modifier_); }
+    | TypeSignifier "(" TypedParameterListOpt ")" { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); }
+    | "(" TypedParameterListOpt ")" { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($2, $$->modifier_); }

     | TypeSignifier { $$ = $1; }
     | { $$ = CYNew CYTypedIdentifier(@$); }
     ;
     | TypeSignifier { $$ = $1; }
     | { $$ = CYNew CYTypedIdentifier(@$); }
     ;


@@ -1853,13 +2023,13 @@ ClassSuperOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

-ClassFieldListOpt
-    : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); }
+ImplementationFieldListOpt
+    : LexSetRegExp TypedIdentifier ";" ImplementationFieldListOpt { $$ = CYNew CYImplementationField($2, $4); }

     | LexSetRegExp { $$ = NULL; }
     ;
 
     | LexSetRegExp { $$ = NULL; }
     ;
 

-ClassFields
-    : BRACE ClassFieldListOpt "}" { $$ = $2; }
+ImplementationFields
+    : BRACE ImplementationFieldListOpt "}" { $$ = $2; }

     ;
 
 MessageScope
     ;
 
 MessageScope


@@ -1873,7 +2043,7 @@ TypeOpt
     ;
 
 MessageParameter
     ;
 
 MessageParameter

-    : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); }
+    : Word ":" TypeOpt BindingIdentifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); }

     ;
 
 MessageParameterList
     ;
 
 MessageParameterList


@@ -1891,7 +2061,7 @@ MessageParameters
     ;
 
 ClassMessageDeclaration
     ;
 
 ClassMessageDeclaration

-    : MessageScope TypeOpt MessageParameters BRACE FunctionBody "}" { $$ = CYNew CYMessage($1, $2, $3, $5); }
+    : MessageScope TypeOpt MessageParameters BRACE LexPushSuperOn FunctionBody "}" LexPopSuper { $$ = CYNew CYMessage($1, $2, $3, $6); }

     ;
 
 ClassMessageDeclarationListOpt
     ;
 
 ClassMessageDeclarationListOpt


@@ -1899,11 +2069,6 @@ ClassMessageDeclarationListOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

-ClassName
-    : Identifier { $$ = $1; }
-    | "(" AssignmentExpression ")" { $$ = $2; }
-    ;
-

 // XXX: this should be AssignmentExpressionNoRight
 ClassProtocols
     : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }
 // XXX: this should be AssignmentExpressionNoRight
 ClassProtocols
     : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }


@@ -1919,8 +2084,8 @@ ClassProtocolListOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

-ClassStatement
-    : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }
+ImplementationStatement
+    : "@implementation" Identifier ClassSuperOpt ClassProtocolListOpt ImplementationFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYImplementation($2, $3, $4, $5, $6); }

     ;
 
 CategoryName
     ;
 
 CategoryName


@@ -1928,17 +2093,17 @@ CategoryName
     ;
 
 CategoryStatement
     ;
 
 CategoryStatement

-    : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
+    : "@implementation" Identifier CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }

     ;
 
 Statement__
     ;
 
 Statement__

-    : ClassStatement { $$ = $1; }
+    : ImplementationStatement { $$ = $1; }

     | CategoryStatement { $$ = $1; }
     ;
 /* }}} */
 /* Cycript (Objective-C): Send Message {{{ */
 VariadicCall
     | CategoryStatement { $$ = $1; }
     ;
 /* }}} */
 /* Cycript (Objective-C): Send Message {{{ */
 VariadicCall

-    : "," AssignmentExpression VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); }
+    : "," AssignmentExpressionClassic VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); }

     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 


@@ -1953,7 +2118,7 @@ SelectorCall_
     ;
 
 SelectorCall
     ;
 
 SelectorCall

-    : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); }
+    : SelectorWordOpt ":" AssignmentExpressionClassic SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); }

     ;
 
 SelectorList
     ;
 
 SelectorList


@@ -1962,8 +2127,8 @@ SelectorList
     ;
 
 MessageExpression
     ;
 
 MessageExpression

-    : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
-    | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); }
+    : "[" AssignmentExpressionClassic { driver.contexts_.push_back($2); } SelectorList "]" { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($2, $4); }
+    | "[" LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" { $$ = CYNew CYSendSuper($5); }

     ;
 
 SelectorExpression_
     ;
 
 SelectorExpression_


@@ -1982,7 +2147,7 @@ SelectorExpressionOpt
 
 PrimaryExpression
     : MessageExpression { $$ = $1; }
 
 PrimaryExpression
     : MessageExpression { $$ = $1; }

-    | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); }
+    | "@selector" "(" SelectorExpression ")" { $$ = CYNew CYSelector($3); }

     ;
 /* }}} */
 @end
     ;
 /* }}} */
 @end


@@ -2023,7 +2188,7 @@ PrimaryExpression
 /* }}} */
 /* Cycript (Objective-C): Block Expressions {{{ */
 PrimaryExpression
 /* }}} */
 /* Cycript (Objective-C): Block Expressions {{{ */
 PrimaryExpression

-    : "^" TypedIdentifier { if ($2->identifier_ != NULL) CYERR($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else CYERR($2->location_, "expected parameters"); }
+    : "^" TypedIdentifier { if ($2->identifier_ != NULL) CYERR($2->location_, "unexpected identifier"); } BRACE FunctionBody "}" { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $5); else CYERR($2->location_, "expected parameters"); }

     ;
 /* }}} */
 /* Cycript (Objective-C): Instance Literals {{{ */
     ;
 /* }}} */
 /* Cycript (Objective-C): Instance Literals {{{ */


@@ -2035,8 +2200,12 @@ PrimaryExpression
 
 @begin C
 /* Cycript (C): Pointer Indirection/Addressing {{{ */
 
 @begin C
 /* Cycript (C): Pointer Indirection/Addressing {{{ */

-LeftHandSideExpression
-    : LexSetRegExp "*" UnaryExpression { $$ = CYNew CYIndirect($3); }
+UnaryExpression_
+    : IndirectExpression { $$ = $1; }
+    ;
+
+IndirectExpression
+    : "*" UnaryExpression { $$ = CYNew CYIndirect($2); }

     ;
 
 UnaryExpression_
     ;
 
 UnaryExpression_


@@ -2070,7 +2239,7 @@ TypedParameterListOpt
     ;
 
 PrimaryExpression
     ;
 
 PrimaryExpression

-    : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); }
+    : "[" LexSetRegExp "&" LexSetRegExp "]" "(" TypedParameterListOpt ")" "->" TypedIdentifier BRACE FunctionBody "}" { $$ = CYNew CYLambda($10, $7, $12); }

     ;
 /* }}} */
 /* Cycript (C): Type Definitions {{{ */
     ;
 /* }}} */
 /* Cycript (C): Type Definitions {{{ */


@@ -2153,7 +2322,7 @@ AttributeIdentifier
 
 PropertySelector_
     : PropertySelector { $$ = $1; }
 
 PropertySelector_
     : PropertySelector { $$ = $1; }

-    | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); }
+    | "[" Expression "]" { $$ = CYNew CYSelector($2); }

     ;
 
 PropertySelector
     ;
 
 PropertySelector


@@ -2266,7 +2435,7 @@ Comprehension
     ;
 
 ComprehensionFor
     ;
 
 ComprehensionFor

-    : "for" "each" "(" LexPushInOn LexicalBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($5, $8); }
+    : "for" "each" "(" LexPushInOn LexBind ForBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($6, $9); }

     ;
 /* }}} */
 /* JavaScript FTL: for each {{{ */
     ;
 /* }}} */
 /* JavaScript FTL: for each {{{ */


@@ -2274,15 +2443,6 @@ IterationStatement
     : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
     ;
 /* }}} */
     : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
     ;
 /* }}} */

-/* JavaScript FTL: let Statements {{{ */
-LetStatement
-    : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
-    ;
-
-Statement__
-    : LetStatement
-    ;
-/* }}} */

 
 /* JavaScript FTW: Array Comprehensions {{{ */
 PrimaryExpression
 
 /* JavaScript FTW: Array Comprehensions {{{ */
 PrimaryExpression


@@ -2290,7 +2450,7 @@ PrimaryExpression
     ;
 
 ArrayComprehension
     ;
 
 ArrayComprehension

-    : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; }
+    : "[" Comprehension "]" { $$ = $2; }

     ;
 
 Comprehension
     ;
 
 Comprehension


@@ -2304,8 +2464,8 @@ ComprehensionTail
     ;
 
 ComprehensionFor
     ;
 
 ComprehensionFor

-    : "for" "(" LexPushInOn LexicalBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForInComprehension($4, $7); }
-    | "for" "(" LexPushInOn LexicalBinding "of" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($4, $7); }
+    : "for" "(" LexPushInOn LexBind ForBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForInComprehension($5, $8); }
+    | "for" "(" LexPushInOn LexBind ForBinding "of" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($5, $8); }

     ;
 
 ComprehensionIf
     ;
 
 ComprehensionIf


@@ -2329,7 +2489,7 @@ RubyProcParameterList_
     ;
 
 RubyProcParameterList
     ;
 
 RubyProcParameterList

-    : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); }
+    : BindingIdentifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); }

     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 


@@ -2340,7 +2500,11 @@ RubyProcParameters
 
 RubyProcParametersOpt
     : RubyProcParameters { $$ = $1; }
 
 RubyProcParametersOpt
     : RubyProcParameters { $$ = $1; }

-    | { $$ = NULL; }
+    | LexSetRegExp { $$ = NULL; }
+    ;
+
+LexOpenBrace
+    : { CYLIN(OpenBrace); }

     ;
 
 RubyProcExpression
     ;
 
 RubyProcExpression


@@ -2348,11 +2512,11 @@ RubyProcExpression
     ;
 
 PrimaryExpression
     ;
 
 PrimaryExpression

-    : BRACE LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); }
+    : BRACE RubyProcParameters StatementListOpt "}" { $$ = CYNew CYRubyProc($2, $3); }

     ;
 
 PostfixExpression
     ;
 
 PostfixExpression

-    : LeftHandSideExpression RubyProcExpression { $$ = CYNew CYRubyBlock($1, $2); }
+    : PostfixExpression LexOpenBrace RubyProcExpression { $$ = CYNew CYRubyBlock($1, $3); }

     ;
 /* }}} */
 
     ;
 /* }}} */