Changes in src/Parser/parser.yy [0442f93f:46da46b]

File:

• src/Parser/parser.yy (modified) (140 diffs)

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  7 14:32:28 2023
-// Update Count     : 6341
+// Last Modified On : Mon Nov 21 22:34:30 2022
+// Update Count     : 5848
 //
 
@@ -44 +44 @@
 
 #include <cstdio>
-#include <sstream>
 #include <stack>
 using namespace std;
 
-#include "SynTree/Type.h"                               // for Type
-#include "DeclarationNode.h"                            // for DeclarationNode, ...
-#include "ExpressionNode.h"                             // for ExpressionNode, ...
-#include "InitializerNode.h"                            // for InitializerNode, ...
-#include "ParserTypes.h"
-#include "StatementNode.h"                              // for build_...
+#include "SynTree/Declaration.h"
+#include "ParseNode.h"
 #include "TypedefTable.h"
 #include "TypeData.h"
+#include "SynTree/LinkageSpec.h"
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 
-#include "SynTree/Attribute.h"                                                  // for Attribute
+#include "SynTree/Attribute.h"     // for Attribute
 
 // lex uses __null in a boolean context, it's fine.
@@ -67 +63 @@
 
 extern DeclarationNode * parseTree;
-extern ast::Linkage::Spec linkage;
+extern LinkageSpec::Spec linkage;
 extern TypedefTable typedefTable;
 
-stack<ast::Linkage::Spec> linkageStack;
+stack<LinkageSpec::Spec> linkageStack;
 
 bool appendStr( string & to, string & from ) {
@@ -108 +104 @@
         assert( declList );
         // printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout );
-        DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec );
+        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( typeSpec );
         // printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout );
         // cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name;
 
-        for ( DeclarationNode * cur = dynamic_cast<DeclarationNode *>( declList->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
+        for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
@@ -203 +199 @@
 } // fieldDecl
 
-#define NEW_ZERO new ExpressionNode( build_constantInteger( yylloc, *new string( "0" ) ) )
-#define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
+#define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) )
+#define NEW_ONE  new ExpressionNode( build_constantInteger( *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
-#define MISSING_ANON_FIELD "syntax error, missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
-#define MISSING_LOW "syntax error, missing low value for up-to range so index is uninitialized."
-#define MISSING_HIGH "syntax error, missing high value for down-to range so index is uninitialized."
-
-static ForCtrl * makeForCtrl(
-                const CodeLocation & location,
-                DeclarationNode * init,
-                enum OperKinds compop,
-                ExpressionNode * comp,
-                ExpressionNode * inc ) {
-        // Wrap both comp/inc if they are non-null.
-        if ( comp ) comp = new ExpressionNode( build_binary_val( location,
-                compop,
-                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
-                comp ) );
-        if ( inc ) inc = new ExpressionNode( build_binary_val( location,
-                // choose += or -= for upto/downto
-                compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
-                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
-                inc ) );
-        // The StatementNode call frees init->name, it must happen later.
-        return new ForCtrl( new StatementNode( init ), comp, inc );
-}
-
-ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+#define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
+#define MISSING_LOW "Missing low value for up-to range so index is uninitialized."
+#define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
+
+ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
-                SemanticError( yylloc, "syntax error, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
+                SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
         } // if
         if ( index->next ) {
-                SemanticError( yylloc, "syntax error, multiple loop indexes disallowed in for-loop declaration." );
+                SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." );
         } // if
-        DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
-        return makeForCtrl( location, initDecl, compop, comp, inc );
+        return new ForCtrl( index->addInitializer( new InitializerNode( start ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index->name ) ) ), inc ) ) : nullptr );
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
-        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
-                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
+ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
+        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
+                type = new ExpressionNode( new CastExpr( maybeMoveBuild<Expression>(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
         } // if
-        DeclarationNode * initDecl = distAttr(
-                DeclarationNode::newTypeof( type, true ),
-                DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) )
-        );
-        return makeForCtrl( location, initDecl, compop, comp, inc );
+//      type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) );
+        return new ForCtrl(
+                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : nullptr,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : nullptr );
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
-                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
-        } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
-                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
-                        return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
+                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
+                if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
+                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
-                        SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed." ); return nullptr;
+                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
                 } // if
         } else {
-                SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed. ." ); return nullptr;
+                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
         } // if
 } // forCtrl
 
 static void IdentifierBeforeIdentifier( string & identifier1, string & identifier2, const char * kind ) {
-        SemanticError( yylloc, ::toString( "syntax error, adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n"
+        SemanticError( yylloc, ::toString( "Adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n"
                                    "Possible cause is misspelled type name or missing generic parameter." ) );
 } // IdentifierBeforeIdentifier
 
 static void IdentifierBeforeType( string & identifier, const char * kind ) {
-        SemanticError( yylloc, ::toString( "syntax error, identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
+        SemanticError( yylloc, ::toString( "Identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
                                    "Possible cause is misspelled storage/CV qualifier, misspelled typename, or missing generic parameter." ) );
 } // IdentifierBeforeType
@@ -300 +281 @@
 %union {
         Token tok;
-        ExpressionNode * expr;
+        ParseNode * pn;
+        ExpressionNode * en;
         DeclarationNode * decl;
-        ast::AggregateDecl::Aggregate aggKey;
-        ast::TypeDecl::Kind tclass;
-        StatementNode * stmt;
-        ClauseNode * clause;
-        ast::WaitForStmt * wfs;
-    ast::WaitUntilStmt::ClauseNode * wucn;
+        AggregateDecl::Aggregate aggKey;
+        TypeDecl::Kind tclass;
+        StatementNode * sn;
+        WaitForStmt * wfs;
+        Expression * constant;
         CondCtl * ifctl;
-        ForCtrl * forctl;
-        LabelNode * labels;
-        InitializerNode * init;
-        OperKinds oper;
+        ForCtrl * fctl;
+        OperKinds compop;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
         std::string * str;
-        bool is_volatile;
-        EnumHiding enum_hiding;
-        ast::ExceptionKind except_kind;
-        ast::GenericExpr * genexpr;
+        bool flag;
+        EnumHiding hide;
+        CatchStmt::Kind catch_kind;
+        GenericExpr * genexpr;
 }
 
-// ************************ TERMINAL TOKENS ********************************
+//************************* TERMINAL TOKENS ********************************
 
 // keywords
@@ -349 +331 @@
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
-%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR WAITUNTIL // CFA
+%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR    // CFA
 %token DISABLE ENABLE TRY THROW THROWRESUME AT                  // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
@@ -355 +337 @@
 
 // names and constants: lexer differentiates between identifier and typedef names
-%token<tok> IDENTIFIER          TYPEDIMname             TYPEDEFname             TYPEGENname
-%token<tok> TIMEOUT                     WAND    WOR                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
 %token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
@@ -382 +364 @@
 %type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
-%type<expr> string_literal
+%type<constant> string_literal
 %type<str> string_literal_list
 
-%type<enum_hiding> hide_opt                                     visible_hide_opt
+%type<hide> hide_opt                                    visible_hide_opt
 
 // expressions
-%type<expr> constant
-%type<expr> tuple                                                       tuple_expression_list
-%type<oper> ptrref_operator                             unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
-%type<expr> primary_expression                  postfix_expression                      unary_expression
-%type<expr> cast_expression_list                        cast_expression                         exponential_expression          multiplicative_expression       additive_expression
-%type<expr> shift_expression                            relational_expression           equality_expression
-%type<expr> AND_expression                              exclusive_OR_expression         inclusive_OR_expression
-%type<expr> logical_AND_expression              logical_OR_expression
-%type<expr> conditional_expression              constant_expression                     assignment_expression           assignment_expression_opt
-%type<expr> comma_expression                            comma_expression_opt
-%type<expr> argument_expression_list_opt        argument_expression_list        argument_expression                     default_initializer_opt
+%type<en> constant
+%type<en> tuple                                                 tuple_expression_list
+%type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
+%type<en> primary_expression                    postfix_expression                      unary_expression
+%type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<en> shift_expression                              relational_expression           equality_expression
+%type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
+%type<en> logical_AND_expression                logical_OR_expression
+%type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
+%type<en> comma_expression                              comma_expression_opt
+%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> conditional_declaration
-%type<forctl> for_control_expression            for_control_expression_list
-%type<oper> upupeq updown updowneq downupdowneq
-%type<expr> subrange
+%type<fctl> for_control_expression              for_control_expression_list
+%type<compop> upupeq updown updowneq downupdowneq
+%type<en> subrange
 %type<decl> asm_name_opt
-%type<expr> asm_operands_opt                            asm_operands_list                       asm_operand
-%type<labels> label_list
-%type<expr> asm_clobbers_list_opt
-%type<is_volatile> asm_volatile_opt
-%type<expr> handler_predicate_opt
+%type<en> asm_operands_opt                              asm_operands_list                       asm_operand
+%type<label> label_list
+%type<en> asm_clobbers_list_opt
+%type<flag> asm_volatile_opt
+%type<en> handler_predicate_opt
 %type<genexpr> generic_association              generic_assoc_list
 
 // statements
-%type<stmt> statement                                           labeled_statement                       compound_statement
-%type<stmt> statement_decl                              statement_decl_list                     statement_list_nodecl
-%type<stmt> selection_statement                 if_statement
-%type<clause> switch_clause_list_opt            switch_clause_list
-%type<expr> case_value
-%type<clause> case_clause                               case_value_list                         case_label                                      case_label_list
-%type<stmt> iteration_statement                 jump_statement
-%type<stmt> expression_statement                        asm_statement
-%type<stmt> with_statement
-%type<expr> with_clause_opt
-%type<stmt> exception_statement
-%type<clause> handler_clause                    finally_clause
-%type<except_kind> handler_key
-%type<stmt> mutex_statement
-%type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
-%type<stmt> waitfor_statement                           waituntil_statement
-%type<wfs> wor_waitfor_clause
-%type<wucn> waituntil_clause                    wand_waituntil_clause       wor_waituntil_clause
+%type<sn> statement                                             labeled_statement                       compound_statement
+%type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
+%type<sn> selection_statement                   if_statement
+%type<sn> switch_clause_list_opt                switch_clause_list
+%type<en> case_value
+%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
+%type<sn> iteration_statement                   jump_statement
+%type<sn> expression_statement                  asm_statement
+%type<sn> with_statement
+%type<en> with_clause_opt
+%type<sn> exception_statement                   handler_clause                          finally_clause
+%type<catch_kind> handler_key
+%type<sn> mutex_statement
+%type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
+%type<sn> waitfor_statement
+%type<wfs> waitfor_clause
 
 // declarations
@@ -441 +421 @@
 %type<decl> assertion assertion_list assertion_list_opt
 
-%type<expr> bit_subrange_size_opt bit_subrange_size
+%type<en> bit_subrange_size_opt bit_subrange_size
 
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
@@ -454 +434 @@
 
 %type<decl> enumerator_list enum_type enum_type_nobody
-%type<init> enumerator_value_opt
+%type<in> enumerator_value_opt
 
 %type<decl> external_definition external_definition_list external_definition_list_opt
@@ -461 +441 @@
 
 %type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
-%type<expr> field field_name_list field_name fraction_constants_opt
+%type<en> field field_name_list field_name fraction_constants_opt
 
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
@@ -502 +482 @@
 %type<decl> typedef_name typedef_declaration typedef_expression
 
-%type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
-%type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
 
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
@@ -510 +489 @@
 %type<decl> type_parameter type_parameter_list type_initializer_opt
 
-%type<expr> type_parameters_opt type_list array_type_list
+%type<en> type_parameters_opt type_list array_type_list
 
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
@@ -521 +500 @@
 
 // initializers
-%type<init>  initializer initializer_list_opt initializer_opt
+%type<in>  initializer initializer_list_opt initializer_opt
 
 // designators
-%type<expr>  designator designator_list designation
+%type<en>  designator designator_list designation
 
 
@@ -533 +512 @@
 // Similar issues exit with the waitfor statement.
 
-// Order of these lines matters (low-to-high precedence). THEN is left associative over WAND/WOR/TIMEOUT/ELSE, WAND/WOR
-// is left associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+// Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
+// associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
 %precedence THEN                // rule precedence for IF/WAITFOR statement
-%precedence ANDAND              // token precedence for start of WAND in WAITFOR statement
-%precedence WAND                // token precedence for start of WAND in WAITFOR statement
-%precedence OROR                // token precedence for start of WOR in WAITFOR statement
 %precedence WOR                 // token precedence for start of WOR in WAITFOR statement
 %precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
@@ -616 +592 @@
 constant:
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
-        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( yylloc, *$1 ) ); }
-        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( yylloc, *$1 ) ); }
+        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
         ;
 
 quasi_keyword:                                                                                  // CFA
         TIMEOUT
