Use implicit properties on older, broken runtimes.

[cycript.git] / Parser.ypp.in

diff --git a/Parser.ypp.in b/Parser.ypp.in
index b76b4b41e5eeffdbfbcb48e1c4a2e5d5a4fe3b3b..0d8e87d50109910107dd4d3b02bff9953f3e0516 100644 (file)
--- a/Parser.ypp.in
+++ b/Parser.ypp.in
@@ -1,5 +1,5 @@
-/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2015  Jay Freeman (saurik)
+/* Cycript - The Truly Universal Scripting Language
+ * Copyright (C) 2009-2016  Jay Freeman (saurik)

 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */


@@ -27,6 +27,7 @@
 #include "Driver.hpp"
 #include "Parser.hpp"
 #include "Stack.hpp"
 #include "Driver.hpp"
 #include "Parser.hpp"
 #include "Stack.hpp"

+#include "Syntax.hpp"

 #define CYNew new(driver.pool_)
 
 @begin ObjectiveC
 #define CYNew new(driver.pool_)
 
 @begin ObjectiveC


@@ -48,11 +49,13 @@
 %union { CYBinding *binding_; }
 %union { CYBindings *bindings_; }
 %union { CYBoolean *boolean_; }
 %union { CYBinding *binding_; }
 %union { CYBindings *bindings_; }
 %union { CYBoolean *boolean_; }

+%union { CYBraced *braced_; }

 %union { CYClause *clause_; }
 %union { cy::Syntax::Catch *catch_; }
 %union { CYClassTail *classTail_; }
 %union { CYComprehension *comprehension_; }
 %union { CYElement *element_; }
 %union { CYClause *clause_; }
 %union { cy::Syntax::Catch *catch_; }
 %union { CYClassTail *classTail_; }
 %union { CYComprehension *comprehension_; }
 %union { CYElement *element_; }

+%union { CYEnumConstant *constant_; }

 %union { CYExpression *expression_; }
 %union { CYFalse *false_; }
 %union { CYVariable *variable_; }
 %union { CYExpression *expression_; }
 %union { CYFalse *false_; }
 %union { CYVariable *variable_; }


@@ -61,6 +64,7 @@
 %union { CYForInInitializer *forin_; }
 %union { CYFunctionParameter *functionParameter_; }
 %union { CYIdentifier *identifier_; }
 %union { CYForInInitializer *forin_; }
 %union { CYFunctionParameter *functionParameter_; }
 %union { CYIdentifier *identifier_; }

+%union { CYImportSpecifier *import_; }

 %union { CYInfix *infix_; }
 %union { CYLiteral *literal_; }
 %union { CYMethod *method_; }
 %union { CYInfix *infix_; }
 %union { CYLiteral *literal_; }
 %union { CYMethod *method_; }


@@ -70,7 +74,7 @@
 %union { CYParenthetical *parenthetical_; }
 %union { CYProperty *property_; }
 %union { CYPropertyName *propertyName_; }
 %union { CYParenthetical *parenthetical_; }
 %union { CYProperty *property_; }
 %union { CYPropertyName *propertyName_; }

-%union { CYRubyProc *rubyProc_; }
+%union { CYTypeSigning signing_; }

 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }
 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }


@@ -80,16 +84,22 @@
 %union { CYWord *word_; }
 
 @begin C
 %union { CYWord *word_; }
 
 @begin C

+%union { CYTypeIntegral *integral_; }
+%union { CYTypeStructField *structField_; }

 %union { CYTypeModifier *modifier_; }
 %union { CYTypeSpecifier *specifier_; }
 %union { CYTypeModifier *modifier_; }
 %union { CYTypeSpecifier *specifier_; }

-%union { CYTypedIdentifier *typedIdentifier_; }
+%union { CYTypedFormal *typedFormal_; }
+%union { CYTypedLocation *typedLocation_; }
+%union { CYTypedName *typedName_; }

 %union { CYTypedParameter *typedParameter_; }
 %union { CYTypedParameter *typedParameter_; }

+%union { CYType *typedThing_; }

 @end
 
 @begin ObjectiveC
 @end
 
 @begin ObjectiveC

+%union { CYObjCKeyValue *keyValue_; }
+%union { CYImplementationField *implementationField_; }

 %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


@@ -179,6 +189,13 @@ type; })
         yyla.type = yytranslate_(token::to); \
 } while (false)
 
         yyla.type = yytranslate_(token::to); \
 } while (false)
 

+#define CYHLD(location, token) do { \
+    if (driver.hold_ != empty_symbol) \
+        CYERR(location, "unexpected hold"); \
+    driver.hold_ = yyla.type; \
+    yyla.type = yytranslate_(token); \
+} while (false)
+

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


@@ -213,6 +230,9 @@ type; })
         case CYMarkModule:
             driver.hold_ = yytranslate_(token::MarkModule);
             break;
         case CYMarkModule:
             driver.hold_ = yytranslate_(token::MarkModule);
             break;

+        case CYMarkExpression:
+            driver.hold_ = yytranslate_(token::MarkExpression);
+            break;

     }
 };
 
     }
 };
 


@@ -248,13 +268,11 @@ type; })
 %token SlashRight "/>"
 %token LeftSlash "</"
 
 %token SlashRight "/>"
 %token LeftSlash "</"
 

-%token ColonColon "::"

 %token PeriodPeriod ".."
 @end
 
 @begin E4X ObjectiveC
 %token At "@"
 %token PeriodPeriod ".."
 @end
 
 @begin E4X ObjectiveC
 %token At "@"

-%token Pound "#"

 @end
 
 %token Ampersand "&"
 @end
 
 %token Ampersand "&"


@@ -300,10 +318,13 @@ type; })
 %token Tilde "~"
 
 %token Colon ":"
 %token Tilde "~"
 
 %token Colon ":"

+%token ColonColon "::"

 %token Comma ","
 %token Question "?"
 %token SemiColon ";"
 %token Comma ","
 %token Question "?"
 %token SemiColon ";"

+%token Pound "#"

 %token NewLine "\n"
 %token NewLine "\n"

+%token __ ""

 
 %token Comment
 
 
 %token Comment
 


@@ -329,6 +350,7 @@ type; })
 %token _typedef_ "typedef"
 %token _unsigned_ "unsigned"
 %token _signed_ "signed"
 %token _typedef_ "typedef"
 %token _unsigned_ "unsigned"
 %token _signed_ "signed"

+%token _struct_ "struct"

 %token _extern_ "extern"
 @end
 
 %token _extern_ "extern"
 @end
 


@@ -354,6 +376,7 @@ type; })
 %token _null_ "null"
 %token _true_ "true"
 
 %token _null_ "null"
 %token _true_ "true"
 

+%token _as_ "as"

 %token _break_ "break"
 %token _case_ "case"
 %token _catch_ "catch"
 %token _break_ "break"
 %token _case_ "case"
 %token _catch_ "catch"


@@ -408,6 +431,7 @@ type; })
 %token _goto_ "goto"
 %token _implements_ "implements"
 %token _int_ "int"
 %token _goto_ "goto"
 %token _implements_ "implements"
 %token _int_ "int"

+%token ___int128_ "__int128"

 %token _interface_ "interface"
 %token _let_ "let"
 %token _let__ "!let"
 %token _interface_ "interface"
 %token _let_ "let"
 %token _let__ "!let"


@@ -416,14 +440,18 @@ type; })
 %token _package_ "package"
 %token _private_ "private"
 %token _protected_ "protected"
 %token _package_ "package"
 %token _private_ "private"
 %token _protected_ "protected"

+%token ___proto___ "__proto__"

 %token _prototype_ "prototype"
 %token _public_ "public"
 %token _prototype_ "prototype"
 %token _public_ "public"

+%token ___restrict_ "__restrict"
+%token _restrict_ "restrict"

 %token _set_ "set"
 %token _short_ "short"
 %token _static_ "static"
 %token _synchronized_ "synchronized"
 %token _throws_ "throws"
 %token _transient_ "transient"
 %token _set_ "set"
 %token _short_ "short"
 %token _static_ "static"
 %token _synchronized_ "synchronized"
 %token _throws_ "throws"
 %token _transient_ "transient"

+%token _typeid_ "typeid"

 %token _volatile_ "volatile"
 %token _yield_ "yield"
 %token _yield__ "!yield"
 %token _volatile_ "volatile"
 %token _yield_ "yield"
 %token _yield__ "!yield"


@@ -439,7 +467,6 @@ type; })
 %token _SEL_ "SEL"
 @end
 
 %token _SEL_ "SEL"
 @end
 

