Index: src/SymTab/Mangler.cc
===================================================================
--- src/SymTab/Mangler.cc	(revision 8360977bb829bdb44991648e6c891fc1e71629ea)
+++ src/SymTab/Mangler.cc	(revision 69911c112f8ee63e5b034a4052592b8607062c40)
@@ -30,6 +30,12 @@
 
 namespace SymTab {
-	Mangler::Mangler( bool mangleOverridable, bool includeQualifiers )
-		: nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), includeQualifiers(includeQualifiers) {}
+	std::string Mangler::mangleType( Type *ty ) {
+		Mangler mangler( false, true );
+		maybeAccept( ty, mangler );
+		return mangler.get_mangleName();
+	}
+	
+	Mangler::Mangler( bool mangleOverridable, bool typeMode )
+		: nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
 		
 	Mangler::Mangler( const Mangler &rhs ) : mangleName() {
@@ -38,5 +44,5 @@
 		isTopLevel = rhs.isTopLevel;
 		mangleOverridable = rhs.mangleOverridable;
-		includeQualifiers = rhs.includeQualifiers;
+		typeMode = rhs.typeMode;
 	}
 
@@ -164,11 +170,9 @@
 		if ( ! params.empty() ) {
 			mangleName << "_";
-			std::list< Type* > paramTypes;
 			for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
 				TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
 				assert(paramType && "Aggregate parameters should be type expressions");
-				paramTypes.push_back( paramType->get_type() );
+				maybeAccept( paramType->get_type(), *this );
 			}
-			acceptAll( paramTypes, *this );
 			mangleName << "_";
 		}
@@ -179,9 +183,11 @@
 
 	void Mangler::visit( StructInstType *aggregateUseType ) {
-		mangleGenericRef( aggregateUseType, "s" );
+		if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
+		else mangleRef( aggregateUseType, "s" );
 	}
 
 	void Mangler::visit( UnionInstType *aggregateUseType ) {
-		mangleGenericRef( aggregateUseType, "u" );
+		if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
+		else mangleRef( aggregateUseType, "u" );
 	}
 
@@ -233,5 +239,5 @@
 	void Mangler::printQualifiers( Type *type ) {
 		// skip if not including qualifiers
-		if ( ! includeQualifiers ) return;
+		if ( typeMode ) return;
 		
 		if ( ! type->get_forall().empty() ) {
@@ -253,5 +259,5 @@
 				varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
 				for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
-					Mangler sub_mangler( mangleOverridable, includeQualifiers );
+					Mangler sub_mangler( mangleOverridable, typeMode );
 					sub_mangler.nextVarNum = nextVarNum;
 					sub_mangler.isTopLevel = false;
Index: src/SymTab/Mangler.h
===================================================================
--- src/SymTab/Mangler.h	(revision 8360977bb829bdb44991648e6c891fc1e71629ea)
+++ src/SymTab/Mangler.h	(revision 69911c112f8ee63e5b034a4052592b8607062c40)
@@ -25,6 +25,9 @@
 	class Mangler : public Visitor {
 	  public:
+		/// Mangle syntax tree object; primary interface to clients
 		template< typename SynTreeClass >
-	    static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool includeQualifiers = true ); // interface to clients
+	    static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true );
+		/// Mangle a type name; secondary interface
+		static std::string mangleType( Type* ty );
 
 		virtual void visit( ObjectDecl *declaration );
@@ -51,7 +54,7 @@
 		bool isTopLevel;                ///< Is the Mangler at the top level
 		bool mangleOverridable;         ///< Specially mangle overridable built-in methods
-		bool includeQualifiers;         ///< Include type qualifiers in mangled name
+		bool typeMode;                  ///< Produce a unique mangled name for a type
   
-		Mangler( bool mangleOverridable, bool includeQualifiers );
+		Mangler( bool mangleOverridable, bool typeMode );
 		Mangler( const Mangler & );
   
@@ -64,6 +67,6 @@
 
 	template< typename SynTreeClass >
-	std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool includeQualifiers ) {
-		Mangler mangler( mangleOverridable, includeQualifiers );
+	std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) {
+		Mangler mangler( mangleOverridable, false );
 		maybeAccept( decl, mangler );
 		return mangler.get_mangleName();