-        | WAND
         | WOR
         | CATCH
@@ -646 +621 @@
 
 string_literal:
-        string_literal_list                                                     { $$ = new ExpressionNode( build_constantStr( yylloc, *$1 ) ); }
+        string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
         ;
 
@@ -663 +638 @@
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | quasi_keyword
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | TYPEDIMname                                                                           // CFA, generic length argument
                 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
                 // { $$ = new ExpressionNode( build_varref( $1 ) ); }
-                { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
         | tuple
         | '(' comma_expression ')'
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
-                { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); }
+                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
-                { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -682 +657 @@
                 {
                         // add the missing control expression to the GenericExpr and return it
-                        $5->control = maybeMoveBuild( $3 );
+                        $5->control = maybeMoveBuild<Expression>( $3 );
                         $$ = new ExpressionNode( $5 );
                 }
@@ -689 +664 @@
         // | RESUME '(' comma_expression ')' compound_statement
         //      { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; }
-        | IDENTIFIER IDENTIFIER                                                         // invalid syntax rules
+        | IDENTIFIER IDENTIFIER                                                         // syntax error
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, "n expression" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
+        | IDENTIFIER type_qualifier                                                     // syntax error
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // invalid syntax rules
+        | IDENTIFIER storage_class                                                      // syntax error
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // invalid syntax rules
+        | IDENTIFIER basic_type_name                                            // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEDEFname                                                        // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEGENname                                                        // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         ;
@@ -708 +683 @@
                 {
                         // steal the association node from the singleton and delete the wrapper
-                        assert( 1 == $3->associations.size() );
-                        $1->associations.push_back( $3->associations.front() );
+                        $1->associations.splice($1->associations.end(), $3->associations);
                         delete $3;
                         $$ = $1;
@@ -719 +693 @@
                 {
                         // create a GenericExpr wrapper with one association pair
-                        $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuildType( $1 ), maybeMoveBuild( $3 ) } } );
+                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
                 }
         | DEFAULT ':' assignment_expression