-%token _auto_ "auto"

 %token _each_ "each"
 %token _of_ "of"
 %token _of__ "!of"
 %token _each_ "each"
 %token _of_ "of"
 %token _of__ "!of"


@@ -450,7 +477,7 @@ type; })
 @end
 
 %token AutoComplete
 @end
 
 %token AutoComplete

-%token YieldStar
+%token YieldStar "yield *"

 
 %token <identifier_> Identifier_
 %token <number_> NumericLiteral
 
 %token <identifier_> Identifier_
 %token <number_> NumericLiteral


@@ -469,11 +496,11 @@ type; })
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <target_> ArrayComprehension
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <target_> ArrayComprehension

+%type <element_> ArrayElement

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

-%type <expression_> AssignmentExpressionOpt

 %type <identifier_> BindingIdentifier
 %type <identifier_> BindingIdentifierOpt
 %type <bindings_> BindingList_
 %type <identifier_> BindingIdentifier
 %type <identifier_> BindingIdentifierOpt
 %type <bindings_> BindingList_


@@ -485,6 +512,8 @@ type; })
 %type <binding_> BindingElement
 %type <expression_> BitwiseORExpression
 %type <expression_> BitwiseXORExpression
 %type <binding_> BindingElement
 %type <expression_> BitwiseORExpression
 %type <expression_> BitwiseXORExpression

+%type <target_> BracedExpression_
+%type <target_> BracedExpression

 %type <statement_> BreakStatement
 %type <statement_> BreakableStatement
 %type <expression_> CallExpression_
 %type <statement_> BreakStatement
 %type <statement_> BreakableStatement
 %type <expression_> CallExpression_


@@ -512,6 +541,7 @@ type; })
 %type <statement_> Declaration_
 %type <statement_> Declaration
 %type <clause_> DefaultClause
 %type <statement_> Declaration_
 %type <statement_> Declaration
 %type <clause_> DefaultClause

+%type <element_> ElementList_

 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt
 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt


@@ -521,6 +551,9 @@ type; })
 %type <expression_> ExpressionOpt
 %type <for_> ExpressionStatement_
 %type <statement_> ExpressionStatement
 %type <expression_> ExpressionOpt
 %type <for_> ExpressionStatement_
 %type <statement_> ExpressionStatement

+%type <statement_> ExternC
+%type <statement_> ExternCStatement
+%type <statement_> ExternCStatementListOpt

 %type <finally_> Finally
 %type <binding_> ForBinding
 %type <forin_> ForDeclaration
 %type <finally_> Finally
 %type <binding_> ForBinding
 %type <forin_> ForDeclaration


@@ -530,6 +563,7 @@ type; })
 %type <functionParameter_> FormalParameterList_
 %type <functionParameter_> FormalParameterList
 %type <functionParameter_> FormalParameters
 %type <functionParameter_> FormalParameterList_
 %type <functionParameter_> FormalParameterList
 %type <functionParameter_> FormalParameters

+%type <string_> FromClause

 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <target_> FunctionExpression
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <target_> FunctionExpression


@@ -543,9 +577,18 @@ type; })
 %type <identifier_> IdentifierNoOf
 %type <identifier_> IdentifierType
 %type <identifier_> IdentifierTypeNoOf
 %type <identifier_> IdentifierNoOf
 %type <identifier_> IdentifierType
 %type <identifier_> IdentifierTypeNoOf

+%type <identifier_> IdentifierTypeOpt

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

+%type <import_> ImportClause
+%type <statement_> ImportDeclaration
+%type <import_> ImportSpecifier
+%type <identifier_> ImportedBinding
+%type <import_> ImportedDefaultBinding
+%type <import_> ImportsList_
+%type <import_> ImportsList
+%type <import_> ImportsListOpt

 %type <target_> IndirectExpression
 %type <expression_> Initializer
 %type <expression_> InitializerOpt
 %type <target_> IndirectExpression
 %type <expression_> Initializer
 %type <expression_> InitializerOpt


@@ -566,8 +609,16 @@ type; })
 %type <access_> MemberAccess
 %type <target_> MemberExpression
 %type <method_> MethodDefinition
 %type <access_> MemberAccess
 %type <target_> MemberExpression
 %type <method_> MethodDefinition

+%type <statement_> ModuleBody
+%type <statement_> ModuleBodyOpt
+%type <statement_> ModuleItem
+%type <statement_> ModuleItemList
+%type <statement_> ModuleItemListOpt

 %type <module_> ModulePath
 %type <module_> ModulePath

+%type <string_> ModuleSpecifier

 %type <expression_> MultiplicativeExpression
 %type <expression_> MultiplicativeExpression

+%type <import_> NameSpaceImport
+%type <import_> NamedImports

 %type <target_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %type <target_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral


@@ -583,7 +634,7 @@ type; })
 %type <bool_> RegularExpressionSlash
 %type <expression_> RelationalExpression
 %type <statement_> ReturnStatement
 %type <bool_> RegularExpressionSlash
 %type <expression_> RelationalExpression
 %type <statement_> ReturnStatement

-%type <rubyProc_> RubyProcExpression
+%type <braced_> BracedParameter

 %type <functionParameter_> RubyProcParameterList_
 %type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameters
 %type <functionParameter_> RubyProcParameterList_
 %type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameters


@@ -607,6 +658,7 @@ type; })
 %type <span_> TemplateSpans
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement
 %type <span_> TemplateSpans
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement

+%type <statement_> TypeDefinition

 %type <expression_> UnaryExpression_
 %type <expression_> UnaryExpression
 %type <binding_> VariableDeclaration
 %type <expression_> UnaryExpression_
 %type <expression_> UnaryExpression
 %type <binding_> VariableDeclaration


@@ -616,24 +668,44 @@ type; })
 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word
 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word

+%type <word_> WordNoUnary

 @begin ObjectiveC
 %type <word_> WordOpt
 @end
 %type <expression_> YieldExpression
 
 @begin C
 @begin ObjectiveC
 %type <word_> WordOpt
 @end
 %type <expression_> YieldExpression
 
 @begin C

-%type <specifier_> IntegerType
-%type <specifier_> IntegerTypeOpt
-%type <typedIdentifier_> PrefixedType
+%type <constant_> EnumConstantListOpt_
+%type <constant_> EnumConstantListOpt
+%type <number_> IntegerNumber
+%type <integral_> IntegerType
+%type <integral_> IntegerTypeOpt
+%type <typedName_> PrefixedType
+%type <specifier_> PrimitiveReference

 %type <specifier_> PrimitiveType
 %type <specifier_> PrimitiveType

-%type <typedIdentifier_> SuffixedType
-%type <typedIdentifier_> TypeSignifier
+%type <structField_> StructFieldListOpt
+%type <typedName_> SuffixedType
+%type <typedName_> SuffixedTypeOpt
+%type <typedName_> TypeSignifier
+%type <typedName_> TypeSignifierNone
+%type <typedName_> TypeSignifierOpt
+%type <signing_> TypeSigning
+%type <modifier_> ParameterTail

 %type <modifier_> TypeQualifierLeft
 %type <modifier_> TypeQualifierLeft

-%type <typedIdentifier_> TypeQualifierRight
-%type <typedIdentifier_> TypedIdentifier
-%type <typedParameter_> TypedParameterList_
-%type <typedParameter_> TypedParameterList
-%type <typedParameter_> TypedParameterListOpt
+%type <modifier_> TypeQualifierLeftOpt
+%type <typedName_> TypeQualifierRight
+%type <typedName_> TypeQualifierRightOpt
+%type <typedName_> TypedIdentifierDefinition
+%type <typedThing_> TypedIdentifierEncoding
+%type <typedName_> TypedIdentifierField
+%type <typedName_> TypedIdentifierMaybe
+%type <typedLocation_> TypedIdentifierNo
+%type <typedName_> TypedIdentifierTagged
+%type <typedName_> TypedIdentifierYes
+%type <typedFormal_> TypedParameterList_
+%type <typedFormal_> TypedParameterList
+%type <typedFormal_> TypedParameterListOpt
+%type <typedParameter_> TypedParameters

 @end
 
 @begin ObjectiveC
 @end
 
 @begin ObjectiveC


@@ -642,14 +714,16 @@ type; })
 %type <statement_> CategoryStatement
 %type <expression_> ClassSuperOpt
 %type <expression_> ConditionalExpressionClassic
 %type <statement_> CategoryStatement
 %type <expression_> ClassSuperOpt
 %type <expression_> ConditionalExpressionClassic

