Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/DeclarationNode.cc	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -177,4 +177,10 @@
 }
 
+DeclarationNode * DeclarationNode::newFromTypeData( TypeData * type ) {
+	DeclarationNode * newnode = new DeclarationNode;
+	newnode->type = type;
+	return newnode;
+} // DeclarationNode::newFromTypeData
+
 DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) {
 	DeclarationNode * newnode = new DeclarationNode;
@@ -188,64 +194,4 @@
 	return newnode;
 } // DeclarationNode::newFuncSpecifier
-
-DeclarationNode * DeclarationNode::newTypeQualifier( ast::CV::Qualifiers tq ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData();
-	newnode->type->qualifiers = tq;
-	return newnode;
-} // DeclarationNode::newQualifier
-
-DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Basic );
-	newnode->type->basictype = bt;
-	return newnode;
-} // DeclarationNode::newBasicType
-
-DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Basic );
-	newnode->type->complextype = ct;
-	return newnode;
-} // DeclarationNode::newComplexType
-
-DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Basic );
-	newnode->type->signedness = sn;
-	return newnode;
-} // DeclarationNode::newSignedNess
-
-DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Basic );
-	newnode->type->length = lnth;
-	return newnode;
-} // DeclarationNode::newLength
-
-DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Unknown );
-	newnode->type->forall = forall;
-	return newnode;
-} // DeclarationNode::newForall
-
-DeclarationNode * DeclarationNode::newFromGlobalScope() {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::GlobalScope );
-	return newnode;
-}
-
-DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Qualified );
-	newnode->type->qualified.parent = parent->type;
-	newnode->type->qualified.child = child->type;
-	parent->type = nullptr;
-	child->type = nullptr;
-	delete parent;
-	delete child;
-	return newnode;
-}
 
 DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
@@ -312,22 +258,4 @@
 }
 
-DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = name;
-	newnode->type->symbolic.isTypedef = true;
-	newnode->type->symbolic.params = nullptr;
-	return newnode;
-} // DeclarationNode::newFromTypedef
-
-DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = name;
-	newnode->type->symbolic.isTypedef = false;
-	newnode->type->symbolic.actuals = params;
-	return newnode;
-} // DeclarationNode::newFromTypeGen
-
 DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) {
 	DeclarationNode * newnode = newName( name );
@@ -423,18 +351,4 @@
 	return newnode;
 }
-
-DeclarationNode * DeclarationNode::newVtableType( DeclarationNode * decl ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Vtable );
-	newnode->setBase( decl->type );
-	return newnode;
-}
-
-DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Builtin );
-	newnode->type->builtintype = bt;
-	return newnode;
-} // DeclarationNode::newBuiltinType
 
 DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
Index: src/Parser/DeclarationNode.h
===================================================================
--- src/Parser/DeclarationNode.h	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/DeclarationNode.h	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -40,16 +40,7 @@
 	static const char * builtinTypeNames[];
 
+	static DeclarationNode * newFromTypeData( TypeData * );
 	static DeclarationNode * newStorageClass( ast::Storage::Classes );
 	static DeclarationNode * newFuncSpecifier( ast::Function::Specs );
-	static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers );
-	static DeclarationNode * newBasicType( BasicType );
-	static DeclarationNode * newComplexType( ComplexType );
-	static DeclarationNode * newSignedNess( Signedness );
-	static DeclarationNode * newLength( Length );
-	static DeclarationNode * newBuiltinType( BuiltinType );
-	static DeclarationNode * newForall( DeclarationNode * );
-	static DeclarationNode * newFromTypedef( const std::string * );
-	static DeclarationNode * newFromGlobalScope();
-	static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
 	static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
 	static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
@@ -59,5 +50,4 @@
 	static DeclarationNode * newEnumInLine( const std::string name );
 	static DeclarationNode * newName( const std::string * );
-	static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
 	static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * );
 	static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
@@ -70,5 +60,4 @@
 	static DeclarationNode * newTuple( DeclarationNode * members );
 	static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
-	static DeclarationNode * newVtableType( DeclarationNode * expr );
 	static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
 	static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
@@ -163,6 +152,4 @@
 }; // DeclarationNode
 
-ast::Type * buildType( TypeData * type );
-
 static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) {
 	ast::Type * ret = orig ? orig->buildType() : nullptr;
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/ExpressionNode.cc	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -29,4 +29,5 @@
 #include "DeclarationNode.h"       // for DeclarationNode
 #include "InitializerNode.h"       // for InitializerNode
+#include "TypeData.h"              // for addType, build_basic_type, build_c...
 #include "parserutility.h"         // for notZeroExpr
 
@@ -316,10 +317,10 @@
 				v2 );
 			ret = build_compoundLiteral( location,
-				DeclarationNode::newBasicType(
-					DeclarationNode::Int128
-				)->addType(
-					DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+				DeclarationNode::newFromTypeData(
+					addType(
+						build_basic_type( DeclarationNode::Int128 ),
+						build_signedness( DeclarationNode::Unsigned ) ) ),
 				new InitializerNode(
-					(InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )
+					(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )
 			);
 		} else {										// explicit length, (length_type)constant
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/TypeData.cc	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -478,5 +478,4 @@
 }
 
-
 TypeData * TypeData::getLastBase() {
 	TypeData * cur = this;
@@ -487,4 +486,80 @@
 void TypeData::setLastBase( TypeData * newBase ) {
 	getLastBase()->base = newBase;
+}
+
+
+TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) {
+	TypeData * type = new TypeData;
+	type->qualifiers = tq;
+	return type;
+}
+
+TypeData * build_basic_type( DeclarationNode::BasicType basic ) {
+	TypeData * type = new TypeData( TypeData::Basic );
+	type->basictype = basic;
+	return type;
+}
+
+TypeData * build_complex_type( DeclarationNode::ComplexType complex ) {
+	TypeData * type = new TypeData( TypeData::Basic );
+	type->complextype = complex;
+	return type;
+}
+
+TypeData * build_signedness( DeclarationNode::Signedness signedness ) {
+	TypeData * type = new TypeData( TypeData::Basic );
+	type->signedness = signedness;
+	return type;
+}
+
+TypeData * build_builtin_type( DeclarationNode::BuiltinType bit ) {
+	TypeData * type = new TypeData( TypeData::Builtin );
+	type->builtintype = bit;
+	return type;
+}
+
+TypeData * build_length( DeclarationNode::Length length ) {
+	TypeData * type = new TypeData( TypeData::Basic );
+	type->length = length;
+	return type;
+}
+
+TypeData * build_forall( DeclarationNode * forall ) {
+	TypeData * type = new TypeData( TypeData::Unknown );
+	type->forall = forall;
+	return type;
+}
+
+TypeData * build_global_scope() {
+	return new TypeData( TypeData::GlobalScope );
+}
+
+TypeData * build_qualified_type( TypeData * parent, TypeData * child ) {
+	TypeData * type = new TypeData( TypeData::Qualified );
+	type->qualified.parent = parent;
+	type->qualified.child = child;
+	return type;
+}
+
+TypeData * build_typedef( const std::string * name ) {
+	TypeData * type = new TypeData( TypeData::SymbolicInst );
+	type->symbolic.name = name;
+	type->symbolic.isTypedef = true;
+	type->symbolic.actuals = nullptr;
+	return type;
+}
+
+TypeData * build_type_gen( const std::string * name, ExpressionNode * params ) {
+	TypeData * type = new TypeData( TypeData::SymbolicInst );
+	type->symbolic.name = name;
+	type->symbolic.isTypedef = false;
+	type->symbolic.actuals = params;
+	return type;
+}
+
+TypeData * build_vtable_type( TypeData * base ) {
+	TypeData * type = new TypeData( TypeData::Vtable );
+	type->base = base;
+	return type;
 }
 
@@ -627,4 +702,9 @@
 		return rtype;
 	} // if
+}
+
+TypeData * addType( TypeData * ltype, TypeData * rtype ) {
+	std::vector<ast::ptr<ast::Attribute>> attributes;
+	return addType( ltype, rtype, attributes );
 }
 
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/TypeData.h	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -116,8 +116,24 @@
 };
 
