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

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