-%type <implementationField_> ImplementationFieldListOpt
-%type <implementationField_> ImplementationFields

 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt
 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt
 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt
 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt

+%type <implementationField_> ImplementationFieldListOpt

 %type <statement_> ImplementationStatement
 %type <statement_> ImplementationStatement

+%type <keyValue_> KeyValuePairList_
+%type <keyValue_> KeyValuePairList
+%type <keyValue_> KeyValuePairListOpt

 %type <target_> MessageExpression
 %type <messageParameter_> MessageParameter
 %type <messageParameter_> MessageParameters
 %type <target_> MessageExpression
 %type <messageParameter_> MessageParameter
 %type <messageParameter_> MessageParameters


@@ -663,7 +737,7 @@ type; })
 %type <selector_> SelectorExpressionOpt
 %type <argument_> SelectorList
 %type <word_> SelectorWordOpt
 %type <selector_> SelectorExpressionOpt
 %type <argument_> SelectorList
 %type <word_> SelectorWordOpt

-%type <typedIdentifier_> TypeOpt
+%type <typedThing_> TypeOpt

 %type <argument_> VariadicCall
 @end
 
 %type <argument_> VariadicCall
 @end
 


@@ -691,17 +765,22 @@ type; })
 /* Token Priorities {{{ */
 %nonassoc "if"
 %nonassoc "else"
 /* Token Priorities {{{ */
 %nonassoc "if"
 %nonassoc "else"

+
+%nonassoc ":"
+%nonassoc "!yield"

 /* }}} */
 
 %start Program
 %token MarkModule
 %token MarkScript
 /* }}} */
 
 %start Program
 %token MarkModule
 %token MarkScript

+%token MarkExpression

 
 %%
 
 Program
     : MarkScript Script
     | MarkModule Module
 
 %%
 
 Program
     : MarkScript Script
     | MarkModule Module

+    | MarkExpression Expression[expression] { driver.context_ = $expression; }

     ;
 
 /* Lexer State {{{ */
     ;
 
 /* Lexer State {{{ */


@@ -711,17 +790,23 @@ LexPopIn: { driver.in_.pop(); };
 
 LexPushReturnOn: { driver.return_.push(true); };
 LexPopReturn: { driver.return_.pop(); };
 
 LexPushReturnOn: { driver.return_.push(true); };
 LexPopReturn: { driver.return_.pop(); };

+Return: "return"[return] { if (!driver.return_.top()) CYERR(@return, "invalid return"); };

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

+Super: "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); };

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

-LexNewLine
-    : { CYLEX(); if (driver.hold_ != empty_symbol) CYERR(@$, "unexpected hold"); if (driver.newline_) { driver.hold_ = yyla.type; yyla.type = yytranslate_(cy::parser::token::NewLine); } }
+LexNewLineOrOpt
+    : { CYLEX(); if (driver.newline_) { CYHLD(@$, tk::NewLine); } }
+    ;
+
+LexNewLineOrNot
+    : { CYLEX(); CYHLD(@$, driver.newline_ ? tk::NewLine : tk::__); }

     ;
 
 LexNoStar
     ;
 
 LexNoStar


@@ -758,9 +843,8 @@ IdentifierName
     | "instanceof" { $$ = CYNew CYWord("instanceof"); }
     ;
 
     | "instanceof" { $$ = CYNew CYWord("instanceof"); }
     ;
 

-Word
+WordNoUnary

     : IdentifierNoOf[pass] { $$ = $pass; }
     : IdentifierNoOf[pass] { $$ = $pass; }

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

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


@@ -770,7 +854,6 @@ Word
     | "continue" { $$ = CYNew CYWord("continue"); }
     | "debugger" { $$ = CYNew CYWord("debugger"); }
     | "default" { $$ = CYNew CYWord("default"); }
     | "continue" { $$ = CYNew CYWord("continue"); }
     | "debugger" { $$ = CYNew CYWord("debugger"); }
     | "default" { $$ = CYNew CYWord("default"); }

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

     | "do" { $$ = CYNew CYWord("do"); }
     | "else" { $$ = CYNew CYWord("else"); }
     | "enum" { $$ = CYNew CYWord("enum"); }
     | "do" { $$ = CYNew CYWord("do"); }
     | "else" { $$ = CYNew CYWord("else"); }
     | "enum" { $$ = CYNew CYWord("enum"); }


@@ -783,7 +866,6 @@ Word
     | "import" { $$ = CYNew CYWord("import"); }
     | "!in" { $$ = CYNew CYWord("in"); }
     | "!of" { $$ = CYNew CYWord("of"); }
     | "import" { $$ = CYNew CYWord("import"); }
     | "!in" { $$ = CYNew CYWord("in"); }
     | "!of" { $$ = CYNew CYWord("of"); }

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

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


@@ -792,11 +874,16 @@ Word
     | "throw" { $$ = CYNew CYWord("throw"); }
     | "true" { $$ = CYNew CYWord("true"); }
     | "try" { $$ = CYNew CYWord("try"); }
     | "throw" { $$ = CYNew CYWord("throw"); }
     | "true" { $$ = CYNew CYWord("true"); }
     | "try" { $$ = CYNew CYWord("try"); }

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

     | "var" { $$ = CYNew CYWord("var"); }
     | "var" { $$ = CYNew CYWord("var"); }

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

     | "while" { $$ = CYNew CYWord("while"); }
     | "with" { $$ = CYNew CYWord("with"); }
     | "while" { $$ = CYNew CYWord("while"); }
     | "with" { $$ = CYNew CYWord("with"); }

+    ;
+
+Word
+    : WordNoUnary[pass] { $$ = $pass; }
+    | "delete" { $$ = CYNew CYWord("delete"); }
+    | "typeof" { $$ = CYNew CYWord("typeof"); }
+    | "void" { $$ = CYNew CYWord("void"); }

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


@@ -834,9 +921,23 @@ StrictSemi
     : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
     ;
 
     : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
     ;
 

+NewLineNot
+    : LexNewLineOrNot ""
+    ;
+
+NewLineOpt
+    : LexNewLineOrNot "\n"
+    | NewLineNot
+    ;
+

 TerminatorSoft
 TerminatorSoft

+    : LexNewLineOrNot "\n" StrictSemi
+    | NewLineNot LexOf Terminator
+    ;
+
+TerminatorHard

     : ";"
     : ";"

-    | "\n" StrictSemi
+    | error { if (yyla.type_get() != yyeof_) CYERR(@error, "required semi-colon"); else CYEOK(); } StrictSemi

     ;
 
 Terminator
     ;
 
 Terminator


@@ -875,6 +976,7 @@ LabelIdentifier
 IdentifierTypeNoOf
     : Identifier_[pass] { $$ = $pass; }
     | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
 IdentifierTypeNoOf
     : Identifier_[pass] { $$ = $pass; }
     | "abstract" { $$ = CYNew CYIdentifier("abstract"); }

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

     | "await" { $$ = CYNew CYIdentifier("await"); }
     | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
     | "byte" { $$ = CYNew CYIdentifier("byte"); }
     | "await" { $$ = CYNew CYIdentifier("await"); }
     | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
     | "byte" { $$ = CYNew CYIdentifier("byte"); }


@@ -896,6 +998,7 @@ IdentifierTypeNoOf
     | "package" { $$ = CYNew CYIdentifier("package"); }
     | "private" { $$ = CYNew CYIdentifier("private"); }
     | "protected" { $$ = CYNew CYIdentifier("protected"); }
     | "package" { $$ = CYNew CYIdentifier("package"); }
     | "private" { $$ = CYNew CYIdentifier("private"); }
     | "protected" { $$ = CYNew CYIdentifier("protected"); }

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

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


@@ -903,6 +1006,7 @@ IdentifierTypeNoOf
     | "target" { $$ = CYNew CYIdentifier("target"); }
     | "throws" { $$ = CYNew CYIdentifier("throws"); }
     | "transient" { $$ = CYNew CYIdentifier("transient"); }
     | "target" { $$ = CYNew CYIdentifier("target"); }
     | "throws" { $$ = CYNew CYIdentifier("throws"); }
     | "transient" { $$ = CYNew CYIdentifier("transient"); }

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

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


@@ -917,18 +1021,24 @@ IdentifierType
     | "of" { $$ = CYNew CYIdentifier("of"); }
     ;
 
     | "of" { $$ = CYNew CYIdentifier("of"); }
     ;
 

