Changes in src/Parser/parser.yy [bb7422a:70056ed]

File:

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

src/Parser/parser.yy

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr  4 14:02:00 2023
-// Update Count     : 6329
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 30 21:28:25 2023
+// Update Count     : 6328
 //
 
@@ -64 +64 @@
 
 extern DeclarationNode * parseTree;
-extern ast::Linkage::Spec linkage;
+extern LinkageSpec::Spec linkage;
 extern TypedefTable typedefTable;
 
-stack<ast::Linkage::Spec> linkageStack;
+stack<LinkageSpec::Spec> linkageStack;
 
 bool appendStr( string & to, string & from ) {
@@ -200 +200 @@
 } // fieldDecl
 
-#define NEW_ZERO new ExpressionNode( build_constantInteger( yylloc, *new string( "0" ) ) )
-#define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
+#define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) )
+#define NEW_ONE  new ExpressionNode( build_constantInteger( *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
 #define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
@@ -208 +208 @@
 
 static ForCtrl * makeForCtrl(
-                const CodeLocation & location,
                 DeclarationNode * init,
                 enum OperKinds compop,
@@ -214 +213 @@
                 ExpressionNode * inc ) {
         // Wrap both comp/inc if they are non-null.
-        if ( comp ) comp = new ExpressionNode( build_binary_val( location,
+        if ( comp ) comp = new ExpressionNode( build_binary_val(
                 compop,
-                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                new ExpressionNode( build_varref( new string( *init->name ) ) ),
                 comp ) );
-        if ( inc ) inc = new ExpressionNode( build_binary_val( location,
+        if ( inc ) inc = new ExpressionNode( build_binary_val(
                 // choose += or -= for upto/downto
                 compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
-                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                new ExpressionNode( build_varref( new string( *init->name ) ) ),
                 inc ) );
         // The StatementNode call frees init->name, it must happen later.
@@ -227 +226 @@
 }
 
-ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( 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." );
@@ -235 +234 @@
         } // if
         DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
-        return makeForCtrl( location, initDecl, compop, comp, inc );
+        return makeForCtrl( initDecl, compop, comp, inc );
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
-        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
-                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
+ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
+        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
+                type = new ExpressionNode( new CastExpr( maybeMoveBuild( type ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
         } // if
         DeclarationNode * initDecl = distAttr(
@@ -247 +246 @@
                 DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) )
         );
-        return makeForCtrl( location, initDecl, compop, comp, inc );
+        return makeForCtrl( initDecl, compop, comp, inc );
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
-                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
-        } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
-                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
-                        return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
+                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
+                if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
+                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
@@ -300 +299 @@
         ExpressionNode * en;
         DeclarationNode * decl;
-        ast::AggregateDecl::Aggregate aggKey;
-        ast::TypeDecl::Kind tclass;
+        AggregateDecl::Aggregate aggKey;
+        TypeDecl::Kind tclass;
         StatementNode * sn;
-        ast::WaitForStmt * wfs;
-        ast::Expr * constant;
+        WaitForStmt * wfs;
+        Expression * constant;
         CondCtl * ifctl;
         ForCtrl * fctl;
@@ -314 +313 @@
         bool flag;
         EnumHiding hide;
-        ast::ExceptionKind catch_kind;
-        ast::GenericExpr * genexpr;
+        CatchStmt::Kind catch_kind;
+        GenericExpr * genexpr;
 }
 
-// ************************ TERMINAL TOKENS ********************************
+//************************* TERMINAL TOKENS ********************************
 
 // keywords
@@ -612 +611 @@
 constant:
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
-        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( yylloc, *$1 ) ); }
-        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
-        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( yylloc, *$1 ) ); }
+        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
         ;
 
@@ -642 +641 @@
 
 string_literal:
-        string_literal_list                                                     { $$ = build_constantStr( yylloc, *$1 ); }
+        string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
         ;
 
@@ -659 +658 @@
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | quasi_keyword
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | TYPEDIMname                                                                           // CFA, generic length argument
                 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
                 // { $$ = new ExpressionNode( build_varref( $1 ) ); }
-                { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
         | tuple
         | '(' comma_expression ')'
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
-                { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); }
+                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild( $2 ) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
-                { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -704 +703 @@
                 {
                         // steal the association node from the singleton and delete the wrapper
-                        assert( 1 == $3->associations.size() );
-                        $1->associations.push_back( $3->associations.front() );
+                        $1->associations.splice($1->associations.end(), $3->associations);
                         delete $3;
                         $$ = $1;
@@ -715 +713 @@
                 {
                         // create a GenericExpr wrapper with one association pair
-                        $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuildType( $1 ), maybeMoveBuild( $3 ) } } );
+                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild( $3 ) } } );
                 }
         | DEFAULT ':' assignment_expression
-                { $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuild( $3 ) } } ); }
+                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild( $3 ) } } ); }
         ;
 
@@ -727 +725 @@
                 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
                 // Current: Commas in subscripts make tuples.
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
@@ -733 +731 @@
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
                 {
                         Token fn;
                         fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
-                        $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
                 }
         | postfix_expression '(' argument_expression_list_opt ')'
-                { $$ = new ExpressionNode( build_func( yylloc, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
         | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')'
                 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; }
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg") ) ),
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__builtin_va_arg") ) ),
                                                                                            (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
         | postfix_expression '.' identifier
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression '.' aggregate_control
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $3, $1 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
         | postfix_expression ARROW identifier
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
         | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ICR
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
-                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, new InitializerNode( $5, true ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
-                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
                 {
                         Token fn;
                         fn.str = new string( "^?{}" );                          // location undefined
-                        $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
                 }
         ;
@@ -815 +813 @@
         field_name
         | FLOATING_DECIMALconstant field
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), build_tuple( yylloc, $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
         | field_name '.' field
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | field_name ARROW field
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
-                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         ;
 
 field_name:
         INTEGERconstant fraction_constants_opt
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_constantInteger( yylloc, *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
         | FLOATINGconstant fraction_constants_opt
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_field_name_FLOATINGconstant( yylloc, *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
                 {
-                        $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_varref( yylloc, $1 ), $2 ) );
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
                 }
         ;
@@ -844 +842 @@
         | fraction_constants_opt FLOATING_FRACTIONconstant
                 {
-                        ast::Expr * constant = build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 );
-                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( yylloc, $1, constant ) ) : new ExpressionNode( constant );
+                        Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
+                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
                 }
         ;
@@ -864 +862 @@
                 {
                         switch ( $1 ) {
-                        case OperKinds::AddressOf:
-                                $$ = new ExpressionNode( new ast::AddressExpr( maybeMoveBuild( $2 ) ) );
+                          case OperKinds::AddressOf:
+                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild( $2 ) ) );
                                 break;
-                        case OperKinds::PointTo:
-                                $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) );
+                          case OperKinds::PointTo:
+                                $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
                                 break;
-                        case OperKinds::And:
-                                $$ = new ExpressionNode( new ast::AddressExpr( new ast::AddressExpr( maybeMoveBuild( $2 ) ) ) );
+                          case OperKinds::And:
+                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild( $2 ) ) ) );
                                 break;
-                        default:
+                          default:
                                 assert( false );
                         }
                 }
         | unary_operator cast_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
         | ICR unary_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
-                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
-                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
-                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
-                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
-                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' identifier ')'
-                { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
+                { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
         | TYPEID '(' type_no_function ')'
                 {
@@ -917 +915 @@
         unary_expression
         | '(' type_no_function ')' cast_expression
-                { $$ = new ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' aggregate_control '*' ')' cast_expression         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
-                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
-                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
@@ -933 +931 @@
                 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
-//              { $$ = new ast::ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+//              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         ;
 
@@ -951 +949 @@
         cast_expression
         | exponential_expression '\\' cast_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Exp, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
         ;
 
@@ -957 +955 @@
         exponential_expression
         | multiplicative_expression '*' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mul, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Div, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mod, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
         ;
 
@@ -967 +965 @@
         multiplicative_expression
         | additive_expression '+' multiplicative_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Plus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
         | additive_expression '-' multiplicative_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Minus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
         ;
 
@@ -975 +973 @@
         additive_expression
         | shift_expression LS additive_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
         | shift_expression RS additive_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::RShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
         ;
 
@@ -983 +981 @@
         shift_expression
         | relational_expression '<' shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
         | relational_expression '>' shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
         | relational_expression LE shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
         | relational_expression GE shift_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
         ;
 
@@ -995 +993 @@
         relational_expression
         | equality_expression EQ relational_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Eq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
         | equality_expression NE relational_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Neq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
         ;
 
@@ -1003 +1001 @@
         equality_expression
         | AND_expression '&' equality_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitAnd, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
         ;
 
@@ -1009 +1007 @@
         AND_expression
         | exclusive_OR_expression '^' AND_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Xor, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
         ;
 
@@ -1015 +1013 @@
         exclusive_OR_expression
         | inclusive_OR_expression '|' exclusive_OR_expression
-                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitOr, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
         ;
 
@@ -1021 +1019 @@
         inclusive_OR_expression
         | logical_AND_expression ANDAND inclusive_OR_expression
-                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::AndExpr ) ); }
+                { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
         ;
 
@@ -1027 +1025 @@
         logical_AND_expression
         | logical_OR_expression OROR logical_AND_expression
-                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::OrExpr ) ); }
+                { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
         ;
 
@@ -1033 +1031 @@
         logical_OR_expression
         | logical_OR_expression '?' comma_expression ':' conditional_expression
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
+                { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
         ;
 
@@ -1051 +1049 @@
 //                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
 //                      } else {
-                                $$ = new ExpressionNode( build_binary_val( yylloc, $2, $1, $3 ) );
+                                $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
 //                      } // if
                 }
@@ -1096 +1094 @@
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         '[' ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
         ;
 
@@ -1114 +1112 @@
         assignment_expression
         | comma_expression ',' assignment_expression
-                { $$ = new ExpressionNode( new ast::CommaExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         ;
 
@@ -1141 +1139 @@
         | asm_statement
         | DIRECTIVE
-                { $$ = new StatementNode( build_directive( yylloc, $1 ) ); }
+                { $$ = new StatementNode( build_directive( $1 ) ); }
         ;
 
@@ -1147 +1145 @@
                 // labels cannot be identifiers 0 or 1
         identifier_or_type_name ':' attribute_list_opt statement
-                { $$ = $4->add_label( yylloc, $1, $3 ); }
+                { $$ = $4->add_label( $1, $3 ); }
         | identifier_or_type_name ':' attribute_list_opt error // syntax error
                 {
@@ -1159 +1157 @@
 compound_statement:
         '{' '}'
-                { $$ = new StatementNode( build_compound( yylloc, (StatementNode *)0 ) ); }
+                { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
-                { $$ = new StatementNode( build_compound( yylloc, $4 ) ); }
+                { $$ = new StatementNode( build_compound( $4 ) ); }
         ;
 
@@ -1195 +1193 @@
 expression_statement:
         comma_expression_opt ';'
-                { $$ = new StatementNode( build_expr( yylloc, $1 ) ); }
+                { $$ = new StatementNode( build_expr( $1 ) ); }
         ;
 
@@ -1204 +1202 @@
                 { $$ = $2; }
         | SWITCH '(' comma_expression ')' case_clause
-                { $$ = new StatementNode( build_switch( yylloc, true, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
         | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
-                        StatementNode *sw = new StatementNode( build_switch( yylloc, true, $3, $8 ) );
+                        StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
                         // The semantics of the declaration list is changed to include associated initialization, which is performed
                         // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
@@ -1213 +1211 @@
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
-                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
                 }
         | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
                 { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
-                { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
-                        StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
-                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        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
@@ -1231 +1229 @@
         IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
-                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), nullptr ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
         | IF '(' conditional_declaration ')' statement ELSE statement
-                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), maybe_build_compound( yylloc, $7 ) ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
@@ -1253 +1251 @@
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
         ;
@@ -1269 +1267 @@
         | CASE case_value_list error                                            // syntax error
                 { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
-        | DEFAULT ':'                                                           { $$ = new StatementNode( build_default( yylloc ) ); }
+        | DEFAULT ':'                                                           { $$ = new StatementNode( build_default() ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
         | DEFAULT error                                                                         //  syntax error
@@ -1281 +1279 @@
 
 case_clause:                                                                                    // CFA
-        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( yylloc, $2 ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
         ;
 
@@ -1292 +1290 @@
 switch_clause_list:                                                                             // CFA
         case_label_list statement_list_nodecl
-                { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); }
+                { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
         | switch_clause_list case_label_list statement_list_nodecl
-                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ) ); }
+                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
         ;
 
 iteration_statement:
         WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) ); }
+                { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); }
         | WHILE '(' ')' statement ELSE statement                        // CFA
                 {
-                        $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) );
+                        $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
-                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
-                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
-                { $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ELSE statement                     // CFA
                 {
-                        $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) );
+                        $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
-                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ), $8 ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
-                { $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
                 {
-                        $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) );
+                        $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
-                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
-                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
         ;
 
@@ -1344 +1342 @@
                         if ( $1->condition ) {
                                 if ( $3->condition ) {
-                                        $1->condition->expr.reset( new ast::LogicalExpr( yylloc, $1->condition->expr.release(), $3->condition->expr.release(), ast::AndExpr ) );
+                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
                                 } // if
                         } else $1->condition = $3->condition;
                         if ( $1->change ) {
                                 if ( $3->change ) {
-                                        $1->change->expr.reset( new ast::CommaExpr( yylloc, $1->change->expr.release(), $3->change->expr.release() ) );
+                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
                                 } // if
                         } else $1->change = $3->change;
@@ -1361 +1359 @@
         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
                 {
-                        StatementNode * init = $1 ? new StatementNode( new ast::ExprStmt( yylloc, maybeMoveBuild( $1 ) ) ) : nullptr;
+                        StatementNode * init = $1 ? new StatementNode( new ExprStmt( maybeMoveBuild( $1 ) ) ) : nullptr;
                         $$ = new ForCtrl( init, $3, $5 );
                 }
@@ -1373 +1371 @@
 
         | comma_expression                                                                      // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
         | downupdowneq comma_expression                                         // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | comma_expression updowneq comma_expression            // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
         | '@' updowneq comma_expression                                         // CFA, anonymous loop-index
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
                 }
         | comma_expression updowneq '@'                                         // CFA, anonymous loop-index
@@ -1390 +1388 @@
                 }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
-                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
         | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                        else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
                 }
         | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index
@@ -1413 +1411 @@
 
         | comma_expression ';' comma_expression                         // CFA
-                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
+                { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
         | comma_expression ';' downupdowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | comma_expression ';' comma_expression updowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
         | comma_expression ';' '@' updowneq comma_expression // CFA
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
                 }
         | comma_expression ';' comma_expression updowneq '@' // CFA
@@ -1428 +1426 @@
                         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( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
                 }
         | comma_expression ';' '@' updowneq '@'                         // CFA, error
@@ -1434 +1432 @@
 
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
         | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 );
                 }
         | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA
@@ -1444 +1442 @@
                         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( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 );
                 }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
-                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
+                { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
         | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr );
                 }
         | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA
@@ -1457 +1455 @@
                         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( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr );
                 }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
@@ -1463 +1461 @@
 
         | declaration comma_expression                                          // CFA
-                { $$ = forCtrl( yylloc, $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
+                { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
         | declaration downupdowneq comma_expression                     // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
 
         | declaration comma_expression updowneq comma_expression // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
         | declaration '@' updowneq comma_expression                     // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE );
                 }
         | declaration comma_expression updowneq '@'                     // CFA
@@ -1478 +1476 @@
                         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( yylloc, $1, $2, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE );
                 }
 
         | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
         | declaration '@' updowneq comma_expression '~' comma_expression // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, $6 );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, $6 );
                 }
         | declaration comma_expression updowneq '@' '~' comma_expression // CFA
@@ -1492 +1490 @@
                         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( yylloc, $1, $2, $3, nullptr, $6 );
+                        else $$ = forCtrl( $1, $2, $3, nullptr, $6 );
                 }
         | declaration comma_expression updowneq comma_expression '~' '@' // CFA
-                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
+                { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
         | declaration '@' updowneq comma_expression '~' '@' // CFA
                 {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
-                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, nullptr );
+                        else $$ = forCtrl( $1, $4, $3, nullptr, nullptr );
                 }
         | declaration comma_expression updowneq '@' '~' '@'     // CFA
@@ -1505 +1503 @@
                         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( yylloc, $1, $2, $3, nullptr, nullptr );
+                        else $$ = forCtrl( $1, $2, $3, nullptr, nullptr );
                 }
         | declaration '@' updowneq '@' '~' '@'                          // CFA, error
@@ -1548 +1546 @@
 jump_statement:
         GOTO identifier_or_type_name ';'
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Goto ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
                 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
@@ -1555 +1553 @@
                 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
         | fall_through_name ';'                                                         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
         | fall_through_name identifier_or_type_name ';'         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
         | fall_through_name DEFAULT ';'                                         // CFA
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThroughDefault ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
         | CONTINUE ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
         | CONTINUE identifier_or_type_name ';'                          // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
         | BREAK ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
         | BREAK identifier_or_type_name ';'                                     // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
-                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
         | RETURN comma_expression_opt ';'
-                { $$ = new StatementNode( build_return( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_return( $2 ) ); }
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | SUSPEND ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::None ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr ) ); }
         | SUSPEND compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $2, ast::SuspendStmt::None ) ); }
+                { $$ = new StatementNode( build_suspend( $2 ) ); }
         | SUSPEND COROUTINE ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
         | SUSPEND COROUTINE compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
         | SUSPEND GENERATOR ';'
-                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
         | SUSPEND GENERATOR compound_statement
-                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
-                { $$ = new StatementNode( build_throw( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_throw( $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
-                { $$ = new StatementNode( build_resume( yylloc, $2 ) ); }
+                { $$ = new StatementNode( build_resume( $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
@@ -1605 +1603 @@
 with_statement:
         WITH '(' tuple_expression_list ')' statement
-                { $$ = new StatementNode( build_with( yylloc, $3, $5 ) ); }
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
         ;
 
@@ -1613 +1611 @@
                 {
                         if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
-                        $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
+                        $$ = new StatementNode( build_mutex( $3, $5 ) );
                 }
         ;
@@ -1652 +1650 @@
         when_clause_opt waitfor statement                                       %prec THEN
                 // Called first: create header for WaitForStmt.
-                { $$ = build_waitfor( yylloc, new ast::WaitForStmt( yylloc ), $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+                { $$ = build_waitfor( new WaitForStmt(), $1, $2, maybe_build_compound( $3 ) ); }
         | wor_waitfor_clause wor when_clause_opt waitfor statement
-                { $$ = build_waitfor( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+                { $$ = build_waitfor( $1, $3, $4, maybe_build_compound( $5 ) ); }
         | wor_waitfor_clause wor when_clause_opt ELSE statement
-                { $$ = build_waitfor_else( yylloc, $1, $3, maybe_build_compound( yylloc, $5 ) ); }
+                { $$ = build_waitfor_else( $1, $3, maybe_build_compound( $5 ) ); }
         | wor_waitfor_clause wor when_clause_opt timeout statement      %prec THEN
-                { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+                { $$ = build_waitfor_timeout( $1, $3, $4, maybe_build_compound( $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
                 { SemanticError( yylloc, "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 ) ); }
-        ;
+                { $$ = build_waitfor_else( build_waitfor_timeout( $1, $3, $4, maybe_build_compound( $5 ) ), $7, maybe_build_compound( $9 ) ); }
 
 waitfor_statement:
@@ -1714 +1711 @@
         wor_waituntil_clause                                                            %prec THEN
                 // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
-                { $$ = new StatementNode( build_compound( yylloc, nullptr ) ); }
+                { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
         ;
 
 exception_statement:
-        TRY compound_statement handler_clause                                   %prec THEN
-                { $$ = new StatementNode( build_try( yylloc, $2, $3, nullptr ) ); }
+        TRY compound_statement handler_clause                           %prec THEN
+                { $$ = new StatementNode( build_try( $2, $3, nullptr ) ); }
         | TRY compound_statement finally_clause
-                { $$ = new StatementNode( build_try( yylloc, $2, nullptr, $3 ) ); }
+                { $$ = new StatementNode( build_try( $2, nullptr, $3 ) ); }
         | TRY compound_statement handler_clause finally_clause
-                { $$ = new StatementNode( build_try( yylloc, $2, $3, $4 ) ); }
+                { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
         ;
 
 handler_clause:
         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
-                { $$ = new StatementNode( build_catch( yylloc, $1, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
         ;
 
@@ -1740 +1737 @@
 
 handler_key:
-        CATCH                                                                           { $$ = ast::Terminate; }
-        | RECOVER                                                                       { $$ = ast::Terminate; }
-        | CATCHRESUME                                                           { $$ = ast::Resume; }
-        | FIXUP                                                                         { $$ = ast::Resume; }
+        CATCH                                                                           { $$ = CatchStmt::Terminate; }
+        | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
+        | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
+        | FIXUP                                                                         { $$ = CatchStmt::Resume; }
         ;
 
 finally_clause:
-        FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( yylloc, $2 ) ); }
+        FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
         ;
 
@@ -1773 +1770 @@
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, nullptr ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, nullptr ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
-                { $$ = new StatementNode( build_asm( yylloc, $2, $5, nullptr, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $5, nullptr, $8, $10, $12 ) ); }
         ;
 
@@ -1805 +1802 @@
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new ast::AsmExpr( yylloc, "", $1, maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
-                {
-                        $$ = new ExpressionNode( new ast::AsmExpr( yylloc, *$2.str, $4, maybeMoveBuild( $6 ) ) );
-                        delete $2.str;
-                }
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild( $6 ) ) ); }
         ;
 
@@ -1825 +1819 @@
         identifier
                 {
-                        $$ = new LabelNode(); $$->labels.emplace_back( yylloc, *$1 );
+                        $$ = new LabelNode(); $$->labels.push_back( *$1 );
                         delete $1;                                                                      // allocated by lexer
                 }
         | label_list ',' identifier
                 {
-                        $$ = $1; $1->labels.emplace_back( yylloc, *$3 );
+                        $$ = $1; $1->labels.push_back( *$3 );
                         delete $3;                                                                      // allocated by lexer
                 }
@@ -1893 +1887 @@
                 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
         | STATICASSERT '(' constant_expression ')' ';'          // CFA
-                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( yylloc, *new string( "\"\"" ) ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
@@ -2093 +2087 @@
                 {
                         SemanticError( yylloc, ::toString( "Missing ';' after end of ",
-                                $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
                                 " declaration" ) );
                         $$ = nullptr;
@@ -2327 +2321 @@
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
-                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ), true ); }
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
@@ -2521 +2515 @@
 aggregate_data:
         STRUCT vtable_opt
-                { $$ = ast::AggregateDecl::Struct; }
+                { $$ = AggregateDecl::Struct; }
         | UNION
-                { $$ = ast::AggregateDecl::Union; }
+                { $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
-                { $$ = ast::AggregateDecl::Exception; }
-          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
+                { $$ = AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 
 aggregate_control:                                                                              // CFA
         MONITOR
-                { $$ = ast::AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | MUTEX STRUCT
-                { $$ = ast::AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | GENERATOR
-                { $$ = ast::AggregateDecl::Generator; }
+                { $$ = AggregateDecl::Generator; }
         | MUTEX GENERATOR
-                {
-                        SemanticError( yylloc, "monitor generator is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
-                { $$ = ast::AggregateDecl::Coroutine; }
+                { $$ = AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
-                {
-                        SemanticError( yylloc, "monitor coroutine is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
-                { $$ = ast::AggregateDecl::Thread; }
+                { $$ = AggregateDecl::Thread; }
         | MUTEX THREAD
-                {
-                        SemanticError( yylloc, "monitor thread is currently unimplemented." );
-                        $$ = ast::AggregateDecl::NoAggregate;
-                }
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 
@@ -2904 +2889 @@
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
-                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         ;
 
@@ -2916 +2901 @@
 designator:
         '.' identifier_at                                                                       // C99, field name
-                { $$ = new ExpressionNode( build_varref( yylloc, $2 ) ); }
+                { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
                 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
@@ -2923 +2908 @@
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
@@ -2963 +2948 @@
                 {
                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
-                        if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
-                        if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
-                        if ( $1 == ast::TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                        if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
+                        if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
+                        if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
                 }
           type_initializer_opt assertion_list_opt
@@ -2976 +2961 @@
                 {
                         typedefTable.addToScope( *$2, TYPEDIMname, "9" );
-                        $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
+                        $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
                 }
         // | type_specifier identifier_parameter_declarator
         | assertion_list
-                { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
         ;
 
 new_type_class:                                                                                 // CFA
         // empty
-                { $$ = ast::TypeDecl::Otype; }
+                { $$ = TypeDecl::Otype; }
         | '&'
-                { $$ = ast::TypeDecl::Dtype; }
+                { $$ = TypeDecl::Dtype; }
         | '*'
-                { $$ = ast::TypeDecl::DStype; }                                         // dtype + sized
+                { $$ = TypeDecl::DStype; }                                              // dtype + sized
         // | '(' '*' ')'
-        //      { $$ = ast::TypeDecl::Ftype; }
+        //      { $$ = TypeDecl::Ftype; }
         | ELLIPSIS
-                { $$ = ast::TypeDecl::Ttype; }
+                { $$ = TypeDecl::Ttype; }
         ;
 
 type_class:                                                                                             // CFA
         OTYPE
-                { $$ = ast::TypeDecl::Otype; }
+                { $$ = TypeDecl::Otype; }
         | DTYPE
-                { $$ = ast::TypeDecl::Dtype; }
+                { $$ = TypeDecl::Dtype; }
         | FTYPE
-                { $$ = ast::TypeDecl::Ftype; }
+                { $$ = TypeDecl::Ftype; }
         | TTYPE
-                { $$ = ast::TypeDecl::Ttype; }
+                { $$ = TypeDecl::Ttype; }
         ;
 
@@ -3030 +3015 @@
 type_list:                                                                                              // CFA
         type
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
         | type_list ',' type
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
@@ -3140 +3125 @@
 external_definition:
         DIRECTIVE
-                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( yylloc, $1 ) ) ); }
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
         | declaration
                 {
@@ -3146 +3131 @@
                         // 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->linkage == LinkageSpec::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;
@@ -3173 +3158 @@
                 }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
-                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( yylloc, false, $3, nullptr ) ) ); }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, nullptr ) ) ); }
         | EXTERN STRINGliteral
                 {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                        linkage = LinkageSpec::update( yylloc, linkage, $2 );
                 }
           up external_definition down
@@ -3188 +3173 @@
                 {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                        linkage = LinkageSpec::update( yylloc, linkage, $2 );
                 }
           '{' up external_definition_list_opt down '}'
@@ -3312 +3297 @@
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
-                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         ;
 
@@ -3841 +3826 @@
 array_type_list:
         basic_type_name
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | type_name
-                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression upupeq assignment_expression
         | array_type_list ',' basic_type_name
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
-        | array_type_list ',' type_name
-                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+        | array_type_list ',' type_name 
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' assignment_expression upupeq assignment_expression
         ;