-                { $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuild( $3 ) } } ); }
+                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
         ;
 
@@ -731 +705 @@
                 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
                 // Current: Commas in subscripts make tuples.
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
@@ -737 +711 @@
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
                 {
                         Token fn;
                         fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
-                        $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
                 }
         | postfix_expression '(' argument_expression_list_opt ')'
-                { $$ = new ExpressionNode( build_func( yylloc, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
         | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')'
                 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; }
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg") ) ),
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__builtin_va_arg") ) ),
                                                                                            (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
         | postfix_expression '.' identifier
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression '.' aggregate_control
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $3, $1 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
         | postfix_expression ARROW identifier
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
         | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ICR
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
-                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, new InitializerNode( $5, true ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
-                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
                 {
                         Token fn;
                         fn.str = new string( "^?{}" );                          // location undefined
-                        $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
                 }
         ;
@@ -807 +781 @@
         '@'                                                                                                     // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
-                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
+                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
         ;
@@ -819 +793 @@
         field_name
         | FLOATING_DECIMALconstant field
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), build_tuple( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
         | field_name '.' field
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | field_name ARROW field
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         ;
 
 field_name:
         INTEGERconstant fraction_constants_opt
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_constantInteger( yylloc, *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
         | FLOATINGconstant fraction_constants_opt
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_field_name_FLOATINGconstant( yylloc, *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
                 {
-                        $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_varref( yylloc, $1 ), $2 ) );
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
                 }
         ;
@@ -848 +822 @@
         | fraction_constants_opt FLOATING_FRACTIONconstant
                 {
-                        ast::Expr * constant = build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 );
-                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( yylloc, $1, constant ) ) : new ExpressionNode( constant );
+                        Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
+                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
                 }
         ;
@@ -859 +833 @@
         | constant
         | string_literal
-                { $$ = $1; }
+                { $$ = new ExpressionNode( $1 ); }
         | EXTENSION cast_expression                                                     // GCC
                 { $$ = $2->set_extension( true ); }
@@ -868 +842 @@
                 {
                         switch ( $1 ) {
-                        case OperKinds::AddressOf:
-                                $$ = new ExpressionNode( new ast::AddressExpr( maybeMoveBuild( $2 ) ) );
+                          case OperKinds::AddressOf:
+                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
                                 break;
-                        case OperKinds::PointTo:
-                                $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) );
+                          case OperKinds::PointTo:
+                                $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
                                 break;
-                        case OperKinds::And:
-                                $$ = new ExpressionNode( new ast::AddressExpr( new ast::AddressExpr( maybeMoveBuild( $2 ) ) ) );
+                          case OperKinds::And:
+                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
                                 break;
-                        default:
+                          default:
                                 assert( false );
                         }
                 }
         | unary_operator cast_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
         | ICR unary_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