+IdentifierTypeOpt
+    : IdentifierType[pass] { $$ = $pass; }
+    | { $$ = NULL; }
+    ;
+

 IdentifierNoOf
     : IdentifierTypeNoOf
     | "char" { $$ = CYNew CYIdentifier("char"); }
     | "int" { $$ = CYNew CYIdentifier("int"); }
 IdentifierNoOf
     : IdentifierTypeNoOf
     | "char" { $$ = CYNew CYIdentifier("char"); }
     | "int" { $$ = CYNew CYIdentifier("int"); }

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

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

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

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

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

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

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

     | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); }
 @end
 @begin ObjectiveC
     | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); }
 @end
 @begin ObjectiveC


@@ -981,10 +1091,19 @@ ArrayLiteral
     : "[" ElementListOpt[elements] "]" { $$ = CYNew CYArray($elements); }
     ;
 
     : "[" ElementListOpt[elements] "]" { $$ = CYNew CYArray($elements); }
     ;
 

-ElementList
-    : AssignmentExpressionOpt[value] "," ElementListOpt[next] { $$ = CYNew CYElementValue($value, $next); }
+ArrayElement
+    : AssignmentExpression[value] { $$ = CYNew CYElementValue($value); }

     | LexOf "..." AssignmentExpression[values] { $$ = CYNew CYElementSpread($values); }
     | LexOf "..." AssignmentExpression[values] { $$ = CYNew CYElementSpread($values); }

-    | AssignmentExpression[value] { $$ = CYNew CYElementValue($value, NULL); }
+    ;
+
+ElementList_
+    : "," ElementListOpt[elements] { $$ = $elements; } 
+    | { $$ = NULL; }
+    ;
+
+ElementList
+    : ArrayElement[element] ElementList_[next] { $$ = $element; $$->SetNext($next); }
+    | LexOf "," ElementListOpt[next] { $$ = CYNew CYElementValue(NULL, $next); }

     ;
 
 ElementListOpt
     ;
 
 ElementListOpt


@@ -1075,8 +1194,8 @@ MemberExpression
     ;
 
 SuperProperty
     ;
 
 SuperProperty

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

     ;
 
 MetaProperty
     ;
 
 MetaProperty


@@ -1104,7 +1223,7 @@ CallExpression
     ;
 
 SuperCall
     ;
 
 SuperCall

-    : "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); } Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); }
+    : Super Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); }

     ;
 
 Arguments
     ;
 
 Arguments


@@ -1132,15 +1251,15 @@ AccessExpression
     ;
 
 LeftHandSideExpression
     ;
 
 LeftHandSideExpression

-    : AccessExpression[pass] LexNewLine { $$ = $pass; }
+    : BracedExpression[pass] { $$ = $pass; }

     | IndirectExpression[pass] { $$ = $pass; }
     ;
 /* }}} */
 /* 12.4 Postfix Expressions {{{ */
 PostfixExpression
     | IndirectExpression[pass] { $$ = $pass; }
     ;
 /* }}} */
 /* 12.4 Postfix Expressions {{{ */
 PostfixExpression

-    : AccessExpression[lhs] LexNewLine { $$ = $lhs; }
-    | AccessExpression[lhs] LexNewLine "++" { $$ = CYNew CYPostIncrement($lhs); }
-    | AccessExpression[lhs] LexNewLine "--" { $$ = CYNew CYPostDecrement($lhs); }
+    : BracedExpression[pass] { $$ = $pass; }
+    | AccessExpression[lhs] LexNewLineOrOpt "++" { $$ = CYNew CYPostIncrement($lhs); }
+    | AccessExpression[lhs] LexNewLineOrOpt "--" { $$ = CYNew CYPostDecrement($lhs); }

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


@@ -1158,7 +1277,6 @@ UnaryExpression_
 
 UnaryExpression
     : PostfixExpression[expression] { $$ = $expression; }
 
 UnaryExpression
     : PostfixExpression[expression] { $$ = $expression; }

-    | PostfixExpression[expression] "\n" { $$ = $expression; }

     | UnaryExpression_[pass] { $$ = $pass; }
     ;
 /* }}} */
     | UnaryExpression_[pass] { $$ = $pass; }
     ;
 /* }}} */


@@ -1274,11 +1392,6 @@ AssignmentExpression
     | ArrowFunction[pass] { $$ = $pass; }
     | LexOf LeftHandSideAssignment[assignment] AssignmentExpression[rhs] { $assignment->SetRight($rhs); $$ = $assignment; }
     ;
     | ArrowFunction[pass] { $$ = $pass; }
     | LexOf LeftHandSideAssignment[assignment] AssignmentExpression[rhs] { $assignment->SetRight($rhs); $$ = $assignment; }
     ;

-
-AssignmentExpressionOpt
-    : AssignmentExpression[pass] { $$ = $pass; }
-    | LexOf { $$ = NULL; }
-    ;

 /* }}} */
 /* 12.15 Comma Operator ( , ) {{{ */
 Expression
 /* }}} */
 /* 12.15 Comma Operator ( , ) {{{ */
 Expression


@@ -1348,7 +1461,7 @@ Block
     ;
 
 StatementList
     ;
 
 StatementList

-    : StatementListItem[statement] StatementListOpt[next] { $statement->SetNext($next); $$ = $statement; }
+    : StatementListItem[statement] StatementListOpt[next] { $$ = $statement; CYSetLast($$) = $next; }

     ;
 
 StatementListOpt
     ;
 
 StatementListOpt


@@ -1527,7 +1640,7 @@ ForStatementInitializer
     ;
 
 ForInStatementInitializer
     ;
 
 ForInStatementInitializer

-    : LexLet LexOf AccessExpression[pass] LexNewLine { $$ = $pass; }
+    : LexLet LexOf BracedExpression[pass] { $$ = $pass; }

     | LexLet LexOf IndirectExpression[pass] { $$ = $pass; }
     | LexLet LexOf Var_ LexBind ForBinding[binding] { $$ = CYNew CYForVariable($binding); }
     | ForDeclaration[pass] { $$ = $pass; }
     | LexLet LexOf IndirectExpression[pass] { $$ = $pass; }
     | LexLet LexOf Var_ LexBind ForBinding[binding] { $$ = CYNew CYForVariable($binding); }
     | ForDeclaration[pass] { $$ = $pass; }


@@ -1544,24 +1657,20 @@ ForBinding
 /* }}} */
 /* 13.8 The continue Statement {{{ */
 ContinueStatement
 /* }}} */
 /* 13.8 The continue Statement {{{ */
 ContinueStatement

-    : "continue" LexNewLine TerminatorSoft { $$ = CYNew CYContinue(NULL); }
-    | "continue" LexNewLine Identifier[label] Terminator { $$ = CYNew CYContinue($label); }
+    : "continue" TerminatorSoft { $$ = CYNew CYContinue(NULL); }
+    | "continue" NewLineNot LexOf Identifier[label] Terminator { $$ = CYNew CYContinue($label); }

     ;
 /* }}} */
 /* 13.9 The break Statement {{{ */
 BreakStatement
     ;
 /* }}} */
 /* 13.9 The break Statement {{{ */
 BreakStatement

-    : "break" LexNewLine TerminatorSoft { $$ = CYNew CYBreak(NULL); }
-    | "break" LexNewLine Identifier[label] Terminator { $$ = CYNew CYBreak($label); }
+    : "break" TerminatorSoft { $$ = CYNew CYBreak(NULL); }
+    | "break" NewLineNot LexOf Identifier[label] Terminator { $$ = CYNew CYBreak($label); }

     ;
 /* }}} */
 /* 13.10 The return Statement {{{ */
     ;
 /* }}} */
 /* 13.10 The return Statement {{{ */

-Return
-    : "return"[return] { if (!driver.return_.top()) CYERR(@return, "invalid return"); }
-    ;
-

 ReturnStatement
 ReturnStatement

-    : Return LexNewLine LexOf TerminatorSoft { $$ = CYNew CYReturn(NULL); }
-    | Return LexNewLine Expression[value] Terminator { $$ = CYNew CYReturn($value); }
+    : Return TerminatorSoft { $$ = CYNew CYReturn(NULL); }
+    | Return NewLineNot Expression[value] Terminator { $$ = CYNew CYReturn($value); }

     ;
 /* }}} */
 /* 13.11 The with Statement {{{ */
     ;
 /* }}} */
 /* 13.11 The with Statement {{{ */


@@ -1605,8 +1714,8 @@ LabelledItem
 /* }}} */
 /* 13.14 The throw Statement {{{ */
 ThrowStatement
 /* }}} */
 /* 13.14 The throw Statement {{{ */
 ThrowStatement

