Index: src/SynTree/AggregateDecl.cc
===================================================================
--- src/SynTree/AggregateDecl.cc	(revision 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ 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 {