-                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
-                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
-                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
-                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' identifier ')'
-                { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
+                { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
         | TYPEID '(' type_no_function ')'
                 {
@@ -921 +895 @@
         unary_expression
         | '(' type_no_function ')' cast_expression
-                { $$ = new ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' aggregate_control '*' ')' cast_expression         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
-                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
-                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_cast( $3, $5, CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
@@ -937 +911 @@
                 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
-//              { $$ = new ast::ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+//              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         ;
 
@@ -955 +929 @@
         cast_expression
         | exponential_expression '\\' cast_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Exp, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
         ;
 
@@ -961 +935 @@
         exponential_expression
         | multiplicative_expression '*' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mul, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Div, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mod, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
         ;
 
@@ -971 +945 @@
         multiplicative_expression
         | additive_expression '+' multiplicative_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Plus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
         | additive_expression '-' multiplicative_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Minus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
         ;
 
@@ -979 +953 @@
         additive_expression
         | shift_expression LS additive_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
         | shift_expression RS additive_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::RShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
         ;
 
@@ -987 +961 @@
         shift_expression
         | relational_expression '<' shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
         | relational_expression '>' shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
         | relational_expression LE shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
         | relational_expression GE shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
         ;
 
@@ -999 +973 @@
         relational_expression
         | equality_expression EQ relational_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Eq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
         | equality_expression NE relational_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Neq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
         ;
 
@@ -1007 +981 @@
         equality_expression
         | AND_expression '&' equality_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitAnd, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
         ;
 
@@ -1013 +987 @@
         AND_expression
         | exclusive_OR_expression '^' AND_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Xor, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
         ;
 
@@ -1019 +993 @@
         exclusive_OR_expression
         | inclusive_OR_expression '|' exclusive_OR_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitOr, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
         ;
 
@@ -1025 +999 @@
         inclusive_OR_expression
         | logical_AND_expression ANDAND inclusive_OR_expression
-                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::AndExpr ) ); }
+                { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
         ;
 
@@ -1031 +1005 @@
         logical_AND_expression
         | logical_OR_expression OROR logical_AND_expression
-                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::OrExpr ) ); }
+                { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
         ;
 
@@ -1037 +1011 @@
         logical_OR_expression
         | logical_OR_expression '?' comma_expression ':' conditional_expression
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
+                { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
         ;
 
@@ -1055 +1029 @@
 //                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
 //                      } else {
-                                $$ = new ExpressionNode( build_binary_val( yylloc, $2, $1, $3 ) );
+                                $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
 //                      } // if
                 }
@@ -1100 +1074 @@
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         '[' ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
         ;
 
@@ -1118 +1092 @@
         assignment_expression
         | comma_expression ',' assignment_expression
-                { $$ = new ExpressionNode( new ast::CommaExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
         ;
 
@@ -1139 +1113 @@
         | mutex_statement
         | waitfor_statement
-        | waituntil_statement
         | exception_statement
         | enable_disable_statement
@@ -1145 +1118 @@
         | asm_statement
         | DIRECTIVE
-                { $$ = new StatementNode( build_directive( yylloc, $1 ) ); }
+                { $$ = new StatementNode( build_directive( $1 ) ); }
         ;
 
@@ -1151 +1124 @@
                 // labels cannot be identifiers 0 or 1
         identifier_or_type_name ':' attribute_list_opt statement
-                { $$ = $4->add_label( yylloc, $1, $3 ); }
-        | identifier_or_type_name ':' attribute_list_opt error // invalid syntax rule
-                {
-                        SemanticError( yylloc, ::toString( "syntx error, label \"", *$1.str, "\" must be associated with a statement, "
+                { $$ = $4->add_label( $1, $3 ); }
+        | identifier_or_type_name ':' attribute_list_opt error // syntax error
+                {
+                        SemanticError( yylloc, ::toString( "Label \"", *$1.str, "\" must be associated with a statement, "
                                                                                            "where a declaration, case, or default is not a statement. "
                                                                                            "Move the label or terminate with a semi-colon." ) );
@@ -1163 +1136 @@
 compound_statement:
         '{' '}'
-                { $$ = new StatementNode( build_compound( yylloc, (StatementNode *)0 ) ); }
+                { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
-                { $$ = new StatementNode( build_compound( yylloc, $4 ) ); }
+                { $$ = new StatementNode( build_compound( $4 ) ); }
         ;
 
@@ -1193 +1166 @@
         | statement_list_nodecl statement
                 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
-        | statement_list_nodecl error                                           // invalid syntax rule
-                { SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; }
+        | statement_list_nodecl error                                           // syntax error
+                { SemanticError( yylloc, "Declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; }
         ;
 
 expression_statement:
         comma_expression_opt ';'
-                { $$ = new StatementNode( build_expr( yylloc, $1 ) ); }
+                { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
         ;
 
@@ -1208 +1183 @@
                 { $$ = $2; }
         | SWITCH '(' comma_expression ')' case_clause
-                { $$ = new StatementNode( build_switch( yylloc, true, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
         | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
-                        StatementNode *sw = new StatementNode( build_switch( yylloc, true, $3, $8 ) );
+                        StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
                         // The semantics of the declaration list is changed to include associated initialization, which is performed
                         // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
@@ -1217 +1192 @@
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
-                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
-                }
-        | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, invalid syntax rule error
-                { SemanticError( yylloc, "synatx error, declarations can only appear before the list of case clauses." ); $$ = nullptr; }
+                        $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
+        | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
+                { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
-                { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
-                        StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
-                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
-                }
-        | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, invalid syntax rule
-                { SemanticError( yylloc, "syntax error, declarations can only appear before the list of case clauses." ); $$ = nullptr; }
+                        StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
+                        $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
+        | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, syntax error
+                { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         ;
 
@@ -1235 +1210 @@
         IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
-                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), nullptr ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
         | IF '(' conditional_declaration ')' statement ELSE statement
-                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), maybe_build_compound( yylloc, $7 ) ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
@@ -1249 +1224 @@
         | declaration comma_expression                                          // semi-colon separated
                 { $$ = new CondCtl( $1, $2 ); }
-        ;
+        ;
 
 // CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
@@ -1257 +1232 @@
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
         ;
 
 case_value_list:                                                                                // CFA
-        case_value                                                                      { $$ = new ClauseNode( build_case( yylloc, $1 ) ); }
+        case_value                                                                      { $$ = new StatementNode( build_case( $1 ) ); }
                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
-        | case_value_list ',' case_value                        { $$ = $1->set_last( new ClauseNode( build_case( yylloc, $3 ) ) ); }
+        | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); }
         ;
 
 case_label:                                                                                             // CFA
-        CASE error                                                                                      // invalid syntax rule
-                { SemanticError( yylloc, "syntax error, case list missing after case." ); $$ = nullptr; }
+        CASE error                                                                                      // syntax error
+                { SemanticError( yylloc, "Missing case list after case." ); $$ = nullptr; }
         | CASE case_value_list ':'                                      { $$ = $2; }
-        | CASE case_value_list error                                            // invalid syntax rule
-                { SemanticError( yylloc, "syntax error, colon missing after case list." ); $$ = nullptr; }
-        | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
+        | CASE case_value_list error                                            // syntax error
+                { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
+        | DEFAULT ':'                                                           { $$ = new StatementNode( build_default() ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
-        | DEFAULT error                                                                         //  invalid syntax rules
-                { SemanticError( yylloc, "syntax error, colon missing after default." ); $$ = nullptr; }
+        | DEFAULT error                                                                         //  syntax error
+                { SemanticError( yylloc, "Missing colon after default." ); $$ = nullptr; }
         ;
 
 case_label_list:                                                                                // CFA
         case_label
-        | case_label_list case_label                            { $$ = $1->set_last( $2 ); }
+        | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
         ;
 
 case_clause:                                                                                    // CFA
-        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( yylloc, $2 ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
         ;
 
@@ -1296 +1271 @@
 switch_clause_list:                                                                             // CFA
         case_label_list statement_list_nodecl
-                { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); }
+                { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
         | switch_clause_list case_label_list statement_list_nodecl
-                { $$ = $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ); }
+                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
         ;
 
 iteration_statement:
         WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) ); }
+                { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); }
         | WHILE '(' ')' statement ELSE statement                        // CFA
                 {
-                        $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
-                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
-                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
-                { $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ELSE statement                     // CFA
                 {
-                        $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
-                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ), $8 ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
-                { $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
                 {
-                        $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
-                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
-                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
         ;
 
@@ -1348 +1323 @@
                         if ( $1->condition ) {
                                 if ( $3->condition ) {
-                                        $1->condition->expr.reset( new ast::LogicalExpr( yylloc, $1->condition->expr.release(), $3->condition->expr.release(), ast::AndExpr ) );
+                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
                                 } // if
                         } else $1->condition = $3->condition;
                         if ( $1->change ) {
                                 if ( $3->change ) {
-                                        $1->change->expr.reset( new ast::CommaExpr( yylloc, $1->change->expr.release(), $3->change->expr.release() ) );
+                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
                                 } // if
                         } else $1->change = $3->change;
@@ -1362 +1337 @@
 for_control_expression:
         ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( nullptr, $2, $4 ); }
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
-                {
-                        StatementNode * init = $1 ? new StatementNode( new ast::ExprStmt( yylloc, maybeMoveBuild( $1 ) ) ) : nullptr;
-                        $$ = new ForCtrl( init, $3, $5 );
-                }
+                { $$ = new ForCtrl( $1, $3, $5 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
-                { $$ = new ForCtrl( new StatementNode( $1 ), $2, $4 ); }
+                { $$ = new ForCtrl( $1, $2, $4 ); }
 
         | '@' ';' comma_expression                                                      // CFA, empty loop-index
-                { $$ = new ForCtrl( nullptr, $3, nullptr ); }
+                { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); }
         | '@' ';' comma_expression ';' comma_expression         // CFA, empty loop-index
-                { $$ = new ForCtrl( nullptr, $3, $5 ); }
+                { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); }
 
         | comma_expression                                                                      // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
         | downupdowneq comma_expression                                         // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | comma_expression updowneq comma_expression            // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
         | '@' updowneq comma_expression                                         // CFA, anonymous loop-index
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
                 }
         | comma_expression updowneq '@'                                         // CFA, anonymous loop-index
@@ -1394 +1366 @@
                 }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
         | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                        else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
                 }
         | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index
@@ -1405 +1377 @@
                         else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
-        | comma_expression updowneq comma_expression '~' '@' // CFA, invalid syntax rules
+        | comma_expression updowneq comma_expression '~' '@' // CFA, error
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@'                                                                      // CFA, invalid syntax rules
+        | '@' updowneq '@'                                                                      // CFA, error
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq comma_expression '~' '@'                         // CFA, invalid syntax rules
+        | '@' updowneq comma_expression '~' '@'                         // CFA, error
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | comma_expression updowneq '@' '~' '@'                         // CFA, invalid syntax rules
+        | comma_expression updowneq '@' '~' '@'                         // CFA, error
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@' '~' '@'                                                      // CFA, invalid syntax rules
+        | '@' updowneq '@' '~' '@'                                                      // CFA, error
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
 
         | comma_expression ';' comma_expression                         // CFA
-                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
+                { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
         | comma_expression ';' downupdowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | comma_expression ';' comma_expression updowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
         | comma_expression ';' '@' updowneq comma_expression // CFA
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
                 }
         | comma_expression ';' comma_expression updowneq '@' // CFA
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
-                }
-        | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rules
-                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                }
+        | comma_expression ';' '@' updowneq '@'                         // CFA, error
+                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, invalid syntax rules
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
+        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 );
                 }
         | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 );
                 }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rules
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
+        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr );
                 }
         | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr );
                 }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