-    : "throw"[throw] LexNewLine LexOf TerminatorSoft { CYERR(@throw, "throw without exception"); }
-    | "throw" LexNewLine Expression[value] Terminator { $$ = CYNew cy::Syntax::Throw($value); }
+    : "throw"[throw] TerminatorSoft { CYERR(@throw, "throw without exception"); }
+    | "throw" NewLineNot Expression[value] Terminator { $$ = CYNew cy::Syntax::Throw($value); }

     ;
 /* }}} */
 /* 13.15 The try Statement {{{ */
     ;
 /* }}} */
 /* 13.15 The try Statement {{{ */


@@ -1681,7 +1790,7 @@ FunctionStatementList
 /* }}} */
 /* 14.2 Arrow Function Definitions {{{ */
 ArrowFunction
 /* }}} */
 /* 14.2 Arrow Function Definitions {{{ */
 ArrowFunction

-    : ArrowParameters[parameters] LexNewLine "=>" LexNoBrace ConciseBody[code] { $$ = CYNew CYFatArrow($parameters, $code); }
+    : ArrowParameters[parameters] LexNewLineOrOpt "=>" LexNoBrace ConciseBody[code] { $$ = CYNew CYFatArrow($parameters, $code); }

     ;
 
 ArrowParameters
     ;
 
 ArrowParameters


@@ -1723,15 +1832,11 @@ GeneratorBody
     : LexPushYieldOn FunctionStatementList[code] LexPopYield { $$ = $code; }
     ;
 
     : LexPushYieldOn FunctionStatementList[code] LexPopYield { $$ = $code; }
     ;
 

-Yield
-    : "!yield" LexNewLine LexNoStar
-    ;
-

 YieldExpression
 YieldExpression

-    : Yield LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ }
-    | Yield LexOf "\n" { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ }
-    | Yield AssignmentExpression[value] { CYNOT(@$); /* $$ = CYNew CYYieldValue($value); */ }
-    | Yield LexOf YieldStar AssignmentExpression[generator] { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($generator); */ }
+    : "!yield" LexNewLineOrNot "\n" LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ }
+    | "!yield" LexNewLineOrNot "" LexNoStar LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } %prec "!yield"
+    | "!yield" LexNewLineOrNot "" LexNoStar AssignmentExpression[value] { CYNOT(@$); /* $$ = CYNew CYYieldValue($value); */ }
+    | "!yield" LexNewLineOrNot "" LexNoStar LexOf "yield *" AssignmentExpression[generator] { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($generator); */ }

     ;
 /* }}} */
 /* 14.5 Class Definitions {{{ */
     ;
 /* }}} */
 /* 14.5 Class Definitions {{{ */


@@ -1797,88 +1902,88 @@ ScriptBodyOpt
 /* }}} */
 /* 15.2 Modules {{{ */
 Module
 /* }}} */
 /* 15.2 Modules {{{ */
 Module

-    : ModuleBodyOpt
+    : ModuleBodyOpt[code] { driver.script_ = CYNew CYScript($code); }

     ;
 
 ModuleBody
     ;
 
 ModuleBody

-    : ModuleItemList
+    : ModuleItemList[pass] { $$ = $pass; }

     ;
 
 ModuleBodyOpt
     ;
 
 ModuleBodyOpt

-    : ModuleBody
-    |
+    : ModuleBody[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf { $$ = NULL; }

     ;
 
 ModuleItemList
     ;
 
 ModuleItemList

-    : ModuleItemListOpt ModuleItem
+    : ModuleItem[statement] ModuleItemListOpt[next] { $$ = $statement; CYSetLast($$) = $next; }

     ;
 
 ModuleItemListOpt
     ;
 
 ModuleItemListOpt

-    : ModuleItemList
-    |
+    : ModuleItemList[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf { $$ = NULL; }

     ;
 
 ModuleItem
     ;
 
 ModuleItem

-    : LexSetStatement LexLet LexOf ImportDeclaration
-    | LexSetStatement LexLet LexOf ExportDeclaration
-    | StatementListItem
+    : LexSetStatement LexLet LexOf ImportDeclaration[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf ExportDeclaration { CYNOT(@$); }
+    | StatementListItem[pass] { $$ = $pass; }

     ;
 /* }}} */
 /* 15.2.2 Imports {{{ */
 ImportDeclaration
     ;
 /* }}} */
 /* 15.2.2 Imports {{{ */
 ImportDeclaration

-    : "import" ImportClause FromClause Terminator
-    | "import" LexOf ModuleSpecifier Terminator
+    : "import" ImportClause[specifiers] FromClause[module] Terminator { $$ = CYNew CYImportDeclaration($specifiers, $module); }
+    | "import" LexOf ModuleSpecifier[module] Terminator { $$ = CYNew CYImportDeclaration(NULL, $module); }

     ;
 
 ImportClause
     ;
 
 ImportClause

-    : ImportedDefaultBinding
-    | LexOf NameSpaceImport
-    | LexOf NamedImports
-    | ImportedDefaultBinding "," NameSpaceImport
-    | ImportedDefaultBinding "," NamedImports
+    : ImportedDefaultBinding[default] { $$ = $default; }
+    | LexOf NameSpaceImport[pass] { $$ = $pass; }
+    | LexOf NamedImports[pass] { $$ = $pass; }
+    | ImportedDefaultBinding[default] "," NameSpaceImport[next] { $$ = $default; CYSetLast($$) = $next; }
+    | ImportedDefaultBinding[default] "," NamedImports[next] { $$ = $default; CYSetLast($$) = $next; }

     ;
 
 ImportedDefaultBinding
     ;
 
 ImportedDefaultBinding

-    : ImportedBinding
+    : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(CYNew CYIdentifier("default"), $binding); }

     ;
 
 NameSpaceImport
     ;
 
 NameSpaceImport

-    : "*" "as" ImportedBinding
+    : "*" "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(NULL, $binding); }

     ;
 
 NamedImports
     ;
 
 NamedImports

-    : "{" ImportsListOpt "}"
+    : "{" ImportsListOpt[pass] "}" { $$ = $pass; }

     ;
 
 FromClause
     ;
 
 FromClause

-    : "from" ModuleSpecifier
+    : "from" ModuleSpecifier[pass] { $$ = $pass; }

     ;
 
 ImportsList_
     ;
 
 ImportsList_

-    : "," ImportsListOpt
-    |
+    : "," ImportsListOpt[pass] { $$ = $pass; }
+    | { $$ = NULL; }

     ;
 
 ImportsList
     ;
 
 ImportsList

-    : ImportSpecifier ImportsList_
+    : ImportSpecifier[import] ImportsList_[next] { $$ = $import; CYSetLast($$) = $next; }

     ;
 
 ImportsListOpt
     ;
 
 ImportsListOpt

-    : ImportsList
-    | LexOf
+    : ImportsList[pass] { $$ = $pass; }
+    | LexOf { $$ = NULL; }

     ;
 
 ImportSpecifier
     ;
 
 ImportSpecifier

-    : ImportedBinding
-    | LexOf IdentifierName "as" ImportedBinding
+    : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($binding, $binding); }
+    | LexOf IdentifierName[name] "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($name, $binding); }

     ;
 
 ModuleSpecifier
     ;
 
 ModuleSpecifier

-    : StringLiteral
+    : StringLiteral[pass] { $$ = $pass; }

     ;
 
 ImportedBinding
     ;
 
 ImportedBinding

-    : BindingIdentifier
+    : BindingIdentifier[pass] { $$ = $pass; }

     ;
 /* }}} */
 /* 15.2.3 Exports {{{ */
     ;
 /* }}} */
 /* 15.2.3 Exports {{{ */


@@ -1924,64 +2029,175 @@ ExportSpecifier
 @begin C
 /* Cycript (C): Type Encoding {{{ */
 TypeSignifier
 @begin C
 /* Cycript (C): Type Encoding {{{ */
 TypeSignifier

-    : IdentifierType[identifier] { $$ = CYNew CYTypedIdentifier(@identifier, $identifier); }
-    | "(" "*" TypeQualifierRight[typed] ")" { $$ = $typed; }
+    : IdentifierType[name] { $$ = CYNew CYTypedName(@name, $name); }
+    | StringLiteral[name] { $$ = CYNew CYTypedName(@name, $name); }
+    | NumericLiteral[name] { $$ = CYNew CYTypedName(@name, $name); }
+    | "(" "*" TypeQualifierRightOpt[typed] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
+    ;
+
+TypeSignifierNone
+    : { $$ = CYNew CYTypedName(@$); }
+    ;
+
+TypeSignifierOpt
+    : TypeSignifier[pass] { $$ = $pass; }
+    | TypeSignifierNone[pass] { $$ = $pass; }
+    ;
+
+Restrict
+    : "__restrict"
+    | "restrict"
+    ;
+
+RestrictOpt
+    : Restrict
+    |
+    ;
+
+ParameterModifier
+    : "throw" "(" ")"
+    ;
+
+ParameterModifierOpt
+    : ParameterModifier
+    |
+    ;
+
+ParameterTail
+    : TypedParameterListOpt[formal] ")" ParameterModifierOpt { $$ = CYNew CYTypeFunctionWith($formal->variadic_, $formal->parameters_); }

     ;
 
 SuffixedType
     ;
 
 SuffixedType

-    : SuffixedType[typed] "[" NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); }
-    | "(" "^" TypeQualifierRight[typed] ")" "(" TypedParameterListOpt[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeBlockWith($parameters, $$->modifier_); }
-    | TypeSignifier[typed] "(" TypedParameterListOpt[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeFunctionWith($parameters, $$->modifier_); }
-    | "("[parenthesis] TypedParameterListOpt[parameters] ")" { $$ = CYNew CYTypedIdentifier(@parenthesis); $$->modifier_ = CYNew CYTypeFunctionWith($parameters, $$->modifier_); }
-    | TypeSignifier[pass] { $$ = $pass; }
-    | { $$ = CYNew CYTypedIdentifier(@$); }
+    : SuffixedTypeOpt[typed] "[" RestrictOpt NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); }
+    | "(" "^" TypeQualifierRightOpt[typed] ")" "(" TypedParameters[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeBlockWith($parameters, $$->modifier_); }
+    | TypeSignifier[typed] "(" ParameterTail[modifier] { $$ = $typed; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    | "("[parenthesis] ParameterTail[modifier] { $$ = CYNew CYTypedName(@parenthesis); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    ;
+
+SuffixedTypeOpt
+    : SuffixedType[pass] { $$ = $pass; }
+    | TypeSignifierOpt[pass] { $$ = $pass; }

     ;
 
 PrefixedType
     ;
 
 PrefixedType

-    : "*" TypeQualifierRight[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
+    : "*" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }

     ;
 
 TypeQualifierLeft
     ;
 
 TypeQualifierLeft

-    : { $$ = NULL; }
-    | "const" TypeQualifierLeft[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeConstant(); }
-    | "volatile" TypeQualifierLeft[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeVolatile(); }
+    : "const" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeConstant(); }
+    | "volatile" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeVolatile(); }
+    ;
+
+TypeQualifierLeftOpt
+    : TypeQualifierLeft[pass] { $$ = $pass; }
+    | { $$ = NULL; }

     ;
 
 TypeQualifierRight
     ;
 
 TypeQualifierRight

