Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/CodeGen/CodeGenerator.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -129,8 +129,8 @@
 	}
 
-	void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
+	void CodeGenerator::genAttributes( vector< Attribute * > & attributes ) {
 	  if ( attributes.empty() ) return;
 		output << "__attribute__ ((";
-		for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
+		for ( vector< Attribute * >::iterator attr( attributes.begin() );; ) {
 			output << (*attr)->name;
 			if ( ! (*attr)->parameters.empty() ) {
Index: src/CodeGen/CodeGenerator.h
===================================================================
--- src/CodeGen/CodeGenerator.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/CodeGen/CodeGenerator.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -118,5 +118,5 @@
 		void postvisit( ImplicitCtorDtorStmt * );
 
-		void genAttributes( std::list< Attribute * > & attributes );
+		void genAttributes( std::vector< Attribute * > & attributes );
 
 		template< class Iterator > void genCommaList( Iterator begin, Iterator end );
Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/ControlStruct/ExceptTranslate.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -167,5 +167,5 @@
 			new BasicType( noQualifiers, BasicType::Bool ),
 			/*init*/ NULL,
-			std::list<Attribute *>{ new Attribute( "unused" ) }
+			std::vector< Attribute * >{ new Attribute( "unused" ) }
 			);
 		ObjectDecl voidptr_obj(
@@ -179,5 +179,5 @@
 					noQualifiers
 					),
-				std::list<Attribute *>{ new Attribute( "unused" ) }
+				std::vector< Attribute * >{ new Attribute( "unused" ) }
 				),
 			NULL
@@ -491,5 +491,5 @@
 		// __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
 
-		std::list< Attribute * > attributes;
+		std::vector< Attribute * > attributes;
 		{
 			std::list< Expression * > attr_params;
@@ -543,5 +543,5 @@
 
 		// Make Cleanup Attribute.
-		std::list< Attribute * > attributes;
+		std::vector< Attribute * > attributes;
 		{
 			std::list< Expression * > attr_params;
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/GenPoly/Box.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -298,5 +298,5 @@
 													 functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
 													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
-													 std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
+													 std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		layoutDecl->fixUniqueId();
 		return layoutDecl;
@@ -1485,5 +1485,5 @@
 			Attribute * aligned = new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } );
 			return new ArrayType( Type::Qualifiers(), charType, size,
-				true, false, std::list<Attribute *>{ aligned } );
+				true, false, std::vector< Attribute * >{ aligned } );
 		}
 
@@ -1764,7 +1764,7 @@
 
 		Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
-			Type *ty = sizeofExpr->get_isType() ? 
+			Type *ty = sizeofExpr->get_isType() ?
 				sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
-			
+
 			Expression * gen = genSizeof( ty );
 			if ( gen ) {
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/InitTweak/FixInit.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -824,5 +824,5 @@
 							// create a new object which is never used
 							static UniqueName dummyNamer( "_dummy" );
-							ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
+							ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::vector< Attribute * >{ new Attribute("unused") } );
 							delete ctorInit;
 							return dummy;
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/InitTweak/InitTweak.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -229,5 +229,5 @@
 
 				static UniqueName targetLabel( "L__autogen__" );