+
+TypeData * build_type_qualifier( ast::CV::Qualifiers );
+TypeData * build_basic_type( DeclarationNode::BasicType );
+TypeData * build_complex_type( DeclarationNode::ComplexType );
+TypeData * build_signedness( DeclarationNode::Signedness );
+TypeData * build_builtin_type( DeclarationNode::BuiltinType );
+TypeData * build_length( DeclarationNode::Length );
+TypeData * build_forall( DeclarationNode * );
+TypeData * build_global_scope();
+TypeData * build_qualified_type( TypeData *, TypeData * );
+TypeData * build_typedef( const std::string * name );
+TypeData * build_type_gen( const std::string * name, ExpressionNode * params );
+TypeData * build_vtable_type( TypeData * );
+
 TypeData * addQualifiers( TypeData * ltype, TypeData * rtype );
 TypeData * addType( TypeData * ltype, TypeData * rtype, std::vector<ast::ptr<ast::Attribute>> & );
+TypeData * addType( TypeData * ltype, TypeData * rtype );
 TypeData * cloneBaseType( TypeData * type, TypeData * other );
 TypeData * makeNewBase( TypeData * type );
+
 
 ast::Type * typebuild( const TypeData * );
@@ -144,4 +160,10 @@
 void buildKRFunction( const TypeData::Function_t & function );
 
+static inline ast::Type * maybeMoveBuildType( TypeData * type ) {
+	ast::Type * ret = type ? typebuild( type ) : nullptr;
+	delete type;
+	return ret;
+}
+
 // Local Variables: //
 // tab-width: 4 //
Index: src/Parser/TypedefTable.cc
===================================================================
--- src/Parser/TypedefTable.cc	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/TypedefTable.cc	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -20,4 +20,6 @@
 #include <string>										// for string
 #include <iostream>										// for iostream
+
+struct TypeData;
 
 #include "ExpressionNode.h"								// for LabelNode
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 06601401c36e6b2cf39fa38d23552cf5418850f3)
+++ src/Parser/parser.yy	(revision 03606cedf407315d91e097e003ebbf953caa4e1e)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  4 08:44:25 2024
-// Update Count     : 6562
+// Last Modified On : Wed Mar  6 10:51:55 2024
+// Update Count     : 6588
 //
 
@@ -317,22 +317,33 @@
 
 %union {
+	// A raw token can be used.
 	Token tok;
+
+	// The general node types hold some generic node or list of nodes.
+	DeclarationNode * decl;
+	InitializerNode * init;
 	ExpressionNode * expr;
-	DeclarationNode * decl;
-	ast::AggregateDecl::Aggregate aggKey;
-	ast::TypeDecl::Kind tclass;
 	StatementNode * stmt;
 	ClauseNode * clause;
-	ast::WaitForStmt * wfs;
-    ast::WaitUntilStmt::ClauseNode * wucn;
+	TypeData * type;
+
+	// Special "nodes" containing compound information.
 	CondCtl * ifctl;
 	ForCtrl * forctl;
 	LabelNode * labels;
-	InitializerNode * init;
+
+	// Various flags and single values that become fields later.
+	ast::AggregateDecl::Aggregate aggKey;
+	ast::TypeDecl::Kind tclass;
 	OperKinds oper;
-	std::string * str;
 	bool is_volatile;
 	EnumHiding enum_hiding;
 	ast::ExceptionKind except_kind;
+	// String passes ownership with it.
+	std::string * str;
+
+	// Narrower node types are used to avoid constant unwrapping.
+	ast::WaitForStmt * wfs;
+	ast::WaitUntilStmt::ClauseNode * wucn;
 	ast::GenericExpr * genexpr;
 }
@@ -464,5 +475,6 @@
 
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
-%type<decl> vtable vtable_opt default_opt
+%type<type> basic_type_name_type
+%type<type> vtable vtable_opt default_opt
 
 %type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
@@ -519,5 +531,6 @@
 %type<decl> type_declarator type_declarator_name type_declaring_list
 
-%type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
+%type<decl> type_declaration_specifier type_type_specifier
+%type<type> type_name typegen_name
 %type<decl> typedef_name typedef_declaration typedef_expression
 
@@ -532,5 +545,6 @@
 %type<expr> type_parameters_opt type_list array_type_list // array_dimension_list
 
-%type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
+%type<decl> type_qualifier forall type_qualifier_list_opt type_qualifier_list
+%type<type> type_qualifier_name
 %type<decl> type_specifier type_specifier_nobody
 
@@ -687,6 +701,4 @@
 		{ $$ = 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( yylloc, $1 ) ); }
 	| tuple
@@ -696,5 +708,5 @@
 		{ $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::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( yylloc, DeclarationNode::newFromTypeData( $1 ), build_varref( yylloc, $3 ) ) ); }
 	| type_name '.' '[' field_name_list ']'				// CFA, nested type / tuple field selector
 		{ SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -751,5 +763,5 @@
 		// 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( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, $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
@@ -766,5 +778,5 @@
 			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 ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), $1->set_last( $3 ) ) ) );
 		}
 	| postfix_expression '(' argument_expression_list_opt ')'
@@ -772,6 +784,6 @@
 	| 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") ) ),
-											   (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
+		{ $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg" ) ) ),
+											   $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 ) ); }
@@ -831,5 +843,5 @@
 			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( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), $2->set_last( $4 ) ) );
 		}
 	;
@@ -844,5 +856,5 @@
 	argument_expression
 	| argument_expression_list_opt ',' argument_expression
-		{ $$ = (ExpressionNode *)($1->set_last( $3 )); }
+		{ $$ = $1->set_last( $3 ); }
 	;
 
@@ -856,5 +868,5 @@
 field_name_list:										// CFA, tuple field selector
 	field
-	| field_name_list ',' field					{ $$ = (ExpressionNode *)($1->set_last( $3 )); }
+	| field_name_list ',' field					{ $$ = $1->set_last( $3 ); }
 	;
 