-    : PrefixedType[pass] { $$ = $pass; }
-    | SuffixedType[pass] { $$ = $pass; }
-    | "const" TypeQualifierRight[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); }
-    | "volatile" TypeQualifierRight[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); }
+    : SuffixedType[pass] { $$ = $pass; }
+    | PrefixedType[pass] { $$ = $pass; }
+    | "const" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); }
+    | "volatile" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); }
+    | Restrict TypeQualifierRightOpt[typed] { $$ = $typed; }
+    ;
+
+TypeQualifierRightOpt
+    : TypeQualifierRight[pass] { $$ = $pass; }
+    | TypeSignifierOpt[pass] { $$ = $pass; }

     ;
 
 IntegerType
     ;
 
 IntegerType

-    : "int" { $$ = CYNew CYTypeVariable("int"); }
-    | "unsigned" IntegerTypeOpt[specifier] { $$ = CYNew CYTypeUnsigned($specifier); }
-    | "signed" IntegerTypeOpt[specifier] { $$ = CYNew CYTypeSigned($specifier); }
-    | "long" IntegerTypeOpt[specifier] { $$ = CYNew CYTypeLong($specifier); }
-    | "short" IntegerTypeOpt[specifier] { $$ = CYNew CYTypeShort($specifier); }
+    : "int" { $$ = CYNew CYTypeIntegral(CYTypeNeutral); }
+    | "unsigned" IntegerTypeOpt[integral] { $$ = $integral->Unsigned(); if ($$ == NULL) CYERR(@1, "incompatible unsigned"); }
+    | "signed" IntegerTypeOpt[integral] { $$ = $integral->Signed(); if ($$ == NULL) CYERR(@1, "incompatible signed"); }
+    | "long" IntegerTypeOpt[integral] { $$ = $integral->Long(); if ($$ == NULL) CYERR(@1, "incompatible long"); }
+    | "short" IntegerTypeOpt[integral] { $$ = $integral->Short(); if ($$ == NULL) CYERR(@1, "incompatible short"); }

     ;
 
 IntegerTypeOpt
     : IntegerType[pass] { $$ = $pass; }
     ;
 
 IntegerTypeOpt
     : IntegerType[pass] { $$ = $pass; }

-    | { $$ = CYNew CYTypeVariable("int"); }
+    | { $$ = CYNew CYTypeIntegral(CYTypeNeutral); }
+    ;
+
+StructFieldListOpt
+    : TypedIdentifierField[typed] ";" StructFieldListOpt[next] { $$ = CYNew CYTypeStructField($typed, $typed->name_, $next); }
+    | { $$ = NULL; }
+    ;
+
+IntegerNumber
+    : NumericLiteral[pass] { $$ = $pass; }
+    | "-" NumericLiteral[positive] { $$ = $positive; $$->value_ = -$$->value_; }
+    ;
+
+EnumConstantListOpt_
+    : "," EnumConstantListOpt[pass] { $$ = $pass; }
+    | { $$ = NULL; }
+    ;
+
+EnumConstantListOpt
+    : IdentifierType[name] "=" IntegerNumber[value] EnumConstantListOpt_[next] { $$ = CYNew CYEnumConstant($name, $value, $next); }
+    | { $$ = NULL; }
+    ;
+
+TypeSigning
+    : { $$ = CYTypeNeutral; }
+    | "signed" { $$ = CYTypeSigned; }
+    | "unsigned" { $$ = CYTypeUnsigned; }

     ;
 
 PrimitiveType
     : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); }
     | IntegerType[pass] { $$ = $pass; }
     ;
 
 PrimitiveType
     : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); }
     | IntegerType[pass] { $$ = $pass; }

