Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision ca9d65e54b7ed187b75dfe016b8d4e2debd19fa4)
+++ src/Parser/DeclarationNode.cc	(revision 5bf685f0d09d252adfe4d47e63f8e37b99c421b6)
@@ -35,5 +35,5 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
-#include "Common/utility.h"        // for maybeClone
+#include "Common/utility.h"        // for copy, spliceBegin
 #include "Parser/ExpressionNode.h" // for ExpressionNode
 #include "Parser/InitializerNode.h"// for InitializerNode
@@ -41,6 +41,4 @@
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable
-
-class Initializer;
 
 extern TypedefTable typedefTable;
@@ -101,29 +99,29 @@
 DeclarationNode * DeclarationNode::clone() const {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->set_next( maybeClone( get_next() ) );
+	newnode->set_next( maybeCopy( get_next() ) );
 	newnode->name = name ? new string( *name ) : nullptr;
 
 	newnode->builtin = NoBuiltinType;
-	newnode->type = maybeClone( type );
+	newnode->type = maybeCopy( type );
 	newnode->inLine = inLine;
 	newnode->storageClasses = storageClasses;
 	newnode->funcSpecs = funcSpecs;
-	newnode->bitfieldWidth = maybeClone( bitfieldWidth );
-	newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
+	newnode->bitfieldWidth = maybeCopy( bitfieldWidth );
+	newnode->enumeratorValue.reset( maybeCopy( enumeratorValue.get() ) );
 	newnode->hasEllipsis = hasEllipsis;
 	newnode->linkage = linkage;
 	newnode->asmName = maybeCopy( asmName );
 	newnode->attributes = attributes;
-	newnode->initializer = maybeClone( initializer );
+	newnode->initializer = maybeCopy( initializer );
 	newnode->extension = extension;
-	newnode->asmStmt = maybeClone( asmStmt );
+	newnode->asmStmt = maybeCopy( asmStmt );
 	newnode->error = error;
 
 //	newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
 	newnode->variable.tyClass = variable.tyClass;
-	newnode->variable.assertions = maybeClone( variable.assertions );
-	newnode->variable.initializer = maybeClone( variable.initializer );
-
-	newnode->assert.condition = maybeClone( assert.condition );
+	newnode->variable.assertions = maybeCopy( variable.assertions );
+	newnode->variable.initializer = maybeCopy( variable.initializer );
+
+	newnode->assert.condition = maybeCopy( assert.condition );
 	newnode->assert.message = maybeCopy( assert.message );
 	return newnode;
@@ -664,5 +662,5 @@
 				dst->base->aggInst.aggregate = src;
 				if ( src->kind == TypeData::Aggregate ) {
-					dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
+					dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
 				} // if
 				dst->base->qualifiers |= src->qualifiers;
@@ -694,5 +692,5 @@
 					if ( o->type->kind == TypeData::Aggregate ) {
 						type->aggInst.hoistType = o->type->aggregate.body;
-						type->aggInst.params = maybeClone( o->type->aggregate.actuals );
+						type->aggInst.params = maybeCopy( o->type->aggregate.actuals );
 					} else {
 						type->aggInst.hoistType = o->type->enumeration.body;
@@ -860,5 +858,5 @@
 				p->type->base->aggInst.aggregate = type;
 				if ( type->kind == TypeData::Aggregate ) {
-					p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
+					p->type->base->aggInst.params = maybeCopy( type->aggregate.actuals );
 				} // if
 				p->type->base->qualifiers |= type->qualifiers;
@@ -897,5 +895,5 @@
 			lastArray->base->aggInst.aggregate = type;
 			if ( type->kind == TypeData::Aggregate ) {
-				lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
+				lastArray->base->aggInst.params = maybeCopy( type->aggregate.actuals );
 			} // if
 			lastArray->base->qualifiers |= type->qualifiers;
@@ -950,5 +948,5 @@
 DeclarationNode * DeclarationNode::cloneType( string * name ) {
 	DeclarationNode * newnode = newName( name );
-	newnode->type = maybeClone( type );
+	newnode->type = maybeCopy( type );
 	newnode->copySpecifiers( this );
 	return newnode;
@@ -984,5 +982,5 @@
 		} // if
 
-		newType->forall = maybeClone( type->forall );
+		newType->forall = maybeCopy( type->forall );
 		if ( ! o->type ) {
 			o->type = newType;