-				Label switchLabel( targetLabel.newName(), 0, std::list< Attribute * >{ new Attribute("unused") } );
+				Label switchLabel( targetLabel.newName(), 0, std::vector< Attribute * >{ new Attribute("unused") } );
 				for ( Initializer * init : *listInit ) {
 					Expression * condition;
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/Parser/DeclarationNode.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -509,5 +509,5 @@
 
 	for ( Attribute *attr: reverseIterate( q->attributes ) ) {
-		attributes.push_front( attr->clone() );
+		attributes.insert(attributes.begin(), attr->clone() );
 	} // for
 	return this;
@@ -770,5 +770,5 @@
 	if ( a ) {
 		for ( Attribute *attr: reverseIterate( a->attributes ) ) {
-			attributes.push_front( attr );
+			attributes.insert( attributes.begin(), attr );
 		} // for
 		a->attributes.clear();
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/Parser/ParseNode.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -344,5 +344,5 @@
 	LinkageSpec::Spec linkage;
 	Expression * asmName = nullptr;
-	std::list< Attribute * > attributes;
+	std::vector< Attribute * > attributes;
 	InitializerNode * initializer = nullptr;
 	bool extension = false;
@@ -374,5 +374,5 @@
 
 	virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
-		stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
+		stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::vector< Attribute * > {} );
 		delete attr;
 		delete name;
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/Parser/TypeData.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -760,5 +760,5 @@
 
 
-AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+AggregateDecl * buildAggregate( const TypeData * td, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Aggregate );
 	AggregateDecl * at;
@@ -790,5 +790,5 @@
 
 
-ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ReferenceToType * buildComAggInst( const TypeData * type, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 	switch ( type->kind ) {
 	  case TypeData::Enum: {
@@ -850,5 +850,5 @@
 	assert( td->kind == TypeData::AggregateInst );
 
-	// ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+	// ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::vector< Attribute * >() );
 	ReferenceToType * ret = nullptr;
 	TypeData * type = td->aggInst.aggregate;
@@ -887,5 +887,5 @@
 
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, std::list< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, std::vector< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Symbolic );
 	NamedTypeDecl * ret;
@@ -898,10 +898,10 @@
 	buildList( td->symbolic.params, ret->get_parameters() );
 	buildList( td->symbolic.assertions, ret->get_assertions() );
-	ret->base->attributes.splice( ret->base->attributes.end(), attributes );
+	ret->base->attributes.insert( ret->base->attributes.end(), attributes.begin(), attributes.end() );
 	return ret;
 } // buildSymbolic
 
 
-EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+EnumDecl * buildEnum( const TypeData * td, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Enum );
 	EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage );
@@ -947,5 +947,5 @@
 
 
-Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::vector< Attribute * > attributes ) {
 	if ( td->kind == TypeData::Function ) {
 		if ( td->function.idList ) {					// KR function ?
@@ -1020,5 +1020,5 @@
 				param->type = decl->type;				// set copy declaration type to parameter type
 				decl->type = nullptr;					// reset declaration type
-				param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
+				param->attributes.insert( param->attributes.end(), decl->attributes.begin(), decl->attributes.end() ); // copy and reset attributes from declaration to parameter
 			} // if
 		} // for
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/Parser/TypeData.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -19,4 +19,5 @@
 #include <list>                  // for list
 #include <string>                // for string
+#include <vector>
 
 #include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
@@ -120,14 +121,14 @@
 ArrayType * buildArray( const TypeData * );
 ReferenceType * buildReference( const TypeData * );
-AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
-ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
+AggregateDecl * buildAggregate( const TypeData *, std::vector< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage );
 ReferenceToType * buildAggInst( const TypeData * );
 TypeDecl * buildVariable( const TypeData * );
-EnumDecl * buildEnum( const TypeData *, std::list< Attribute * >, LinkageSpec::Spec );
+EnumDecl * buildEnum( const TypeData *, std::vector< Attribute * >, LinkageSpec::Spec );
 TypeInstType * buildSymbolicInst( const TypeData * );
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
 Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
-						 Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+						 Initializer * init = nullptr, std::vector< Attribute * > attributes = std::vector< Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SymTab/Autogen.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -264,5 +264,5 @@
 		LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
 		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt(),
-												std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
+												std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		decl->fixUniqueId();
 		return decl;
@@ -692,11 +692,11 @@
 					TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
 					newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
-																		   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+																		   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
 					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
-																		   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+																		   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
 					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
-																		   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+																		   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
 					newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
-																		   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+																		   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
 					typeParams.push_back( newDecl );
 					done.insert( ty->get_baseType() );
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SymTab/Validate.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -912,5 +912,5 @@
 			// attributes are not carried over from typedef to function parameters/return values
 			if ( ! inFunctionType ) {
-				ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
+				ret->attributes.insert( ret->attributes.end(), typeInst->attributes.begin(), typeInst->attributes.end() );
 			} else {
 				deleteAll( ret->attributes );
Index: src/SynTree/AggregateDecl.cc
===================================================================
--- src/SynTree/AggregateDecl.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/AggregateDecl.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -25,5 +25,5 @@
 
 
-AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
+AggregateDecl::AggregateDecl( const std::string &name, const std::vector< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
 }
 
Index: src/SynTree/ArrayType.cc
===================================================================
--- src/SynTree/ArrayType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/ArrayType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -24,5 +24,5 @@
 
 
-ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
+ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
 	base->set_lvalue( false );
Index: src/SynTree/AttrType.cc
===================================================================
--- src/SynTree/AttrType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/AttrType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -25,9 +25,9 @@
 
 
-AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes )
+AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), name( name ), expr( expr ), type( 0 ), isType( false ) {
 }
 
-AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes )
+AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), name( name ), expr( 0 ), type( type ), isType( true ) {
 }
Index: src/SynTree/Attribute.h
===================================================================
--- src/SynTree/Attribute.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/Attribute.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -19,4 +19,5 @@
 #include <list>    // for list
 #include <string>  // for string, operator==
+#include <vector>
 
 #include "BaseSyntaxNode.h"
@@ -54,5 +55,5 @@
 };
 
-const std::list< Attribute * > noAttributes;
+const std::vector< Attribute * > noAttributes;
 
 // Local Variables: //
Index: src/SynTree/BasicType.cc
===================================================================
--- src/SynTree/BasicType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/BasicType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -22,5 +22,5 @@
 class Attribute;
 
-BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
+BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
 
 void BasicType::print( std::ostream &os, Indenter indent ) const {
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/Declaration.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -20,4 +20,5 @@
 #include <list>                  // for list
 #include <string>                // for string, operator+, allocator, to_string
+#include <vector>
 
 #include "BaseSyntaxNode.h"      // for BaseSyntaxNode
@@ -83,8 +84,8 @@
 
 	Expression *asmName;
-	std::list< Attribute * > attributes;
+	std::vector< Attribute * > attributes;
 	bool isDeleted = false;
 
-	DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+	DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::vector< Attribute * > & attributes, Type::FuncSpecifiers fs );
 	DeclarationWithType( const DeclarationWithType &other );
 	virtual ~DeclarationWithType();
@@ -101,6 +102,6 @@
 	DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
 
-	std::list< Attribute * >& get_attributes() { return attributes; }
-	const std::list< Attribute * >& get_attributes() const { return attributes; }
+	std::vector< Attribute * >& get_attributes() { return attributes; }
+	const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
 	Type::FuncSpecifiers get_funcSpec() const { return fs; }
@@ -125,5 +126,5 @@
 
 	ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
-				const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+				const std::vector< Attribute * > attributes = std::vector< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 	ObjectDecl( const ObjectDecl &other );
 	virtual ~ObjectDecl();
@@ -155,5 +156,5 @@
 
 	FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
-				  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+				  const std::vector< Attribute * > attributes = std::vector< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 	FunctionDecl( const FunctionDecl &other );
 	virtual ~FunctionDecl();
@@ -265,8 +266,8 @@
 	std::list<TypeDecl*> parameters;
 	bool body;
-	std::list< Attribute * > attributes;
+	std::vector< Attribute * > attributes;
 	AggregateDecl * parent = nullptr;
 
-	AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+	AggregateDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
 	AggregateDecl( const AggregateDecl &other );
 	virtual ~AggregateDecl();
@@ -275,6 +276,6 @@
 	std::list<TypeDecl*>& get_parameters() { return parameters; }
 
-	std::list< Attribute * >& get_attributes() { return attributes; }
-	const std::list< Attribute * >& get_attributes() const { return attributes; }
+	std::vector< Attribute * >& get_attributes() { return attributes; }
+	const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
 	bool has_body() const { return body; }
@@ -290,5 +291,5 @@
 	typedef AggregateDecl Parent;
   public:
-	StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
+	StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
 	StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {}
 
@@ -308,5 +309,5 @@
 	typedef AggregateDecl Parent;
   public:
-	UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+	UnionDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
 	UnionDecl( const UnionDecl &other ) : Parent( other ) {}
 
@@ -321,5 +322,5 @@
 	typedef AggregateDecl Parent;
   public:
-	EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+	EnumDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
 	EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
@@ -337,5 +338,5 @@
 	typedef AggregateDecl Parent;
   public:
-	TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
+	TraitDecl( const std::string &name, const std::vector< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
 		assertf( attributes.empty(), "attribute unsupported for traits" );
 	}
Index: src/SynTree/DeclarationWithType.cc
===================================================================
--- src/SynTree/DeclarationWithType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/DeclarationWithType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -24,5 +24,5 @@
 #include "Type.h"                // for Type, Type::FuncSpecifiers, Type::St...
 
-DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs )
+DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::vector< Attribute * > & attributes, Type::FuncSpecifiers fs )
 	: Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
 }
Index: src/SynTree/FunctionDecl.cc
===================================================================
--- src/SynTree/FunctionDecl.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/FunctionDecl.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -30,5 +30,5 @@
 extern bool translation_unit_nomain;
 
-FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
+FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::vector< Attribute * > attributes, Type::FuncSpecifiers fs )
 	: Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
 	// hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
Index: src/SynTree/FunctionType.cc
===================================================================
--- src/SynTree/FunctionType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/FunctionType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -25,5 +25,5 @@
 class Attribute;
 
-FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), isVarArgs( isVarArgs ) {
+FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), isVarArgs( isVarArgs ) {
 }
 
Index: src/SynTree/Label.h
===================================================================
--- src/SynTree/Label.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/Label.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -19,9 +19,10 @@
 #include <list>
 #include <iostream>
+#include <vector>
 #include "SynTree.h"
 
 class Label {
   public:
-	Label( const std::string & name = "", Statement * labelled = 0, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : name( name ), labelled( labelled ), attributes( attributes ) {}
+	Label( const std::string & name = "", Statement * labelled = 0, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ) : name( name ), labelled( labelled ), attributes( attributes ) {}
 	Label( const char * name, Statement * labelled = 0 ) : name( name ), labelled( labelled ) {}
 
@@ -31,5 +32,5 @@
 	Statement * get_statement() const { return labelled; }
 	void set_statement( Statement * newValue ) { labelled = newValue; }
-	std::list< Attribute * >& get_attributes() { return attributes; }
+	std::vector< Attribute * >& get_attributes() { return attributes; }
 
 	operator std::string() const { return name; }
@@ -38,5 +39,5 @@
 	std::string name;
 	Statement * labelled;
-	std::list< Attribute * > attributes;
+	std::vector< Attribute * > attributes;
 };
 
Index: src/SynTree/ObjectDecl.cc
===================================================================
--- src/SynTree/ObjectDecl.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/ObjectDecl.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -26,5 +26,5 @@
 #include "Type.h"                // for Type, Type::StorageClasses, Type::Fu...
 
-ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
+ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::vector< Attribute * > attributes, Type::FuncSpecifiers fs )
 	: Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
 }
Index: src/SynTree/PointerType.cc
===================================================================
--- src/SynTree/PointerType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/PointerType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -23,9 +23,9 @@
 class Attribute;
 
-PointerType::PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes )
+PointerType::PointerType( const Type::Qualifiers &tq, Type *base, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), base( base ), dimension( 0 ), isVarLen( false ), isStatic( false ) {
 }
 
-PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
+PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
 }
Index: src/SynTree/ReferenceToType.cc
===================================================================
--- src/SynTree/ReferenceToType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/ReferenceToType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -27,5 +27,5 @@
 class Attribute;
 
-ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), name( name ), hoistType( false ) {
+ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), name( name ), hoistType( false ) {
 }
 
@@ -59,5 +59,5 @@
 } // namespace
 
-StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes ) :
+StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::vector< Attribute * > & attributes ) :
 		Parent( tq, baseStruct->name, attributes ), baseStruct( baseStruct ) {}
 
@@ -102,5 +102,5 @@
 
 
-UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes ) :
+UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::vector< Attribute * > & attributes ) :
 		Parent( tq, baseUnion->name, attributes ), baseUnion( baseUnion ) {}
 
@@ -145,5 +145,5 @@
 
 
-EnumInstType::EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes ) :
+EnumInstType::EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::vector< Attribute * > & attributes ) :
 		Parent( tq, baseEnum->get_name(), attributes ), baseEnum( baseEnum ) {}
 
@@ -167,5 +167,5 @@
 std::string TraitInstType::typeString() const { return "trait"; }
 
-TraitInstType::TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes ) : Parent( tq, baseTrait->name, attributes ), baseTrait( baseTrait ) {}
+TraitInstType::TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::vector< Attribute * > & attributes ) : Parent( tq, baseTrait->name, attributes ), baseTrait( baseTrait ) {}
 
 TraitInstType::TraitInstType( const TraitInstType &other ) : Parent( other ), baseTrait( other.baseTrait ) {
@@ -177,9 +177,9 @@
 bool TraitInstType::isComplete() const { assert( false ); }
 
-TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes ) : Parent( tq, name, attributes ) {
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::vector< Attribute * > & attributes ) : Parent( tq, name, attributes ) {
 	set_baseType( baseType );
 }
 
-TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes ) : Parent( tq, name, attributes ), baseType( 0 ), isFtype( isFtype ) {
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::vector< Attribute * > & attributes ) : Parent( tq, name, attributes ), baseType( 0 ), isFtype( isFtype ) {
 }
 
Index: src/SynTree/ReferenceType.cc
===================================================================
--- src/SynTree/ReferenceType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/ReferenceType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -19,5 +19,5 @@
 #include "Common/utility.h"
 
-ReferenceType::ReferenceType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes )
+ReferenceType::ReferenceType( const Type::Qualifiers &tq, Type *base, const std::vector< Attribute * > & attributes )
 	: Type( tq, attributes ), base( base ) {
 	assertf( base, "Reference Type with a null base created." );
Index: src/SynTree/TupleType.cc
===================================================================
--- src/SynTree/TupleType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/TupleType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -25,5 +25,5 @@
 class Attribute;
 
-TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
 	for ( Type * t : *this ) {
 		// xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then
Index: src/SynTree/Type.cc
===================================================================
--- src/SynTree/Type.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/Type.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -56,5 +56,5 @@
 );
 
-Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
+Type::Type( const Qualifiers &tq, const std::vector< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
 
 Type::Type( const Type &other ) : BaseSyntaxNode( other ), tq( other.tq ) {
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/Type.h	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -21,4 +21,5 @@
 #include <ostream>           // for ostream, operator<<, basic_ostream
 #include <string>            // for string
+#include <vector>
 
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
@@ -137,7 +138,7 @@
 	Qualifiers tq;
 	ForallList forall;
-	std::list< Attribute * > attributes;
-
-	Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
+	std::vector< Attribute * > attributes;
+
+	Type( const Qualifiers & tq, const std::vector< Attribute * > & attributes );
 	Type( const Type & other );
 	virtual ~Type();
@@ -159,6 +160,6 @@
 	ForallList& get_forall() { return forall; }
 
-	std::list< Attribute * >& get_attributes() { return attributes; }
-	const std::list< Attribute * >& get_attributes() const { return attributes; }
+	std::vector< Attribute * >& get_attributes() { return attributes; }
+	const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
 	/// How many elemental types are represented by this type
@@ -194,5 +195,5 @@
 class VoidType : public Type {
   public:
-	VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	VoidType( const Type::Qualifiers & tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 
 	virtual unsigned size() const override { return 0; };
@@ -238,5 +239,5 @@
 	static const char *typeNames[];						// string names for basic types, MUST MATCH with Kind
 
-	BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	BasicType( const Type::Qualifiers & tq, Kind bt, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 
 	Kind get_kind() { return kind; }
@@ -260,6 +261,6 @@
 	bool isStatic;
 
-	PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-	PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	PointerType( const Type::Qualifiers & tq, Type *base, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+	PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	PointerType( const PointerType& );
 	virtual ~PointerType();
@@ -291,5 +292,5 @@
 	bool isStatic;
 
-	ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	ArrayType( const ArrayType& );
 	virtual ~ArrayType();
@@ -334,5 +335,5 @@
 	Type *base;
 
-	ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	ReferenceType( const Type::Qualifiers & tq, Type *base, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	ReferenceType( const ReferenceType & );
 	virtual ~ReferenceType();
@@ -367,5 +368,5 @@
 	bool isVarArgs;
 
-	FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	FunctionType( const FunctionType& );
 	virtual ~FunctionType();
@@ -391,5 +392,5 @@
 	bool hoistType;
 
-	ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
+	ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes );
 	ReferenceToType( const ReferenceToType & other );
 	virtual ~ReferenceToType();
@@ -418,6 +419,6 @@
 	StructDecl *baseStruct;
 
-	StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
-	StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+	StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 
@@ -455,6 +456,6 @@
 	UnionDecl *baseUnion;
 
-	UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
-	UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
+	UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
 
@@ -492,6 +493,6 @@
 	EnumDecl *baseEnum = nullptr;
 
-	EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-	EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+	EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
 
@@ -519,6 +520,6 @@
 	TraitDecl * baseTrait = nullptr;
 
-	TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
-	TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ) : Parent( tq, name, attributes ) {}
+	TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	TraitInstType( const TraitInstType & other );
 	~TraitInstType();
@@ -541,6 +542,6 @@
 	bool isFtype;
 
-	TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-	TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
+	TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	TypeInstType( const TypeInstType & other );
 	~TypeInstType();
@@ -566,5 +567,5 @@
 	std::list<Declaration *> members;
 
-	TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	TupleType( const TupleType& );
 	virtual ~TupleType();
@@ -601,7 +602,7 @@
 	bool is_basetypeof;  ///< true iff is basetypeof type
 
-	TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-	TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
-		const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+	TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+	TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+		const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 	TypeofType( const TypeofType& );
 	virtual ~TypeofType();
@@ -625,6 +626,6 @@
 	bool isType;
 
-	AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-	AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+	AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 	AttrType( const AttrType& );
 	virtual ~AttrType();
@@ -651,5 +652,5 @@
   public:
 	VarArgsType();
-	VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	VarArgsType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
 	virtual bool isComplete() const override{ return true; } // xxx - is this right?
@@ -665,5 +666,5 @@
   public:
 	ZeroType();
-	ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	ZeroType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
 	virtual ZeroType *clone() const override { return new ZeroType( *this ); }
@@ -677,5 +678,5 @@
   public:
 	OneType();
-	OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+	OneType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
 	virtual OneType *clone() const override { return new OneType( *this ); }
Index: src/SynTree/TypeofType.cc
===================================================================
--- src/SynTree/TypeofType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/TypeofType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -23,10 +23,10 @@
 class Attribute;
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, 
-	const std::list< Attribute * > & attributes ) 
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr,
+	const std::vector< Attribute * > & attributes )
 : Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof, 
-	const std::list< Attribute * > & attributes ) 
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof,
+	const std::vector< Attribute * > & attributes )
 : Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
 
Index: src/SynTree/VarArgsType.cc
===================================================================
--- src/SynTree/VarArgsType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/VarArgsType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -21,7 +21,7 @@
 class Attribute;
 
-VarArgsType::VarArgsType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+VarArgsType::VarArgsType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+VarArgsType::VarArgsType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void VarArgsType::print( std::ostream &os, Indenter indent ) const {
Index: src/SynTree/VoidType.cc
===================================================================
--- src/SynTree/VoidType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/VoidType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -21,5 +21,5 @@
 class Attribute;
 
-VoidType::VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {
+VoidType::VoidType( const Type::Qualifiers &tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {
 }
 
Index: src/SynTree/ZeroOneType.cc
===================================================================
--- src/SynTree/ZeroOneType.cc	(revision ede87c6a5f0d54fbb88873625f5058e3f072cf1b)
+++ src/SynTree/ZeroOneType.cc	(revision 70a1c3aed5e5b84a329ddc71a02c60806fd80216)
@@ -21,7 +21,7 @@
 class Attribute;
 
-ZeroType::ZeroType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+ZeroType::ZeroType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+ZeroType::ZeroType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void ZeroType::print( std::ostream &os, Indenter ) const {
@@ -29,7 +29,7 @@
 }
 
-OneType::OneType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+OneType::OneType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+OneType::OneType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void OneType::print( std::ostream &os, Indenter ) const {