-    | "void" { $$ = CYNew CYTypeVoid(); }
-    | "char" { $$ = CYNew CYTypeVariable("char"); }
-    | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); }
-    | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); }
+    | TypeSigning[signing] "char" { $$ = CYNew CYTypeCharacter($signing); }
+    | TypeSigning[signing] "__int128" { $$ = CYNew CYTypeInt128($signing); }
+    ;
+
+PrimitiveReference
+    : PrimitiveType[pass] { $$ = $pass; }
+    | "struct" IdentifierType[name] { $$ = CYNew CYTypeReference(CYTypeReferenceStruct, $name); }
+    | "enum" IdentifierType[name] { $$ = CYNew CYTypeReference(CYTypeReferenceEnum, $name); }
+    | "struct" AutoComplete { driver.mode_ = CYDriver::AutoStruct; YYACCEPT; }
+    | "enum" AutoComplete { driver.mode_ = CYDriver::AutoEnum; YYACCEPT; }
+    ;
+
+TypedIdentifierMaybe
+    : TypeQualifierLeft[modifier] "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    | "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); }
+    | TypeQualifierLeftOpt[modifier] PrimitiveReference[specifier] TypeQualifierRightOpt[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    ;
+
+TypedIdentifierYes
+    : TypedIdentifierMaybe[typed] { if ($typed->name_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; }
+    ;
+
+TypedIdentifierNo
+    : TypedIdentifierMaybe[typed] { if ($typed->name_ != NULL) CYERR($typed->location_, "unexpected identifier"); $$ = $typed; }

     ;
 
     ;
 

-TypedIdentifier
-    : TypeQualifierLeft[modifier] PrimitiveType[specifier] TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+TypedIdentifierTagged
+    : TypeQualifierLeftOpt[modifier] "struct" "{" StructFieldListOpt[fields] "}" TypeQualifierRightOpt[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeStruct(NULL, CYNew CYStructTail($fields)); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    | TypeQualifierLeftOpt[modifier] "enum" ":" PrimitiveType[specifier] "{" EnumConstantListOpt[constants] "}" TypeQualifierRightOpt[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeEnum(NULL, $specifier, $constants); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    ;
+
+TypedIdentifierField
+    : TypedIdentifierYes[pass] { $$ = $pass; }
+    | TypedIdentifierTagged[typed] { if ($typed->name_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; }
+    ;
+
+TypedIdentifierEncoding
+    : TypedIdentifierNo[pass] { $$ = $pass; }
+    | TypedIdentifierTagged[typed] { if ($typed->name_ != NULL) CYERR($typed->location_, "unexpected identifier"); $$ = $typed; }
+    | "void" TypeSignifierNone[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); }
+    ;
+
+TypedIdentifierDefinition
+    : TypedIdentifierYes[pass] { $$ = $pass; }
+    | TypeQualifierLeftOpt[modifier] "struct" IdentifierTypeOpt[name] "{" StructFieldListOpt[fields] "}" TypeQualifierRightOpt[typed] { if ($typed->name_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; $$->specifier_ = CYNew CYTypeStruct($name, CYNew CYStructTail($fields)); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+    | "void" TypeSignifier[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); }

     ;
 
 PrimaryExpression
     ;
 
 PrimaryExpression

-    : "@encode" "(" TypedIdentifier[typed] ")" { $$ = CYNew CYEncodedType($typed); }
+    : "@encode" "(" TypedIdentifierEncoding[typed] ")" { $$ = CYNew CYEncodedType($typed); }

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


@@ -1995,26 +2211,22 @@ ClassSuperOpt
     ;
 
 ImplementationFieldListOpt
     ;
 
 ImplementationFieldListOpt

-    : TypedIdentifier[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $next); }
+    : TypedIdentifierField[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $typed->name_, $next); }

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

-ImplementationFields
-    : "{" ImplementationFieldListOpt[fields] "}" { $$ = $fields; }
-    ;
-

 MessageScope
     : "+" { $$ = false; }
     | "-" { $$ = true; }
     ;
 
 TypeOpt
 MessageScope
     : "+" { $$ = false; }
     | "-" { $$ = true; }
     ;
 
 TypeOpt

-    : "(" TypedIdentifier[type] ")" { if ($type->identifier_ != NULL) CYERR($type->location_, "unexpected identifier"); $$ = $type; }
-    | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); }
+    : "(" TypedIdentifierNo[type] ")" { $$ = $type; }
+    | { $$ = CYNew CYType(CYNew CYTypeVariable("id")); }

     ;
 
 MessageParameter
     ;
 
 MessageParameter

-    : Word[tag] ":" TypeOpt[type] BindingIdentifier[identifier] { $type->identifier_ = $identifier; $$ = CYNew CYMessageParameter($tag, $type); }
+    : Word[tag] ":" TypeOpt[type] BindingIdentifier[identifier] { $$ = CYNew CYMessageParameter($tag, $type, $identifier); }

     ;
 
 MessageParameterList
     ;
 
 MessageParameterList


@@ -2023,12 +2235,12 @@ MessageParameterList
 
 MessageParameterListOpt
     : MessageParameterList[pass] { $$ = $pass; }
 
 MessageParameterListOpt
     : MessageParameterList[pass] { $$ = $pass; }

-    | { $$ = NULL; }
+    | TypedParameterList_[formal] { if ($formal->variadic_) CYERR(@$, "unsupported variadic"); /*XXX*/ if ($formal->parameters_ != NULL) CYERR(@$, "temporarily unsupported"); $$ = NULL; }

     ;
 
 MessageParameters
     : MessageParameterList[pass] { $$ = $pass; }
     ;
 
 MessageParameters
     : MessageParameterList[pass] { $$ = $pass; }

-    | Word[tag] { $$ = CYNew CYMessageParameter($tag, NULL); }
+    | Word[tag] { $$ = CYNew CYMessageParameter($tag); }

     ;
 
 ClassMessageDeclaration
     ;
 
 ClassMessageDeclaration


@@ -2056,7 +2268,7 @@ ClassProtocolListOpt
     ;
 
 ImplementationStatement
     ;
 
 ImplementationStatement

-    : "@implementation" Identifier[name] ClassSuperOpt[extends] ClassProtocolListOpt[protocols] ImplementationFields[fields] ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYImplementation($name, $extends, $protocols, $fields, $messages); }
+    : "@implementation" Identifier[name] ClassSuperOpt[extends] ClassProtocolListOpt[protocols] "{" ImplementationFieldListOpt[fields] "}" ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYImplementation($name, $extends, $protocols, $fields, $messages); }

     ;
 
 CategoryName
     ;
 
 CategoryName


@@ -2141,15 +2353,29 @@ BoxableExpression
     | BooleanLiteral[pass] { $$ = $pass; }
     | NumericLiteral[pass] { $$ = $pass; }
     | StringLiteral[pass] { $$ = $pass; }
     | BooleanLiteral[pass] { $$ = $pass; }
     | NumericLiteral[pass] { $$ = $pass; }
     | StringLiteral[pass] { $$ = $pass; }

-    | ArrayLiteral[pass] { $$ = $pass; }
-    | ObjectLiteral[pass] { $$ = $pass; }

     | CoverParenthesizedExpressionAndArrowParameterList[pass] { $$ = $pass; }
     | "YES" { $$ = CYNew CYTrue(); }
     | "NO" { $$ = CYNew CYFalse(); }
     ;
 
     | CoverParenthesizedExpressionAndArrowParameterList[pass] { $$ = $pass; }
     | "YES" { $$ = CYNew CYTrue(); }
     | "NO" { $$ = CYNew CYFalse(); }
     ;
 

+KeyValuePairList_
+    : "," KeyValuePairListOpt[next] { $$ = $next; }
+    | { $$ = NULL; }
+
+KeyValuePairList
+    : AssignmentExpression[key] ":" AssignmentExpression[value] KeyValuePairList_[next] { $$ = CYNew CYObjCKeyValue($key, $value, $next); }
+    ;
+
+KeyValuePairListOpt
+    : KeyValuePairList[pass] { $$ = $pass; }
+    | LexOf { $$ = NULL; }
+    ;
+

 PrimaryExpression
     : "@" BoxableExpression[expression] { $$ = CYNew CYBox($expression); }
 PrimaryExpression
     : "@" BoxableExpression[expression] { $$ = CYNew CYBox($expression); }

+    | "@" "[" ElementListOpt[elements] "]" { $$ = CYNew CYObjCArray($elements); }
+    | "@" "{" KeyValuePairListOpt[pairs] "}" { $$ = CYNew CYObjCDictionary($pairs); }
+

     | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); }
     | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); }
     | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); }
     | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); }
     | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); }
     | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); }


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

-    : "^" TypedIdentifier[type] { if ($type->identifier_ != NULL) CYERR($type->location_, "unexpected identifier"); } "{" FunctionBody[code] "}" { if (CYTypeFunctionWith *function = $type->Function()) $$ = CYNew CYObjCBlock($type, function->parameters_, $code); else CYERR($type->location_, "expected parameters"); }
+    : "^" TypedIdentifierNo[type] "{" FunctionBody[code] "}" { if (CYTypeFunctionWith *function = $type->Function()) $$ = CYNew CYObjCBlock($type, function->parameters_, $code); else CYERR($type->location_, "expected parameters"); }

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


@@ -2189,41 +2415,94 @@ MemberAccess
     | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; }
     ;
 /* }}} */
     | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; }
     ;
 /* }}} */

-/* Cycript (C): auto Compatibility {{{ */
-Var_
-    : "auto"
-    ;
-/* }}} */

 /* Cycript (C): Lambda Expressions {{{ */
 TypedParameterList_
     : "," TypedParameterList[parameters] { $$ = $parameters; }
 /* Cycript (C): Lambda Expressions {{{ */
 TypedParameterList_
     : "," TypedParameterList[parameters] { $$ = $parameters; }

-    | { $$ = NULL; }
+    | { $$ = CYNew CYTypedFormal(false); }

     ;
 
 TypedParameterList
     ;
 
 TypedParameterList

-    : TypedIdentifier[typed] TypedParameterList_[next] { $$ = CYNew CYTypedParameter($typed, $next); }
+    : TypedIdentifierMaybe[typed] TypedParameterList_[formal] { CYIdentifier *identifier; if ($typed->name_ == NULL) identifier = NULL; else { identifier = $typed->name_->Identifier(); if (identifier == NULL) CYERR($typed->location_, "invalid identifier"); } $$ = $formal; $$->parameters_ = CYNew CYTypedParameter($typed, identifier, $$->parameters_); }
+    | "..." { $$ = CYNew CYTypedFormal(true); }

     ;
 
 TypedParameterListOpt
     : TypedParameterList[pass] { $$ = $pass; }
     ;
 
 TypedParameterListOpt
     : TypedParameterList[pass] { $$ = $pass; }

-    | { $$ = NULL; }
+    | "void" { $$ = CYNew CYTypedFormal(false); }
+    | { $$ = CYNew CYTypedFormal(false); }
+    ;
+
+TypedParameters
+    : TypedParameterListOpt[formal] { if ($formal->variadic_) CYERR(@$, "unsupported variadic"); $$ = $formal->parameters_; }
+    ;
+
+PrimaryExpression
+    : "[" LexOf "&" "]" "(" TypedParameters[parameters] ")" "->" TypedIdentifierNo[type] "{" FunctionBody[code] "}" { $$ = CYNew CYLambda($type, $parameters, $code); }
+    ;
+/* }}} */
+/* Cycript (C): Structure Definitions {{{ */
+IdentifierNoOf
+    : "struct" NewLineOpt { $$ = CYNew CYIdentifier("struct"); }
+    ;
+
+Statement__
+    : "struct" NewLineNot IdentifierType[name] "{" StructFieldListOpt[fields] "}" { $$ = CYNew CYStructDefinition($name, CYNew CYStructTail($fields)); }

     ;
 
 PrimaryExpression
     ;
 
 PrimaryExpression

-    : "[" LexOf "&" "]" "(" TypedParameterListOpt[parameters] ")" "->" TypedIdentifier[type] "{" FunctionBody[code] "}" { $$ = CYNew CYLambda($type, $parameters, $code); }
+    : "(" LexOf "struct" NewLineOpt IdentifierType[name] TypeQualifierRightOpt[typed] ")" { $typed->specifier_ = CYNew CYTypeReference(CYTypeReferenceStruct, $name); $$ = CYNew CYTypeExpression($typed); }
+    | "(" LexOf "struct" NewLineOpt AutoComplete { driver.mode_ = CYDriver::AutoStruct; YYACCEPT; }

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

+IdentifierNoOf
+    : "typedef" NewLineOpt { $$ = CYNew CYIdentifier("typedef"); }
+    ;
+
+TypeDefinition
+    : "typedef" NewLineNot TypedIdentifierDefinition[typed] TerminatorHard { CYIdentifier *identifier; if ($typed->name_ == NULL) identifier = NULL; else { identifier = $typed->name_->Identifier(); if (identifier == NULL) CYERR($typed->location_, "invalid identifier"); } $$ = CYNew CYTypeDefinition($typed, identifier); }
+    ;
+

 Statement__
 Statement__

-    : "typedef" TypedIdentifier[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($typed); }
+    : TypeDefinition[pass] { $$ = $pass; }
+    ;
+
+PrimaryExpression
+    : "(" LexOf "typedef" NewLineOpt TypedIdentifierEncoding[typed] ")" { $$ = CYNew CYTypeExpression($typed); }

     ;
 /* }}} */
 /* Cycript (C): extern "C" {{{ */
     ;
 /* }}} */
 /* Cycript (C): extern "C" {{{ */

+IdentifierNoOf
+    : "extern" NewLineOpt { $$ = CYNew CYIdentifier("extern"); }
+    ;
+
+ExternCStatement
+    : TypedIdentifierField[typed] TerminatorHard { CYIdentifier *identifier; if ($typed->name_ == NULL) identifier = NULL; else { identifier = $typed->name_->Identifier(); if (identifier == NULL) CYERR($typed->location_, "invalid identifier"); } $$ = CYNew CYExternalDefinition(CYNew CYString("C"), $typed, identifier); }
+    | TypeDefinition[pass] { $$ = $pass; }
+    ;
+
+ExternCStatementListOpt
+    : ExternCStatement[statement] ExternCStatementListOpt[next] { $$ = $statement; CYSetLast($$) = $next; }
+    | { $$ = NULL; }
+    ;
+
+ExternC
+    : "{" ExternCStatementListOpt[pass] "}" { $$ = $pass; }
+    | ExternCStatement[pass] { $$ = $pass; }
+    ;
+
+ABI
+    : StringLiteral[abi] { if (strcmp($abi->Value(), "C") != 0) CYERR(@abi, "unknown extern binding"); }
+    ;
+

 Statement__
 Statement__

-    : "extern" StringLiteral[abi] { if (strcmp($abi->Value(), "C") != 0) CYERR(@abi, "unknown extern binding"); } TypedIdentifier[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($abi, $typed); }
+    : "extern" NewLineNot ABI[abi] ExternC[pass] { $$ = $pass; }

     ;
     ;

-/* }}} */

 
 

+PrimaryExpression
+    : "(" LexOf "extern" NewLineOpt ABI[abi] TypedIdentifierField[typed] ")" { $$ = CYNew CYExternalExpression(CYNew CYString("C"), $typed, $typed->name_); }
+    ;
+/* }}} */

 @end
 
 @begin E4X
 @end
 
 @begin E4X


@@ -2443,16 +2722,23 @@ ComprehensionIf
     : "if" "(" AssignmentExpression[test] ")" { $$ = CYNew CYIfComprehension($test); }
     ;
 /* }}} */
     : "if" "(" AssignmentExpression[test] ")" { $$ = CYNew CYIfComprehension($test); }
     ;
 /* }}} */

-/* JavaScript FTW: Coalesce Operator {{{ */
-ConditionalExpression
-    : LogicalORExpression[test] "?" LexPushInOff LexOf ":" LexPopIn AssignmentExpression[false] { $$ = CYNew CYCondition($test, $test, $false); }
-    ;
-/* }}} */

 /* JavaScript FTW: Named Arguments {{{ */
 ArgumentList
 /* JavaScript FTW: Named Arguments {{{ */
 ArgumentList

-    : LexOf Word[tag] ":" AssignmentExpression[value] ArgumentList_[next] { $$ = CYNew CYArgument($tag, $value, $next); }
+    : LexOf WordNoUnary[tag] ":" AssignmentExpression[value] ArgumentList_[next] { $$ = CYNew CYArgument($tag, $value, $next); }
+    ;
+/* }}} */
+/* JavaScript FTW: Subscript Access {{{ */
+MemberAccess
+    : "." "[" AssignmentExpression[property] "]" { $$ = CYNew CYSubscriptMember(NULL, $property); }
+    ;
+/* }}} */
+
+/* JavaScript FTW: Java "Anonymous Inner Classes" {{{ */
+BracedParameter
+    : "{" PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYExtend(NULL, $properties); }

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

+

 /* JavaScript FTW: Ruby Blocks {{{ */
 RubyProcParameterList_
     : "," RubyProcParameterList[parameters] { $$ = $parameters; }
 /* JavaScript FTW: Ruby Blocks {{{ */
 RubyProcParameterList_
     : "," RubyProcParameterList[parameters] { $$ = $parameters; }


@@ -2474,16 +2760,34 @@ RubyProcParametersOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

-RubyProcExpression
-    : "{" RubyProcParametersOpt[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); }
+BracedParameter
+    : ";{" RubyProcParametersOpt[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyBlock(NULL, CYNew CYRubyProc($parameters, $code)); }

     ;
 
 PrimaryExpression
     : "{" RubyProcParameters[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); }
     ;
 
     ;
 
 PrimaryExpression
     : "{" RubyProcParameters[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); }
     ;
 

-PostfixExpression
-    : PostfixExpression[lhs] RubyProcExpression[rhs] LexNewLine { $$ = CYNew CYRubyBlock($lhs, $rhs); }
+BracedExpression_
+    : AccessExpression[pass] LexNewLineOrOpt { $$ = $pass; }
+    | BracedExpression_[lhs] { if (!$lhs->IsNew()) CYMAP(OpenBrace_, OpenBrace); } BracedParameter[rhs] LexNewLineOrOpt { $rhs->SetLeft($lhs); $$ = $rhs; }
+    ;
+
+BracedExpression
+    : BracedExpression_[pass] "\n" { $$ = $pass; }
+    | BracedExpression_[pass] { $$ = $pass; }
+    ;
+/* }}} */
+/* JavaScript FTW: Ruby Scopes {{{ */
+MemberAccess
+    : "::" "[" Expression[property] "]" { $$ = CYNew CYResolveMember(NULL, $property); }
+    | "::" IdentifierName[property] { $$ = CYNew CYResolveMember(NULL, CYNew CYString($property)); }
+    | "::" AutoComplete { driver.mode_ = CYDriver::AutoResolve; YYACCEPT; }
+    ;
+/* }}} */
+/* JavaScript FTW: Ruby Symbols {{{ */
+PrimaryExpression
+    : ":" Word[name] { $$ = CYNew CYSymbol($name->Word()); }

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