-                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | declaration comma_expression                                          // CFA
-                { $$ = forCtrl( yylloc, $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
+                { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
         | declaration downupdowneq comma_expression                     // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | declaration comma_expression updowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
         | declaration '@' updowneq comma_expression                     // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE );
                 }
         | declaration comma_expression updowneq '@'                     // CFA
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE );
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE );
                 }
 
         | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
         | declaration '@' updowneq comma_expression '~' comma_expression // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, $6 );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, $6 );
                 }
         | declaration comma_expression updowneq '@' '~' comma_expression // CFA
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 );
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $1, $2, $3, nullptr, $6 );
                 }
         | declaration comma_expression updowneq comma_expression '~' '@' // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
         | declaration '@' updowneq comma_expression '~' '@' // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, nullptr );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, nullptr );
                 }
         | declaration comma_expression updowneq '@' '~' '@'     // CFA
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
-                }
-        | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rules
-                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else $$ = forCtrl( $1, $2, $3, nullptr, nullptr );
+                }
+        | declaration '@' updowneq '@' '~' '@'                          // CFA, error
+                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' TYPEDEFname                                      // CFA, array type
@@ -1521 +1493 @@
         | comma_expression ';' downupdowneq TYPEDEFname         // CFA, array type
                 {
-                        if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) {
-                                SemanticError( yylloc, "syntax error, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr;
-                        }
+                        if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, "All enumation ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr; }
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
                 }
-        ;
+        ;
 
 downupdowneq:
@@ -1535 +1505 @@
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
-        ;
+        ;
 
 updown:
@@ -1542 +1512 @@
         | ErangeDown
                 { $$ = OperKinds::GThan; }
-        ;
+        ;
 
 updowneq:
@@ -1550 +1520 @@
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
-        ;
+        ;
 
 jump_statement:
         GOTO identifier_or_type_name ';'
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Goto ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
                 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
@@ -1561 +1531 @@
                 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
         | fall_through_name ';'                                                         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
         | fall_through_name identifier_or_type_name ';'         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
         | fall_through_name DEFAULT ';'                                         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThroughDefault ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
         | CONTINUE ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
         | CONTINUE identifier_or_type_name ';'                          // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
         | BREAK ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
         | BREAK identifier_or_type_name ';'                                     // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
         | RETURN comma_expression_opt ';'
-                { $$ = new StatementNode( build_return( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_return( $2 ) ); }
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | SUSPEND ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::None ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr ) ); }
         | SUSPEND compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $2, ast::SuspendStmt::None ) ); }
+                { $$ = new StatementNode( build_suspend( $2 ) ); }
         | SUSPEND COROUTINE ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
         | SUSPEND COROUTINE compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
         | SUSPEND GENERATOR ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
         | SUSPEND GENERATOR compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
