Index: src/Common/PassVisitor.h
===================================================================
--- src/Common/PassVisitor.h	(revision 7b15d7a7914323553bc86669ce003542d86e46e0)
+++ src/Common/PassVisitor.h	(revision ab904dc2d88885a200b84e36078cc551c9a2472f)
@@ -1,9 +1,17 @@
 #pragma once
 
+#include "SynTree/Mutator.h"
 #include "SynTree/Visitor.h"
 
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-//Deep magic (a.k.a template meta programming) to make the templated visitor work
-//Basically the goal is to make 2 previsit_impl
+#include "SynTree/Initializer.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Constant.h"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) to make the templated visitor work
+// Basically the goal is to make 2 previsit_impl
 // 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of 
 //     'pass.previsit( node )' that compiles will be used for that node for that type
@@ -16,5 +24,7 @@
 //     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
 //     the first implementation takes priority in regards to overloading.
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Mutator functions work along the same principal
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Visit
 template<typename pass_type, typename node_type>
 static inline auto previsit_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.previsit( node ), void() ) {
@@ -23,7 +33,5 @@
 
 template<typename pass_type, typename node_type>
-static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {
-	//Do nothing
-}
+static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
 
 
@@ -34,7 +42,23 @@
 
 template<typename pass_type, typename node_type>
-static inline auto postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {
-	//Do nothing
-}
+static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
+
+// Mutate
+template<typename pass_type, typename node_type>
+static inline auto premutate_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.premutate( node ), void() ) {
+	return pass.premutate( node );
+}
+
+template<typename pass_type, typename node_type>
+static inline void premutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
+
+
+template<typename return_type, typename pass_type, typename node_type>
+static inline auto postmutate_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.postmutate( node ) ) {
+	return pass.postmutate( node );
+}
+
+template<typename return_type, typename pass_type, typename node_type>
+static inline return_type postmutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) { return node; }
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -44,5 +68,5 @@
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 template< typename pass_type >
-class PassVisitor final : public Visitor {
+class PassVisitor final : public Visitor, public Mutator {
 public:
 	PassVisitor() = default;
@@ -145,4 +169,90 @@
 	virtual void visit( Constant *constant ) override final;
 
+	virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final;
+	virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final;
+	virtual Declaration* mutate( StructDecl *aggregateDecl ) override final;
+	virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final;
+	virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final;
+	virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final;
+	virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final;
+	virtual Declaration* mutate( TypedefDecl *typeDecl ) override final;
+	virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final;
+
+	virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final;
+	virtual Statement* mutate( ExprStmt *exprStmt ) override final;
+	virtual Statement* mutate( AsmStmt *asmStmt ) override final;
+	virtual Statement* mutate( IfStmt *ifStmt ) override final;
+	virtual Statement* mutate( WhileStmt *whileStmt ) override final;
+	virtual Statement* mutate( ForStmt *forStmt ) override final;
+	virtual Statement* mutate( SwitchStmt *switchStmt ) override final;
+	virtual Statement* mutate( CaseStmt *caseStmt ) override final;
+	virtual Statement* mutate( BranchStmt *branchStmt ) override final;
+	virtual Statement* mutate( ReturnStmt *returnStmt ) override final;
+	virtual Statement* mutate( TryStmt *returnStmt ) override final;
+	virtual Statement* mutate( CatchStmt *catchStmt ) override final;
+	virtual Statement* mutate( FinallyStmt *catchStmt ) override final;
+	virtual NullStmt* mutate( NullStmt *nullStmt ) override final;
+	virtual Statement* mutate( DeclStmt *declStmt ) override final;
+	virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final;
+
+	virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final;
+	virtual Expression* mutate( UntypedExpr *untypedExpr ) override final;
+	virtual Expression* mutate( NameExpr *nameExpr ) override final;
+	virtual Expression* mutate( AddressExpr *castExpr ) override final;
+	virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final;
+	virtual Expression* mutate( CastExpr *castExpr ) override final;
+	virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final;
+	virtual Expression* mutate( MemberExpr *memberExpr ) override final;
+	virtual Expression* mutate( VariableExpr *variableExpr ) override final;
+	virtual Expression* mutate( ConstantExpr *constantExpr ) override final;
+	virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final;
+	virtual Expression* mutate( AlignofExpr *alignofExpr ) override final;
+	virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final;
+	virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final;
+	virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final;
+	virtual Expression* mutate( AttrExpr *attrExpr ) override final;
+	virtual Expression* mutate( LogicalExpr *logicalExpr ) override final;
+	virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final;
+	virtual Expression* mutate( CommaExpr *commaExpr ) override final;
+	virtual Expression* mutate( TypeExpr *typeExpr ) override final;
+	virtual Expression* mutate( AsmExpr *asmExpr ) override final;
+	virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final;
+	virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final;
+	virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final;
+	virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final;
+	virtual Expression* mutate( RangeExpr *rangeExpr ) override final;
+	virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final;
+	virtual Expression* mutate( TupleExpr *tupleExpr ) override final;
+	virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final;
+	virtual Expression* mutate( MemberTupleExpr *tupleExpr ) override final;
+	virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final;
+	virtual Expression* mutate( StmtExpr * stmtExpr ) override final;
+	virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final;
+
+	virtual Type* mutate( VoidType *basicType ) override final;
+	virtual Type* mutate( BasicType *basicType ) override final;
+	virtual Type* mutate( PointerType *pointerType ) override final;
+	virtual Type* mutate( ArrayType *arrayType ) override final;
+	virtual Type* mutate( FunctionType *functionType ) override final;
+	virtual Type* mutate( StructInstType *aggregateUseType ) override final;
+	virtual Type* mutate( UnionInstType *aggregateUseType ) override final;
+	virtual Type* mutate( EnumInstType *aggregateUseType ) override final;
+	virtual Type* mutate( TraitInstType *aggregateUseType ) override final;
+	virtual Type* mutate( TypeInstType *aggregateUseType ) override final;
+	virtual Type* mutate( TupleType *tupleType ) override final;
+	virtual Type* mutate( TypeofType *typeofType ) override final;
+	virtual Type* mutate( AttrType *attrType ) override final;
+	virtual Type* mutate( VarArgsType *varArgsType ) override final;
+	virtual Type* mutate( ZeroType *zeroType ) override final;
+	virtual Type* mutate( OneType *oneType ) override final;
+
+	virtual Initializer* mutate( SingleInit *singleInit ) override final;
+	virtual Initializer* mutate( ListInit *listInit ) override final;
+	virtual Initializer* mutate( ConstructorInit *ctorInit ) override final;
+
+	virtual Subrange *mutate( Subrange *subrange ) override final;
+
+	virtual Constant *mutate( Constant *constant ) override final;
+
 private:
 	template<typename node_type> 
@@ -159,4 +269,18 @@
 		postvisit_impl( pass, node, 0 ); 
 	}
+
+	template<typename node_type>
+	auto call_premutate ( node_type * node )
+		-> decltype( premutate_impl( pass, node, 0 ), void() )
+	{
+		premutate_impl( pass, node, 0 );
+	}
+
+	template<typename return_type, typename node_type>
+	auto call_postmutate ( node_type * node )
+		-> decltype( postmutate_impl<return_type>( pass, node, 0 ) )
+	{
+		return postmutate_impl<return_type>( pass, node, 0 );
+	}
 };
 
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 7b15d7a7914323553bc86669ce003542d86e46e0)
+++ src/Common/PassVisitor.impl.h	(revision ab904dc2d88885a200b84e36078cc551c9a2472f)
@@ -6,397 +6,802 @@
 	call_postvisit( node ); \
 
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ObjectDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( FunctionDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( StructDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UnionDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( EnumDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TraitDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TypeDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TypedefDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AsmDecl * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CompoundStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ExprStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AsmStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( IfStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( WhileStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ForStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( SwitchStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CaseStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( BranchStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ReturnStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TryStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CatchStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( FinallyStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( NullStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( DeclStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ImplicitCtorDtorStmt * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ApplicationExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UntypedExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( NameExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CastExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AddressExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( LabelAddressExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UntypedMemberExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( MemberExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( VariableExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ConstantExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( SizeofExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AlignofExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UntypedOffsetofExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( OffsetofExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( OffsetPackExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AttrExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( LogicalExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ConditionalExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CommaExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TypeExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AsmExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ImplicitCopyCtorExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ConstructorExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( CompoundLiteralExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UntypedValofExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( RangeExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UntypedTupleExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TupleExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TupleIndexExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( MemberTupleExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TupleAssignExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( StmtExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UniqueExpr * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( VoidType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( BasicType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( PointerType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ArrayType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( FunctionType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( StructInstType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( UnionInstType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( EnumInstType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TraitInstType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TypeInstType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TupleType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( TypeofType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( AttrType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( VarArgsType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ZeroType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( OneType * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( SingleInit * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ListInit * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( ConstructorInit * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( Subrange * node ) { 
-	VISIT_BODY( node ); 
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type>::visit( Constant * node ) { 
-	VISIT_BODY( node ); 
-}
+#define MUTATE_BODY( type, node )                   \
+	call_premutate( node );                       \
+	Mutator::mutate( node );                      \
+	auto ret = call_postmutate< type * >( node ); \
+	return ret;                                   \
+
+
+
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( StructDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UnionDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( EnumDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TraitDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypeDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AsmDecl * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ExprStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AsmStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( IfStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( WhileStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ForStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CaseStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( BranchStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TryStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CatchStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( NullStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DeclStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( NameExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CastExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AddressExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( MemberExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( VariableExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AttrExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CommaExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypeExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AsmExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( RangeExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TupleExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( MemberTupleExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( StmtExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( VoidType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( BasicType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( PointerType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ArrayType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( FunctionType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( StructInstType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( UnionInstType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( EnumInstType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TraitInstType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypeInstType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TupleType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypeofType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AttrType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( VarArgsType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ZeroType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( OneType * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SingleInit * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ListInit * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( Subrange * node ) {
+	VISIT_BODY( node ); 
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( Constant * node ) {
+	VISIT_BODY( node ); 
+}
+
+//---------------------------------------------------------------------------------------------------------------
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
+	MUTATE_BODY( DeclarationWithType, node );
+}
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
+	MUTATE_BODY( DeclarationWithType, node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
+	MUTATE_BODY( Declaration, node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
+	MUTATE_BODY( Declaration, node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
+	MUTATE_BODY( Declaration, node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
+	MUTATE_BODY( Declaration, node );
+}
+
+template< typename pass_type >
+TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
+	MUTATE_BODY( TypeDecl, node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
+	MUTATE_BODY( Declaration, node );
+}
+
+template< typename pass_type >
+AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
+	MUTATE_BODY( AsmDecl, node );
+}
+
+template< typename pass_type >
+CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
+	MUTATE_BODY( CompoundStmt, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
+	MUTATE_BODY( NullStmt, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
+	MUTATE_BODY( Statement, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
+	MUTATE_BODY( Expression, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( OneType * node ) {
+	MUTATE_BODY( Type, node );
+}
+
+template< typename pass_type >
+Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
+	MUTATE_BODY( Initializer, node );
+}
+
+template< typename pass_type >
+Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
+	MUTATE_BODY( Initializer, node );
+}
+
+template< typename pass_type >
+Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
+	MUTATE_BODY( Initializer, node );
+}
+
+template< typename pass_type >
+Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
+	MUTATE_BODY( Subrange, node );
+}
+
+template< typename pass_type >
+Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
+	MUTATE_BODY( Constant, node );
+}
Index: src/Tuples/TupleExpansion.cc
===================================================================
--- src/Tuples/TupleExpansion.cc	(revision 7b15d7a7914323553bc86669ce003542d86e46e0)
+++ src/Tuples/TupleExpansion.cc	(revision ab904dc2d88885a200b84e36078cc551c9a2472f)
@@ -18,16 +18,17 @@
 #include <cassert>
 #include "Tuples.h"
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
 #include "GenPoly/DeclMutator.h"
+#include "InitTweak/GenInit.h"
+#include "InitTweak/InitTweak.h"
+#include "ResolvExpr/typeops.h"
+#include "SymTab/Mangler.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
-#include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SymTab/Mangler.h"
-#include "Common/ScopedMap.h"
-#include "ResolvExpr/typeops.h"
-#include "InitTweak/GenInit.h"
-#include "InitTweak/InitTweak.h"
 
 namespace Tuples {
@@ -82,10 +83,7 @@
 		};
 
-		class TupleIndexExpander final : public Mutator {
-		public:
-			typedef Mutator Parent;
-			using Parent::mutate;
-
-			virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override;
+		class TupleIndexExpander {
+		public:
+			Expression * postmutate( TupleIndexExpr * tupleExpr );
 		};
 
@@ -116,5 +114,5 @@
 		replacer.mutateDeclarationList( translationUnit );
 
-		TupleIndexExpander idxExpander;
+		PassVisitor<TupleIndexExpander> idxExpander;
 		mutateAll( translationUnit, idxExpander );
 
@@ -250,6 +248,6 @@
 	}
 
-	Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) {
-		Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this );
+	Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
+		Expression * tuple = tupleExpr->get_tuple();
 		assert( tuple );
 		tupleExpr->set_tuple( nullptr );