@@ -938,7 +950,15 @@
 	| ALIGNOF '(' type_no_function ')'					// GCC, type alignment
 		{ $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+
+		// Cannot use rule "type", which includes cfa_abstract_function, for sizeof/alignof, because of S/R problems on
+		// look ahead, so the cfa_abstract_function is factored out.
+	| SIZEOF '(' cfa_abstract_function ')'
+		{ $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+	| ALIGNOF '(' cfa_abstract_function ')'				// GCC, type alignment
+		{ $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+
 	| OFFSETOF '(' type_no_function ',' identifier ')'
 		{ $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
-	| TYPEID '(' type_no_function ')'
+	| TYPEID '(' type ')'
 		{
 			SemanticError( yylloc, "typeid name is currently unimplemented." ); $$ = nullptr;
@@ -970,5 +990,5 @@
 		{ $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
 	| '(' VIRTUAL ')' cast_expression					// CFA
-		{ $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+		{ $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), nullptr ) ); }
 	| '(' VIRTUAL type_no_function ')' cast_expression	// CFA
 		{ $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
@@ -1142,7 +1162,7 @@
 //		{ $$ = new ExpressionNode( build_tuple( $3 ) ); }
 	'[' ',' tuple_expression_list ']'
-		{ $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+		{ $$ = new ExpressionNode( build_tuple( yylloc, (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( yylloc, $3->set_last( $6 ) ) ); }
 	;
 
@@ -1152,5 +1172,5 @@
 		{ SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
 	| tuple_expression_list ',' assignment_expression
-		{ $$ = (ExpressionNode *)($1->set_last( $3 )); }
+		{ $$ = $1->set_last( $3 ); }
 	| tuple_expression_list ',' '@'
 		{ SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
@@ -1238,5 +1258,6 @@
 		{ assert( $1 ); $1->set_last( $2 ); $$ = $1; }
 	| statement_list_nodecl error						// invalid syntax rule
-		{ SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; }
+		{ SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body,"
+						 " i.e., after the '{'." ); $$ = nullptr; }
 	;
 
@@ -1246,9 +1267,27 @@
 	;
 
-// if, switch, and choose require parenthesis around the conditional because it can be followed by a statement.
-// For example, without parenthesis:
-//
-//    if x + y + z; => "if ( x + y ) + z" or "if ( x ) + y + z"
-//    switch ( S ) { ... } => switch ( S ) { compound literal... } ... or 
+// "if", "switch", and "choose" require parenthesis around the conditional. See the following ambiguities without
+// parenthesis:
+//
+//   if x + y + z; => "if ( x + y ) + z" or "if ( x ) + y + z"
+//
+//   switch O { }
+// 
+//     O{} => object-constructor for conditional, switch body ???
+//     O{} => O for conditional followed by switch body
+// 
+//     C++ has this problem, as it has the same constructor syntax.
+// 
+//   switch sizeof ( T ) { }
+// 
+//     sizeof ( T ) => sizeof of T for conditional followed by switch body
+//     sizeof ( T ) => sizeof of compound literal (T){ }, closing parenthesis ???
+// 
+//     Note the two grammar rules for sizeof (alignof)
+// 
+//       | SIZEOF unary_expression
+//       | SIZEOF '(' type_no_function ')'
+// 
+//     where the first DOES NOT require parenthesis! And C++ inherits this problem from C.
 
 selection_statement:
@@ -1268,5 +1307,5 @@
 			// 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( yylloc, (new StatementNode( $7 ))->set_last( sw ) ) ) : sw;
 		}
 	| SWITCH '(' comma_expression ')' '{' error '}'		// CFA, invalid syntax rule error
@@ -1277,5 +1316,5 @@
 		{
 			StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
-			$$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+			$$ = $7 ? new StatementNode( build_compound( yylloc, (new StatementNode( $7 ))->set_last( sw ) ) ) : sw;
 		}
 	| CHOOSE '(' comma_expression ')' '{' error '}'		// CFA, invalid syntax rule
@@ -1679,5 +1718,4 @@
 	cast_expression
 	| cast_expression_list ',' cast_expression
-		// { $$ = (ExpressionNode *)($1->set_last( $3 )); }
 		{ SemanticError( yylloc, "List of mutex member is currently unimplemented." ); $$ = nullptr; }
 	;
@@ -1695,5 +1733,5 @@
 		{ $$ = $3; }
 	| WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
-		{ $$ = (ExpressionNode *)($3->set_last( $5 )); }
+		{ $$ = $3->set_last( $5 ); }
 	;
 
@@ -1851,5 +1889,5 @@
 	asm_operand
 	| asm_operands_list ',' asm_operand
-		{ $$ = (ExpressionNode *)($1->set_last( $3 )); }
+		{ $$ = $1->set_last( $3 ); }
 	;
 
@@ -1870,5 +1908,5 @@
 		{ $$ = $1; }
 	| asm_clobbers_list_opt ',' string_literal
-		{ $$ = (ExpressionNode *)( $1->set_last( $3 ) ); }
+		{ $$ = $1->set_last( $3 ); }
 	;
 
@@ -2188,4 +2226,5 @@
 type_qualifier:
 	type_qualifier_name
+		{ $$ = DeclarationNode::newFromTypeData( $1 ); }
 	| attribute											// trick handles most attribute locations
 	;
@@ -2193,13 +2232,18 @@
 type_qualifier_name:
 	CONST
-		{ $$ = DeclarationNode::newTypeQualifier( ast::CV::Const ); }
+		{ $$ = build_type_qualifier( ast::CV::Const ); }
 	| RESTRICT
-		{ $$ = DeclarationNode::newTypeQualifier( ast::CV::Restrict ); }
+		{ $$ = build_type_qualifier( ast::CV::Restrict ); }
 	| VOLATILE
-		{ $$ = DeclarationNode::newTypeQualifier( ast::CV::Volatile ); }
+		{ $$ = build_type_qualifier( ast::CV::Volatile ); }
 	| ATOMIC
-		{ $$ = DeclarationNode::newTypeQualifier( ast::CV::Atomic ); }
+		{ $$ = build_type_qualifier( ast::CV::Atomic ); }
+
+		// forall must be a CV qualifier because it can appear in places where SC qualifiers are disallowed.
+		//
+		//   void foo( forall( T ) T (*)( T ) ); // forward declaration
+		//   void bar( static int ); // static disallowed (gcc/CFA)
 	| forall
-		{ $$ = DeclarationNode::newForall( $1 ); }
+		{ $$ = build_forall( $1 ); }
 	;
 
@@ -2251,36 +2295,42 @@
 
 basic_type_name:
+	basic_type_name_type
+		{ $$ = DeclarationNode::newFromTypeData( $1 ); }
+	;
+
+// Just an intermediate value for conversion.
+basic_type_name_type:
 	VOID
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+		{ $$ = build_basic_type( DeclarationNode::Void ); }
 	| BOOL												// C99
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+		{ $$ = build_basic_type( DeclarationNode::Bool ); }
 	| CHAR
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+		{ $$ = build_basic_type( DeclarationNode::Char ); }
 	| INT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+		{ $$ = build_basic_type( DeclarationNode::Int ); }
 	| INT128
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }
+		{ $$ = build_basic_type( DeclarationNode::Int128 ); }
 	| UINT128
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ); }
+		{ $$ = addType( build_basic_type( DeclarationNode::Int128 ), build_signedness( DeclarationNode::Unsigned ) ); }
 	| FLOAT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+		{ $$ = build_basic_type( DeclarationNode::Float ); }
 	| DOUBLE
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+		{ $$ = build_basic_type( DeclarationNode::Double ); }
 	| uuFLOAT80
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
+		{ $$ = build_basic_type( DeclarationNode::uuFloat80 ); }
 	| uuFLOAT128
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
+		{ $$ = build_basic_type( DeclarationNode::uuFloat128 ); }
 	| uFLOAT16
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat16 ); }
 	| uFLOAT32
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat32 ); }
 	| uFLOAT32X
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat32x ); }
 	| uFLOAT64
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat64 ); }
 	| uFLOAT64X
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat64x ); }
 	| uFLOAT128
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
+		{ $$ = build_basic_type( DeclarationNode::uFloat128 ); }
 	| DECIMAL32
 		{ SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }
@@ -2290,19 +2340,19 @@
 		{ SemanticError( yylloc, "_Decimal128 is currently unimplemented." ); $$ = nullptr; }
 	| COMPLEX											// C99
-		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+		{ $$ = build_complex_type( DeclarationNode::Complex ); }
 	| IMAGINARY											// C99
-		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+		{ $$ = build_complex_type( DeclarationNode::Imaginary ); }
 	| SIGNED
-		{ $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
+		{ $$ = build_signedness( DeclarationNode::Signed ); }
 	| UNSIGNED
-		{ $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+		{ $$ = build_signedness( DeclarationNode::Unsigned ); }
 	| SHORT
-		{ $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+		{ $$ = build_length( DeclarationNode::Short ); }
 	| LONG
-		{ $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
+		{ $$ = build_length( DeclarationNode::Long ); }
 	| VA_LIST											// GCC, __builtin_va_list
-		{ $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+		{ $$ = build_builtin_type( DeclarationNode::Valist ); }
 	| AUTO_TYPE
-		{ $$ = DeclarationNode::newBuiltinType( DeclarationNode::AutoType ); }
+		{ $$ = build_builtin_type( DeclarationNode::AutoType ); }
 	| vtable
 	;
@@ -2316,6 +2366,5 @@
 vtable:
 	VTABLE '(' type_name ')' default_opt
-		{ $$ = DeclarationNode::newVtableType( $3 ); }
-		// { SemanticError( yylloc, "vtable is currently unimplemented." ); $$ = nullptr; }
+		{ $$ = build_vtable_type( $3 ); }
 	;
 
@@ -2367,7 +2416,7 @@
 		{ $$ = DeclarationNode::newTypeof( $3, true ); }
 	| ZERO_T											// CFA
-		{ $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
+		{ $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::Zero ) ); }
 	| ONE_T												// CFA
-		{ $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
+		{ $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::One ) ); }
 	;
 
@@ -2425,6 +2474,7 @@
 type_type_specifier:									// typedef types
 	type_name
+		{ $$ = DeclarationNode::newFromTypeData( $1 ); }
 	| type_qualifier_list type_name
-		{ $$ = $2->addQualifiers( $1 ); }
+		{ $$ = DeclarationNode::newFromTypeData( $2 )->addQualifiers( $1 ); }
 	| type_type_specifier type_qualifier
 		{ $$ = $1->addQualifiers( $2 ); }
@@ -2433,23 +2483,23 @@
 type_name:
 	TYPEDEFname
-		{ $$ = DeclarationNode::newFromTypedef( $1 ); }
+		{ $$ = build_typedef( $1 ); }
 	| '.' TYPEDEFname
-		{ $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
+		{ $$ = build_qualified_type( build_global_scope(), build_typedef( $2 ) ); }
 	| type_name '.' TYPEDEFname
-		{ $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
+		{ $$ = build_qualified_type( $1, build_typedef( $3 ) ); }
 	| typegen_name
 	| '.' typegen_name
-		{ $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
+		{ $$ = build_qualified_type( build_global_scope(), $2 ); }
 	| type_name '.' typegen_name
-		{ $$ = DeclarationNode::newQualifiedType( $1, $3 ); }
+		{ $$ = build_qualified_type( $1, $3 ); }
 	;
 
 typegen_name:											// CFA
 	TYPEGENname
-		{ $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
+		{ $$ = build_type_gen( $1, nullptr ); }
 	| TYPEGENname '(' ')'
-		{ $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
+		{ $$ = build_type_gen( $1, nullptr ); }
 	| TYPEGENname '(' type_list ')'
-		{ $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
+		{ $$ = build_type_gen( $1, $3 ); }
 	;
 
@@ -2463,4 +2513,6 @@
 	| enum_type_nobody
 	;
+
+// ************************** AGGREGATE *******************************
 
 aggregate_type:											// struct, union
@@ -2485,5 +2537,5 @@
 	  '{' field_declaration_list_opt '}' type_parameters_opt
 		{
-			DeclarationNode::newFromTypedef( $3 );
+			DeclarationNode::newFromTypeData( build_typedef( $3 ) );
 			$$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 		}
@@ -2495,5 +2547,5 @@
 	  '{' field_declaration_list_opt '}' type_parameters_opt
 		{
-			DeclarationNode::newFromTypeGen( $3, nullptr );
+			DeclarationNode::newFromTypeData( build_type_gen( $3, nullptr ) );
 			$$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 		}
@@ -2520,11 +2572,10 @@
 			// Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
 			// switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
-			// delete newFromTypeGen.
-			if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) {
-				$$ = $3->addQualifiers( $2 );
+			if ( $3->kind == TypeData::SymbolicInst && ! $3->symbolic.isTypedef ) {
+				$$ = DeclarationNode::newFromTypeData( $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;
+				$$ = DeclarationNode::newAggregate( $1, $3->symbolic.name, $3->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+				$3->symbolic.name = nullptr;			// copied to $$
+				$3->symbolic.actuals = nullptr;
 				delete $3;
 			}
@@ -2544,5 +2595,4 @@
 	| EXCEPTION											// CFA
 		{ $$ = ast::AggregateDecl::Exception; }
-	  //		{ SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
 	;
 
@@ -2683,7 +2733,5 @@
 	;
 
-// ***********
-// Enumeration
-// ***********
+// ************************** ENUMERATION *******************************
 
 enum_type:
@@ -2754,6 +2802,6 @@
 	| ENUM attribute_list_opt type_name
 		{
-			typedefTable.makeTypedef( *$3->type->symbolic.name, "enum_type_nobody 2" );
-			$$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 );
+			typedefTable.makeTypedef( *$3->symbolic.name, "enum_type_nobody 2" );
+			$$ = DeclarationNode::newEnum( $3->symbolic.name, nullptr, false, false )->addQualifiers( $2 );
 		}
 	;
@@ -2763,5 +2811,5 @@
 		{ $$ = DeclarationNode::newEnumValueGeneric( $2, $3 ); }
 	| INLINE type_name
-		{ $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); }
+		{ $$ = DeclarationNode::newEnumInLine( *$2->symbolic.name ); }
 	| enumerator_list ',' visible_hide_opt identifier_or_type_name enumerator_value_opt
 		{ $$ = $1->set_last( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); }
@@ -2785,7 +2833,5 @@
 	;
 
-// *******************
-// Function parameters
-// *******************
+// ************************** FUNCTION PARAMETERS *******************************
 
 parameter_list_ellipsis_opt:
@@ -2810,5 +2856,5 @@
 cfa_parameter_list_ellipsis_opt:						// CFA, abstract + real
 	// empty
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+		{ $$ = DeclarationNode::newFromTypeData( build_basic_type( DeclarationNode::Void ) ); }
 	| ELLIPSIS
 		{ $$ = nullptr; }
@@ -2868,5 +2914,5 @@
 	| type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initializer_opt
 		{ $$ = $2->addName( $3 )->addQualifiers( $1 ); }
-	| cfa_function_specifier
+	| cfa_function_specifier							// int f( "int fp()" );
 	;
 
@@ -2878,5 +2924,5 @@
 	| type_qualifier_list cfa_abstract_tuple
 		{ $$ = $2->addQualifiers( $1 ); }
-	| cfa_abstract_function
+	| cfa_abstract_function								// int f( "int ()" );
 	;
 
@@ -2928,6 +2974,6 @@
 	| initializer
 	| designation initializer					{ $$ = $2->set_designators( $1 ); }
-	| initializer_list_opt ',' initializer		{ $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
-	| initializer_list_opt ',' designation initializer { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
+	| initializer_list_opt ',' initializer		{ $$ = $1->set_last( $3 ); }
+	| initializer_list_opt ',' designation initializer { $$ = $1->set_last( $4->set_designators( $3 ) ); }
 	;
 
@@ -2951,5 +2997,5 @@
 	designator
 	| designator_list designator
-		{ $$ = (ExpressionNode *)($1->set_last( $2 )); }
+		{ $$ = $1->set_last( $2 ); }
 	//| designator_list designator						{ $$ = new ExpressionNode( $1, $2 ); }
 	;
@@ -3036,7 +3082,7 @@
 		{ $$ = ast::TypeDecl::Dtype; }
 	| '*'
-		{ $$ = ast::TypeDecl::DStype; }						// dtype + sized
-	// | '(' '*' ')'
-	// 	{ $$ = ast::TypeDecl::Ftype; }
+		{ $$ = ast::TypeDecl::DStype; }					// Dtype + sized
+	// | '(' '*' ')'									// Gregor made me do it
+	//  	{ $$ = ast::TypeDecl::Ftype; }
 	| ELLIPSIS
 		{ $$ = ast::TypeDecl::Ttype; }
@@ -3080,7 +3126,7 @@
 	| assignment_expression
 	| type_list ',' type
-		{ $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+		{ $$ = $1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) ); }
 	| type_list ',' assignment_expression
-		{ $$ = (ExpressionNode *)( $1->set_last( $3 )); }
+		{ $$ = $1->set_last( $3 ); }
 	;
 
@@ -3244,5 +3290,5 @@
 			$$ = $6;
 		}
-	// global distribution
+		// global distribution
 	| type_qualifier_list
 		{
@@ -3369,4 +3415,6 @@
 	;
 
+// **************************** ASM *****************************
+
 asm_name_opt:											// GCC
 	// empty
@@ -3379,4 +3427,6 @@
 		}
 	;
+
+// **************************** ATTRIBUTE *****************************
 
 attribute_list_opt:										// GCC
@@ -3742,5 +3792,5 @@
 		{ $$ = $1->addQualifiers( $2 ); }
 	| '&' MUTEX paren_identifier attribute_list_opt
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ),
+		{ $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ),
 															OperKinds::AddressOf ) )->addQualifiers( $4 ); }
 	| identifier_parameter_ptr
@@ -3793,5 +3843,5 @@
 		{ $$ = $1->addQualifiers( $2 ); }
 	| '&' MUTEX typedef_name attribute_list_opt
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ),
+		{ $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ),
 															OperKinds::AddressOf ) )->addQualifiers( $4 ); }
 	| type_parameter_ptr
@@ -3826,5 +3876,5 @@
 
 type_parameter_function:
-	typedef_name '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)
+	typedef_name '(' parameter_list_ellipsis_opt ')'	// empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $1->addParamList( $3 ); }
 	| '(' type_parameter_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)
@@ -3876,5 +3926,5 @@
 
 abstract_function:
-	'(' parameter_list_ellipsis_opt ')'			// empty parameter list OBSOLESCENT (see 3)
+	'(' parameter_list_ellipsis_opt ')'					// empty parameter list OBSOLESCENT (see 3)
 		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
 	| '(' abstract_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)
@@ -3915,7 +3965,7 @@
 	| assignment_expression upupeq assignment_expression
 	| array_type_list ',' basic_type_name
-		{ $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+		{ $$ = $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 ) ) ) )); }
+		{ $$ = $1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) ); }
 	| array_type_list ',' assignment_expression upupeq assignment_expression
 	;
@@ -3977,5 +4027,5 @@
 	abstract_parameter_ptr
 	| '&' MUTEX attribute_list_opt
-		{ $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
+		{ $$ = DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ), OperKinds::AddressOf )->addQualifiers( $3 ); }
 	| abstract_parameter_array attribute_list_opt
 		{ $$ = $1->addQualifiers( $2 ); }
@@ -4008,5 +4058,5 @@
 
 abstract_parameter_function:
-	'(' parameter_list_ellipsis_opt ')'			// empty parameter list OBSOLESCENT (see 3)
+	'(' parameter_list_ellipsis_opt ')'					// empty parameter list OBSOLESCENT (see 3)
 		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
 	| '(' abstract_parameter_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)
@@ -4280,4 +4330,4 @@
 // mode: c++ //
 // tab-width: 4 //
-// compile-command: "make install" //
+// compile-command: "bison -Wcounterexamples parser.yy" //
 // End: //