-                { $$ = new StatementNode( build_throw( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_throw( $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
-                { $$ = new StatementNode( build_resume( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_resume( $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
@@ -1611 +1581 @@
 with_statement:
         WITH '(' tuple_expression_list ')' statement
-                { $$ = new StatementNode( build_with( yylloc, $3, $5 ) ); }
-        ;
-
-// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so possibly change syntax to "with mutex".
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
+
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
-        MUTEX '(' argument_expression_list_opt ')' statement
-                {
-                        if ( ! $3 ) { SemanticError( yylloc, "syntax error, mutex argument list cannot be empty." ); $$ = nullptr; }
-                        $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
-                }
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
         ;
 
@@ -1631 +1598 @@
                 { $$ = nullptr; }
         | when_clause
+        ;
+
+waitfor:
+        WAITFOR '(' cast_expression ')'
+                { $$ = $3; }
+//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
+//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
+                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
         ;
 
@@ -1641 +1617 @@
 
 timeout:
-        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
-        ;
-
-wor:
-        OROR
-        | WOR
-
-waitfor:
-        WAITFOR '(' cast_expression ')'
-                { $$ = $3; }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
-                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
-        ;
-
-wor_waitfor_clause:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+
+waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
-                // Called first: create header for WaitForStmt.
-                { $$ = build_waitfor( yylloc, new ast::WaitForStmt( yylloc ), $1, $2, maybe_build_compound( yylloc, $3 ) ); }
-        | wor_waitfor_clause wor when_clause_opt waitfor statement
-                { $$ = build_waitfor( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
-        | wor_waitfor_clause wor when_clause_opt ELSE statement
-                { $$ = build_waitfor_else( yylloc, $1, $3, maybe_build_compound( yylloc, $5 ) ); }
-        | wor_waitfor_clause wor when_clause_opt timeout statement      %prec THEN
-                { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
+        | when_clause_opt timeout statement                                     %prec THEN
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt ELSE statement
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
-                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
-        | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
-                { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); }
+        | when_clause_opt timeout statement WOR ELSE statement // syntax error
+                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | when_clause_opt timeout statement WOR when_clause ELSE statement
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
         ;
 
 waitfor_statement:
-        wor_waitfor_clause                                                                      %prec THEN
-                { $$ = new StatementNode( $1 ); }
-        ;
-
-wand:
-        ANDAND
-        | WAND
-        ;
-
-waituntil:
-        WAITUNTIL '(' comma_expression ')'
-                { $$ = $3; }
-        ;
-
-waituntil_clause:
-        when_clause_opt waituntil statement
-                { $$ = build_waituntil_clause( yylloc, $1, $2, maybe_build_compound( yylloc, $3 ) ); }
-        | '(' wor_waituntil_clause ')'
-                { $$ = $2; }
-        ;
-
-wand_waituntil_clause:
-        waituntil_clause                                                                        %prec THEN
-                { $$ = $1; }
-        | waituntil_clause wand wand_waituntil_clause
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::AND, $1, $3 ); }
-        ;
-
-wor_waituntil_clause:
-        wand_waituntil_clause
-                { $$ = $1; }
-        | wor_waituntil_clause wor wand_waituntil_clause
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, $1, $3 ); }
-        | wor_waituntil_clause wor when_clause_opt ELSE statement
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
-        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
-        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
-                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
-                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, 
-                    build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ), 
-                    build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
-        ;
-
-waituntil_statement:
-        wor_waituntil_clause                                                            %prec THEN
-                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
-                {
-            $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
-            // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
-        }
+        when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
         ;
 
 exception_statement:
-        TRY compound_statement handler_clause                                   %prec THEN
-                { $$ = new StatementNode( build_try( yylloc, $2, $3, nullptr ) ); }
+        TRY compound_statement handler_clause                                   %prec THEN
+                { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
         | TRY compound_statement finally_clause
-                { $$ = new StatementNode( build_try( yylloc, $2, nullptr, $3 ) ); }
+                { $$ = new StatementNode( build_try( $2, 0, $3 ) ); }
         | TRY compound_statement handler_clause finally_clause
-                { $$ = new StatementNode( build_try( yylloc, $2, $3, $4 ) ); }
+                { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
         ;
 
 handler_clause:
         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
-                { $$ = new ClauseNode( build_catch( yylloc, $1, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
-                { $$ = $1->set_last( new ClauseNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
         ;
 
@@ -1752 +1666 @@
 
 handler_key:
-        CATCH                                                                           { $$ = ast::Terminate; }
-        | RECOVER                                                                       { $$ = ast::Terminate; }
-        | CATCHRESUME                                                           { $$ = ast::Resume; }
-        | FIXUP                                                                         { $$ = ast::Resume; }
+        CATCH                                                                           { $$ = CatchStmt::Terminate; }
+        | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
+        | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
+        | FIXUP                                                                         { $$ = CatchStmt::Resume; }
         ;
 
 finally_clause:
-        FINALLY compound_statement                                      { $$ = new ClauseNode( build_finally( yylloc, $2 ) ); }
+        FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
         ;
 
@@ -1785 +1699 @@
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, nullptr ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, 0 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $5, nullptr, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $5, 0, $8, $10, $12 ) ); }
         ;
 
@@ -1817 +1731 @@
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new ast::AsmExpr( yylloc, "", maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
-                {
-                        $$ = new ExpressionNode( new ast::AsmExpr( yylloc, *$2.str, maybeMoveBuild( $4 ), maybeMoveBuild( $6 ) ) );
-                        delete $2.str;
-                }
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
         ;
 
@@ -1829 +1740 @@
                 { $$ = nullptr; }                                                               // use default argument
         | string_literal
-                { $$ = $1; }
+                { $$ = new ExpressionNode( $1 ); }
         | asm_clobbers_list_opt ',' string_literal
-                { $$ = (ExpressionNode *)( $1->set_last( $3 ) ); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
         ;
 
@@ -1837 +1748 @@
         identifier
                 {
-                        $$ = new LabelNode(); $$->labels.emplace_back( yylloc, *$1 );
+                        $$ = new LabelNode(); $$->labels.push_back( *$1 );
                         delete $1;                                                                      // allocated by lexer
                 }
         | label_list ',' identifier
                 {
-                        $$ = $1; $1->labels.emplace_back( yylloc, *$3 );
+                        $$ = $1; $1->labels.push_back( *$3 );
                         delete $3;                                                                      // allocated by lexer
                 }
@@ -1893 +1804 @@
                 {
                         // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
@@ -1903 +1814 @@
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
-                { $$ = DeclarationNode::newStaticAssert( $3, maybeMoveBuild( $5 ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
         | STATICASSERT '(' constant_expression ')' ';'          // CFA
-                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( yylloc, *new string( "\"\"" ) ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
@@ -1969 +1880 @@
 //      '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
 //              {
-//                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, nullptr, true );
+//                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
 //              }
 //      '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
-//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
 //              }
 //      | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
-//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
 //              }
 //      | '[' ']' typegen_name
@@ -1991 +1902 @@
         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
-                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
-                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
         ;
 
@@ -2029 +1940 @@
                 {
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
-                        if ( $2->type->forall || ($2->type->kind == TypeData::Aggregate && $2->type->aggregate.params) ) {
-                                SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." ); $$ = nullptr;
-                        } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
+                        $$ = $3->addType( $2 )->addTypedef();
                 }
         | typedef_declaration pop ',' push declarator
@@ -2039 +1948 @@
                 }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
-                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
+                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                }
         | type_specifier TYPEDEF declarator
-                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+                {
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
+                        $$ = $3->addType( $1 )->addTypedef();
+                }
         | type_specifier TYPEDEF type_qualifier_list declarator
-                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
+                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                }
         ;
 
@@ -2050 +1968 @@
         TYPEDEF identifier '=' assignment_expression
                 {
-                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
                 }
         | typedef_expression pop ',' push identifier '=' assignment_expression
                 {
-                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
                 }
         ;
@@ -2064 +1982 @@
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
-                {
-                        assert( $1->type );
-                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
-                                SemanticError( yylloc, "syntax error, useless type qualifier(s) in empty declaration." ); $$ = nullptr;
-                        }
-                        // enums are never empty declarations because there must have at least one enumeration.
-                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
-                                SemanticError( yylloc, "syntax error, useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
-                        }
-                }
         ;
 
@@ -2079 +1987 @@
                 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
                 // storage-class
-        variable_declarator asm_name_opt initializer_opt
+        declarator asm_name_opt initializer_opt
                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
-        | variable_type_redeclarator asm_name_opt initializer_opt
-                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
-
-        | general_function_declarator asm_name_opt
-                { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
-        | general_function_declarator asm_name_opt '=' VOID
-                { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
-
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
         ;
 
-general_function_declarator:
-        function_type_redeclarator
-        | function_declarator
-        ;
-
 declaration_specifier:                                                                  // type specifier + storage class
         basic_declaration_specifier
+        | sue_declaration_specifier
         | type_declaration_specifier
-        | sue_declaration_specifier
-        | sue_declaration_specifier invalid_types                       // invalid syntax rule
-                {
-                        SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of ",
-                                $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
-                                " declaration." ) );
-                        $$ = nullptr;
-                }
-        ;
-
-invalid_types:
-        aggregate_key
-        | basic_type_name
-        | indirect_type
         ;
 
@@ -2131 +2013 @@
         basic_type_specifier
         | sue_type_specifier
+                {
+                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | type_type_specifier
         ;
@@ -2177 +2065 @@
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
         | forall
-                { $$ = DeclarationNode::newForall( $1 ); }
         ;
 
 forall:
         FORALL '(' type_parameter_list ')'                                      // CFA
-                { $$ = $3; }
+                { $$ = DeclarationNode::newForall( $3 ); }
         ;
 
@@ -2339 +2226 @@
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
-                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ), true ); }
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
@@ -2352 +2239 @@
                 {
                         // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
@@ -2368 +2255 @@
                 {
                         // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
@@ -2446 +2333 @@
                 {
                         // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
@@ -2470 +2357 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
+                        // if ( $2 )
+                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
+                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
+                        //      } // for
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
+                        // } // for
                 }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
@@ -2479 +2375 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2489 +2386 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2515 +2413 @@
                         // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
                         // delete newFromTypeGen.
-                        if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) {
-                                $$ = $3->addQualifiers( $2 );
-                        } else {
-                                $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
-                                $3->type->symbolic.name = nullptr;                      // copied to $$
-                                $3->type->symbolic.actuals = nullptr;
-                                delete $3;
-                        }
+                        $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                        $3->type->symbolic.name = nullptr;
+                        $3->type->symbolic.actuals = nullptr;
+                        delete $3;
                 }
         ;
@@ -2533 +2427 @@
 aggregate_data:
         STRUCT vtable_opt
-                { $$ = ast::AggregateDecl::Struct; }
+                { $$ = AggregateDecl::Struct; }
         | UNION
-                { $$ = ast::AggregateDecl::Union; }
+                { $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
-                { $$ = ast::AggregateDecl::Exception; }
-          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
+                { $$ = AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 
 aggregate_control:                                                                              // CFA
         MONITOR
-                { $$ = ast::AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | MUTEX STRUCT
-                { $$ = ast::AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | GENERATOR
-                { $$ = ast::AggregateDecl::Generator; }
+                { $$ = AggregateDecl::Generator; }
         | MUTEX GENERATOR
-                {
-                        SemanticError( yylloc, "monitor generator is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
-                { $$ = ast::AggregateDecl::Coroutine; }
+                { $$ = AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
-                {
-                        SemanticError( yylloc, "monitor coroutine is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
-                { $$ = ast::AggregateDecl::Thread; }
+                { $$ = AggregateDecl::Thread; }
         | MUTEX THREAD
-                {
-                        SemanticError( yylloc, "monitor thread is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 
@@ -2582 +2467 @@
                         $$ = fieldDecl( $1, $2 );
                         // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
                 }
-        | type_specifier field_declaring_list_opt '}'           // invalid syntax rule
-                {
-                        SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of previous declaration." ) );
-                        $$ = nullptr;
-                }
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
-        | STATIC type_specifier field_declaring_list_opt ';' // CFA
-                { SemanticError( yylloc, "STATIC aggregate field qualifier currently unimplemented." ); $$ = nullptr; }
         | INLINE type_specifier field_abstract_list_opt ';'     // CFA
                 {
@@ -2605 +2483 @@
                 }
         | INLINE aggregate_control ';'                                          // CFA
-                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
+                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
@@ -2631 +2509 @@
                 { $$ = $1->addBitfield( $2 ); }
         | variable_type_redeclarator bit_subrange_size_opt
-                // A semantic check is required to ensure bit_subrange only appears on integral types.
-                { $$ = $1->addBitfield( $2 ); }
-        | function_type_redeclarator bit_subrange_size_opt
                 // A semantic check is required to ensure bit_subrange only appears on integral types.
                 { $$ = $1->addBitfield( $2 ); }
@@ -2688 +2563 @@
                 { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
-                {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() ) {
-                                SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
-                        }
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                        { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+
                         $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
                 }
@@ -2700 +2575 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) {
-                                SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
-                        }
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
                 }
@@ -2736 +2609 @@
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
-                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, nullptr, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt type_name
-                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
         ;
 
@@ -2878 +2751 @@
 type_no_function:                                                                               // sizeof, alignof, cast (constructor)
         cfa_abstract_declarator_tuple                                           // CFA
-        | type_specifier                                                                        // cannot be type_specifier_nobody, e.g., (struct S {}){} is a thing
+        | type_specifier
         | type_specifier abstract_declarator
                 { $$ = $2->addType( $1 ); }
@@ -2923 +2796 @@
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         ;
 
@@ -2935 +2808 @@
 designator:
         '.' identifier_at                                                                       // C99, field name
-                { $$ = new ExpressionNode( build_varref( yylloc, $2 ) ); }
+                { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
                 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
@@ -2942 +2815 @@
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $3 ), maybeMoveBuild<Expression>( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
@@ -2982 +2855 @@
                 {
                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
-                        if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
-                        if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
-                        if ( $1 == ast::TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                        if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
+                        if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
+                        if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
                 }
           type_initializer_opt assertion_list_opt
@@ -2995 +2868 @@
                 {
                         typedefTable.addToScope( *$2, TYPEDIMname, "9" );
-                        $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
+                        $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
                 }
         // | type_specifier identifier_parameter_declarator
         | assertion_list
-                { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
         ;
 
 new_type_class:                                                                                 // CFA
         // empty
-                { $$ = ast::TypeDecl::Otype; }
+                { $$ = TypeDecl::Otype; }
         | '&'
-                { $$ = ast::TypeDecl::Dtype; }
+                { $$ = TypeDecl::Dtype; }
         | '*'
-                { $$ = ast::TypeDecl::DStype; }                                         // dtype + sized
+                { $$ = TypeDecl::DStype; }                                              // dtype + sized
         // | '(' '*' ')'
-        //      { $$ = ast::TypeDecl::Ftype; }
+        //      { $$ = TypeDecl::Ftype; }
         | ELLIPSIS
-                { $$ = ast::TypeDecl::Ttype; }
+                { $$ = TypeDecl::Ttype; }
         ;
 
 type_class:                                                                                             // CFA
         OTYPE
-                { $$ = ast::TypeDecl::Otype; }
+                { $$ = TypeDecl::Otype; }
         | DTYPE
-                { $$ = ast::TypeDecl::Dtype; }
+                { $$ = TypeDecl::Dtype; }
         | FTYPE
-                { $$ = ast::TypeDecl::Ftype; }
+                { $$ = TypeDecl::Ftype; }
         | TTYPE
-                { $$ = ast::TypeDecl::Ttype; }
+                { $$ = TypeDecl::Ttype; }
         ;
 
@@ -3049 +2922 @@
 type_list:                                                                                              // CFA
         type
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
         | type_list ',' type
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
@@ -3077 +2950 @@
                 {
                         typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
-                        $$ = DeclarationNode::newTypeDecl( $1, nullptr );
+                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
                 }
         | identifier_or_type_name '(' type_parameter_list ')'
@@ -3088 +2961 @@
 trait_specifier:                                                                                // CFA
         TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
-                {
-                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
-                        $$ = DeclarationNode::newTrait( $2, $4, nullptr );
-                }
-        | forall TRAIT identifier_or_type_name '{' '}'          // alternate
-                { $$ = DeclarationNode::newTrait( $3, $1, nullptr ); }
+                { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
         | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
-                {
-                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
-                        $$ = DeclarationNode::newTrait( $2, $4, $8 );
-                }
-        | forall TRAIT identifier_or_type_name '{' push trait_declaration_list pop '}' // alternate
-                { $$ = DeclarationNode::newTrait( $3, $1, $6 ); }
+                { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
         ;
 
@@ -3159 +3022 @@
 external_definition:
         DIRECTIVE
-                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( yylloc, $1 ) ) ); }
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
         | declaration
-                {
-                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
-                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
-                        // disallowed at the moment.
-                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
-                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
-                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
-                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
-                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
-                                }
-                        }
-                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
+        | IDENTIFIER type_qualifier                                                     // syntax error
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // invalid syntax rules
+        | IDENTIFIER storage_class                                                      // syntax error
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // invalid syntax rules
+        | IDENTIFIER basic_type_name                                            // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEDEFname                                                        // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEGENname                                                        // syntax error
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         | external_function_definition
@@ -3192 +3043 @@
                 }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
-                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( yylloc, false, $3, nullptr ) ) ); }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
         | EXTERN STRINGliteral
                 {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                        linkage = LinkageSpec::update( yylloc, linkage, $2 );
                 }
           up external_definition down
@@ -3207 +3058 @@
                 {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                        linkage = LinkageSpec::update( yylloc, linkage, $2 );
                 }
           '{' up external_definition_list_opt down '}'
@@ -3218 +3069 @@
         | type_qualifier_list
                 {
-                        if ( $1->type->qualifiers.any() ) {
-                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
-                        }
+                        if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
                 }
@@ -3226 +3075 @@
                 {
                         distQual( $5, $1 );
-                        forall = false;
+                        forall = false;
                         $$ = $5;
                 }
         | declaration_qualifier_list
                 {
-                        if ( $1->type && $1->type->qualifiers.any() ) {
-                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
-                        }
+                        if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
                 }
@@ -3239 +3086 @@
                 {
                         distQual( $5, $1 );
-                        forall = false;
+                        forall = false;
                         $$ = $5;
                 }
         | declaration_qualifier_list type_qualifier_list
                 {
-                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) {
-                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
-                        }
+                        if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
                 }
@@ -3252 +3097 @@
                 {
                         distQual( $6, $1->addQualifiers( $2 ) );
-                        forall = false;
+                        forall = false;
                         $$ = $6;
                 }
@@ -3277 +3122 @@
                         $$ = $3; forall = false;
                         if ( $5 ) {
-                                SemanticError( yylloc, "syntax error, attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
+                                SemanticError( yylloc, "Attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
                                 $$ = nullptr;
                         } // if
@@ -3296 +3141 @@
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
                 }
-        | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
+        | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
                 {
                         rebindForall( $1, $2 );
@@ -3332 +3177 @@
         | variable_type_redeclarator
         | function_declarator
-        | function_type_redeclarator
         ;
 
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
         ;
 
@@ -3346 +3190 @@
                 {
                         DeclarationNode * name = new DeclarationNode();
-                        name->asmName = maybeMoveBuild( $3 );
+                        name->asmName = $3;
                         $$ = name->addQualifiers( $5 );
                 }
@@ -3443 +3287 @@
 variable_ptr:
         ptrref_operator variable_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3459 +3303 @@
         | '(' attribute_list variable_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
@@ -3507 +3351 @@
 function_ptr:
         ptrref_operator function_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3559 +3403 @@
 KR_function_ptr:
         ptrref_operator KR_function_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list KR_function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3583 +3427 @@
         ;
 
-// This pattern parses a declaration for a variable that redefines a type name, e.g.:
+// This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
 //
 //              typedef int foo;
@@ -3589 +3433 @@
 //                 int foo; // redefine typedef name in new scope
 //              }
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
+// and functions versus pointers to arrays and functions.
 
 paren_type:
@@ -3603 +3450 @@
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
-        | variable_type_ptr
-        | variable_type_array attribute_list_opt
+        | type_ptr
+        | type_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
-        | variable_type_function attribute_list_opt
+        | type_function attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         ;
 
-variable_type_ptr:
+type_ptr:
         ptrref_operator variable_type_redeclarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
+        | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
-        | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
+        | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
         ;
 
-variable_type_array:
+type_array:
         paren_type array_dimension
                 { $$ = $1->addArray( $2 ); }
-        | '(' variable_type_ptr ')' array_dimension
+        | '(' type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list variable_type_ptr ')' array_dimension
+        | '(' attribute_list type_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
+        | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
+        | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' variable_type_array ')'                                           // redundant parenthesis
+        | '(' type_array ')'                                                            // redundant parenthesis
                 { $$ = $2; }
-        | '(' attribute_list variable_type_array ')'            // redundant parenthesis
+        | '(' attribute_list type_array ')'                                     // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
         ;
 
-variable_type_function:
-        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
-        | '(' variable_type_function ')'                                        // redundant parenthesis
-                { $$ = $2; }
-        | '(' attribute_list variable_type_function ')'         // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 ); }
-        ;
-
-// This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
-// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
-// arrays and functions.
-
-function_type_redeclarator:
-        function_type_no_ptr attribute_list_opt
-                { $$ = $1->addQualifiers( $2 ); }
-        | function_type_ptr
-        | function_type_array attribute_list_opt
-                { $$ = $1->addQualifiers( $2 ); }
-        ;
-
-function_type_no_ptr:
+type_function:
         paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
-        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
+        | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
+        | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
-        | '(' function_type_no_ptr ')'                                          // redundant parenthesis
+        | '(' type_function ')'                                                         // redundant parenthesis
                 { $$ = $2; }
-        | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 ); }
-        ;
-
-function_type_ptr:
-        ptrref_operator function_type_redeclarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
-        | ptrref_operator type_qualifier_list function_type_redeclarator
-                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' function_type_ptr ')' attribute_list_opt
-                { $$ = $2->addQualifiers( $4 ); }
-        | '(' attribute_list function_type_ptr ')' attribute_list_opt
-                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
-        ;
-
-function_type_array:
-        '(' function_type_ptr ')' array_dimension
-                { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list function_type_ptr ')' array_dimension
-                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
-                { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' function_type_array ')'                                           // redundant parenthesis
-                { $$ = $2; }
-        | '(' attribute_list function_type_array ')'            // redundant parenthesis
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
         ;
@@ -3719 +3517 @@
 identifier_parameter_ptr:
         ptrref_operator identifier_parameter_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3776 +3574 @@
 type_parameter_ptr:
         ptrref_operator type_parameter_redeclarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3819 +3617 @@
 abstract_ptr:
         ptrref_operator
-                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -3852 +3650 @@
                 // Only the first dimension can be empty.
         '[' ']'
-                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
+                { $$ = DeclarationNode::newArray( 0, 0, false ); }
         | '[' ']' multi_array_dimension
-                { $$ = DeclarationNode::newArray( nullptr, nullptr, false )->addArray( $3 ); }
+                { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $3 ); }
                 // Cannot use constant_expression because of tuples => semantic check
         | '[' push assignment_expression pop ',' comma_expression ']' // CFA
-                { $$ = DeclarationNode::newArray( $3, nullptr, false )->addArray( DeclarationNode::newArray( $6, nullptr, false ) ); }
+                { $$ = DeclarationNode::newArray( $3, 0, false )->addArray( DeclarationNode::newArray( $6, 0, false ) ); }
                 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
         | '[' push array_type_list pop ']'                                      // CFA
@@ -3866 +3664 @@
 array_type_list:
         basic_type_name
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | type_name
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression upupeq assignment_expression
         | array_type_list ',' basic_type_name
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
-        | array_type_list ',' type_name
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+        | array_type_list ',' type_name 
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' assignment_expression upupeq assignment_expression
         ;
@@ -3882 +3680 @@
         | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
-        ;
+        ;
 
 multi_array_dimension:
         '[' push assignment_expression pop ']'
-                { $$ = DeclarationNode::newArray( $3, nullptr, false ); }
+                { $$ = DeclarationNode::newArray( $3, 0, false ); }
         | '[' push '*' pop ']'                                                          // C99
                 { $$ = DeclarationNode::newVarArray( 0 ); }
         | multi_array_dimension '[' push assignment_expression pop ']'
-                { $$ = $1->addArray( DeclarationNode::newArray( $4, nullptr, false ) ); }
+                { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
         | multi_array_dimension '[' push '*' pop ']'            // C99
                 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
@@ -3987 +3785 @@
 array_parameter_1st_dimension:
         '[' ']'
-                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
+                { $$ = DeclarationNode::newArray( 0, 0, false ); }
                 // multi_array_dimension handles the '[' '*' ']' case
         | '[' push type_qualifier_list '*' pop ']'                      // remaining C99
                 { $$ = DeclarationNode::newVarArray( $3 ); }
         | '[' push type_qualifier_list pop ']'
-                { $$ = DeclarationNode::newArray( nullptr, $3, false ); }
+                { $$ = DeclarationNode::newArray( 0, $3, false ); }
                 // multi_array_dimension handles the '[' assignment_expression ']' case
         | '[' push type_qualifier_list assignment_expression pop ']'
@@ -4021 +3819 @@
 variable_abstract_ptr:
         ptrref_operator
-                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator variable_abstract_declarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
@@ -4067 +3865 @@
                 // No SUE declaration in parameter list.
         ptrref_operator type_specifier_nobody
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier_nobody
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_identifier_parameter_declarator_tuple
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
@@ -4084 +3882 @@
                 // shift/reduce conflict with new-style empty (void) function return type.
         '[' ']' type_specifier_nobody
-                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
         | cfa_array_parameter_1st_dimension type_specifier_nobody
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension type_specifier_nobody
-                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension type_specifier_nobody
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
@@ -4095 +3893 @@
 
         | '[' ']' cfa_identifier_parameter_ptr
-                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
         | cfa_array_parameter_1st_dimension cfa_identifier_parameter_ptr
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension cfa_identifier_parameter_ptr
-                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension cfa_identifier_parameter_ptr
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
@@ -4155 +3953 @@
 cfa_abstract_ptr:                                                                               // CFA
         ptrref_operator type_specifier
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_declarator_tuple
-                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }