Index: src/ControlStruct/ExceptTranslate.h
===================================================================
--- src/ControlStruct/ExceptTranslate.h	(revision 451d9580a1907a9ec491628a954f8a1767f660dd)
+++ src/ControlStruct/ExceptTranslate.h	(revision 5f3ba117d89cd71b0b82121f2363d27a6752b378)
@@ -31,4 +31,5 @@
 
 	void translateTries( std::list< Declaration *> & translationUnit );
+	void translateTries( ast::TranslationUnit & transUnit );
 	/* Replaces all try blocks (and their many clauses) with function definitions and calls.
 	 * This uses the exception built-ins to produce typed output and should take place after
Index: src/ControlStruct/ExceptTranslateNew.cpp
===================================================================
--- src/ControlStruct/ExceptTranslateNew.cpp	(revision 451d9580a1907a9ec491628a954f8a1767f660dd)
+++ src/ControlStruct/ExceptTranslateNew.cpp	(revision 5f3ba117d89cd71b0b82121f2363d27a6752b378)
@@ -20,8 +20,28 @@
 #include "AST/Stmt.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "AST/DeclReplacer.hpp"
 
 namespace ControlStruct {
 
 namespace {
+
+	typedef std::list<ast::CatchStmt*> CatchList;
+
+	void split( CatchList& allHandlers, CatchList& terHandlers,
+				CatchList& resHandlers ) {
+		while ( !allHandlers.empty() ) {
+			ast::CatchStmt * stmt = allHandlers.front();
+			allHandlers.pop_front();
+			if (stmt->kind == ast::ExceptionKind::Terminate) {
+				terHandlers.push_back(stmt);
+			} else {
+				resHandlers.push_back(stmt);
+			}
+		}
+	}
+
+	void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
+		block->push_back(new ast::DeclStmt(block->location, item));
+	}
 
 class TranslateThrowsCore : public ast::WithGuards {
@@ -128,8 +148,609 @@
 }
 
+
+class TryMutatorCore {
+	// The built in types used in translation.
+	const ast::StructDecl * except_decl;
+	const ast::StructDecl * node_decl;
+	const ast::StructDecl * hook_decl;
+
+	// The many helper functions for code/syntree generation.
+	ast::CompoundStmt * take_try_block( ast::TryStmt * tryStmt );
+	ast::FunctionDecl * create_try_wrapper( const ast::CompoundStmt * body );
+	ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
+	ast::CompoundStmt * create_single_matcher(
+		const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler );
+	ast::FunctionDecl * create_terminate_match( CatchList &handlers );
+	ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
+		ast::FunctionDecl * terminate_catch, ast::FunctionDecl * terminate_match );
+	ast::FunctionDecl * create_resume_handler( CatchList &handlers );
+	ast::CompoundStmt * create_resume_wrapper(
+		const ast::Stmt * wraps, const ast::FunctionDecl * resume_handler );
+	ast::FunctionDecl * create_finally_wrapper( ast::TryStmt * tryStmt );
+	ast::ObjectDecl * create_finally_hook( ast::FunctionDecl * finally_wrapper );
+	ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );
+
+	// Types used in translation, make sure to use clone.
+	// void (*function)();
+	ast::FunctionDecl * try_func_t;
+	// void (*function)(int, exception);
+	ast::FunctionDecl * catch_func_t;
+	// int (*function)(exception);
+	ast::FunctionDecl * match_func_t;
+	// bool (*function)(exception);
+	ast::FunctionDecl * handle_func_t;
+	// void (*function)(__attribute__((unused)) void *);
+	ast::FunctionDecl * finally_func_t;
+
+	ast::StructInstType * create_except_type() {
+		assert( except_decl );
+		return new ast::StructInstType( except_decl );
+	}
+	void init_func_types();
+
+public:
+	TryMutatorCore() :
+		except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr )
+	{}
+
+	void previsit( const ast::StructDecl *structDecl );
+	ast::Stmt * postvisit( const ast::TryStmt *tryStmt );
+	ast::Stmt * postvisit( const ast::ThrowStmt *throwStmt );
+};
+
+void TryMutatorCore::init_func_types() {
+	assert( except_decl );
+
+	ast::ObjectDecl index_obj(
+		{},
+		"__handler_index",
+		new ast::BasicType(ast::BasicType::SignedInt)
+		);
+	ast::ObjectDecl exception_obj(
+		{},
+		"__exception_inst",
+		new ast::PointerType(
+			new ast::StructInstType( except_decl )
+			),
+		NULL
+		);
+	ast::ObjectDecl bool_obj(
+		{},
+		"__ret_bool",
+		new ast::BasicType( ast::BasicType::Bool ),
+		nullptr, //init
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall,
+		nullptr, //width
+		std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+		);
+	ast::ObjectDecl voidptr_obj(
+		{},
+		"__hook",
+		new ast::PointerType(
+			new ast::VoidType()
+		),
+		nullptr, //init
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall,
+		nullptr, //width
+		std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+		);
+
+	ast::ObjectDecl unused_index_obj(
+		{},
+		"__handler_index",
+		new ast::BasicType(ast::BasicType::SignedInt),
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall,
+		nullptr, //width
+		std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+	);
+	//unused_index_obj->attributes.push_back( new Attribute( "unused" ) );
+
+	try_func_t = new ast::FunctionDecl(
+		{},
+		"try",
+		{}, //forall
+		{}, //no param
+		{}, //no return
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall
+	);
+
+	catch_func_t = new ast::FunctionDecl(
+		{},
+		"catch",
+		{}, //forall
+		{ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
+		{}, //return void
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall
+	);
+
+	match_func_t = new ast::FunctionDecl(
+		{},
+		"match",
+		{}, //forall
+		{ast::deepCopy(&exception_obj)},
+		{ast::deepCopy(&unused_index_obj)},
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall
+	);
+
+	handle_func_t = new ast::FunctionDecl(
+		{},
+		"handle",
+		{}, //forall
+		{ast::deepCopy(&exception_obj)},
+		{ast::deepCopy(&bool_obj)},
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall
+	);
+
+	finally_func_t = new ast::FunctionDecl(
+		{},
+		"finally",
+		{}, //forall
+		{ast::deepCopy(&voidptr_obj)},
+		{}, //return void
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall
+	);
+
+	//catch_func_t.get_parameters().push_back( index_obj.clone() );
+	//catch_func_t.get_parameters().push_back( exception_obj.clone() );
+	//match_func_t.get_returnVals().push_back( unused_index_obj );
+	//match_func_t.get_parameters().push_back( exception_obj.clone() );
+	//handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+	//handle_func_t.get_parameters().push_back( exception_obj.clone() );
+	//finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
+}
+
+// TryStmt Mutation Helpers
+
+/*
+ast::CompoundStmt * TryMutatorCore::take_try_block( ast::TryStmt *tryStmt ) {
+	ast::CompoundStmt * block = tryStmt->body;
+	tryStmt->body = nullptr;
+	return block;
+}
+*/
+
+ast::FunctionDecl * TryMutatorCore::create_try_wrapper(
+		const ast::CompoundStmt *body ) {
+
+	ast::FunctionDecl * ret = ast::deepCopy(try_func_t);
+	ret->stmts = body;
+	return ret;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
+		CatchList &handlers ) {
+	std::vector<ast::ptr<ast::Stmt>> handler_wrappers;
+
+	assert (!handlers.empty());
+	const CodeLocation loc = handlers.front()->location;
+
+	ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
+	const ast::DeclWithType * index_obj = func_t->params.front();
+	const ast::DeclWithType * except_obj = func_t->params.back();
+
+	// Index 1..{number of handlers}
+	int index = 0;
+	CatchList::iterator it = handlers.begin();
+	for ( ; it != handlers.end() ; ++it ) {
+		++index;
+		ast::CatchStmt * handler = *it;
+		const CodeLocation loc = handler->location;
+
+		// case `index`:
+		// {
+		//     `handler.decl` = { (virtual `decl.type`)`except` };
+		//     `handler.body`;
+		// }
+		// return;
+		ast::CompoundStmt * block = new ast::CompoundStmt(loc);
+
+		// Just copy the exception value. (Post Validation)
+		const ast::ObjectDecl * handler_decl =
+			handler->decl.strict_as<ast::ObjectDecl>();
+		ast::ObjectDecl * local_except = ast::deepCopy(handler_decl);
+		ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
+			new ast::VariableExpr( loc, except_obj ),
+			local_except->get_type()
+			);
+		vcex->location = handler->location;
+		local_except->init = new ast::ListInit(loc, { new ast::SingleInit( loc, vcex ) });
+		block->push_back( new ast::DeclStmt( loc, local_except ) );
+
+		// Add the cleanup attribute.
+		local_except->attributes.push_back( new ast::Attribute(
+			"cleanup",
+			{ new ast::NameExpr( loc, "__cfaehm_cleanup_terminate" ) }
+			) );
+
+		ast::DeclReplacer::DeclMap mapping;
+		mapping[handler_decl] = local_except;
+		const ast::Stmt * mutBody = strict_dynamic_cast<const ast::Stmt *>(
+			ast::DeclReplacer::replace(handler->body, mapping));
+
+
+		block->push_back( mutBody );
+		// handler->body = nullptr;
+
+		handler_wrappers.push_back( new ast::CaseStmt(loc, 
+			ast::ConstantExpr::from_int(loc, index) ,
+			{ block, new ast::ReturnStmt( loc, nullptr ) }
+			));
+	}
+	// TODO: Some sort of meaningful error on default perhaps?
+
+	/*
+	std::list<Statement*> stmt_handlers;
+	while ( !handler_wrappers.empty() ) {
+		stmt_handlers.push_back( handler_wrappers.front() );
+		handler_wrappers.pop_front();
+	}
+	*/
+
+	ast::SwitchStmt * handler_lookup = new ast::SwitchStmt(loc, 
+		new ast::VariableExpr( loc, index_obj ),
+		std::move(handler_wrappers)
+		);
+	ast::CompoundStmt * body = new ast::CompoundStmt(loc, 
+		{handler_lookup});
+
+	func_t->stmts = body;
+	return func_t;
+}
+
+// Create a single check from a moddified handler.
+// except_obj is referenced, modded_handler will be freed.
+ast::CompoundStmt * TryMutatorCore::create_single_matcher(
+		const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
+	// {
+	//     `modded_handler.decl`
+	//     if ( `decl.name = (virtual `decl.type`)`except`
+	//             [&& `modded_handler.cond`] ) {
+	//         `modded_handler.body`
+	//     }
+	// }
+
+	const CodeLocation loc = modded_handler->location;
+	ast::CompoundStmt * block = new ast::CompoundStmt(loc);
+
+	// Local Declaration
+	const ast::ObjectDecl * local_except =
+		modded_handler->decl.strict_as<ast::ObjectDecl>();
+	block->push_back( new ast::DeclStmt( loc,  local_except ) );
+
+	// Check for type match.
+	ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc, 
+		new ast::VariableExpr(loc, except_obj ),
+		local_except->get_type()
+		);
+	ast::Expr * cond = ast::UntypedExpr::createAssign(loc,
+		new ast::VariableExpr(loc, local_except ), vcex );
+
+	// Add the check on the conditional if it is provided.
+	if ( modded_handler->cond ) {
+		cond = new ast::LogicalExpr( loc, cond, modded_handler->cond, ast::LogicalFlag::AndExpr );
+	}
+	// Construct the match condition.
+	block->push_back( new ast::IfStmt(loc, 
+		cond, modded_handler->body, nullptr ) );
+
+	// xxx - how does this work in new ast
+	//modded_handler->set_decl( nullptr );
+	//modded_handler->set_cond( nullptr );
+	//modded_handler->set_body( nullptr );
+	//delete modded_handler;
+	return block;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_terminate_match(
+		CatchList &handlers ) {
+	// int match(exception * except) {
+	//     HANDLER WRAPPERS { return `index`; }
+	// }
+
+	assert (!handlers.empty());
+	const CodeLocation loc = handlers.front()->location;
+
+	ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+	ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
+	const ast::DeclWithType * except_obj = func_t->params.back();
+
+	// Index 1..{number of handlers}
+	int index = 0;
+	CatchList::iterator it;
+	for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
+		++index;
+		ast::CatchStmt * handler = *it;
+
+		// Body should have been taken by create_terminate_catch.
+		// xxx - just ignore it?
+		// assert( nullptr == handler->get_body() );
+
+		// Create new body.
+		handler->body = new ast::ReturnStmt( handler->location,
+			ast::ConstantExpr::from_int( handler->location, index ) );
+
+		// Create the handler.
+		body->push_back( create_single_matcher( except_obj, handler ) );
+		*it = nullptr;
+	}
+
+	body->push_back( new ast::ReturnStmt(loc, 
+		ast::ConstantExpr::from_int( loc, 0 ) ));
+
+	func_t->stmts = body;
+
+	return func_t;
+}
+
+ast::CompoundStmt * TryMutatorCore::create_terminate_caller(
+		CodeLocation loc,
+		ast::FunctionDecl * try_wrapper,
+		ast::FunctionDecl * terminate_catch,
+		ast::FunctionDecl * terminate_match ) {
+	// { __cfaehm_try_terminate(`try`, `catch`, `match`); }
+
+	ast::UntypedExpr * caller = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
+		"__cfaehm_try_terminate" ) );
+	caller->args.push_back( new ast::VariableExpr(loc, try_wrapper ) );
+	caller->args.push_back( new ast::VariableExpr(loc, terminate_catch ) );
+	caller->args.push_back( new ast::VariableExpr(loc, terminate_match ) );
+
+	ast::CompoundStmt * callStmt = new ast::CompoundStmt(loc);
+	callStmt->push_back( new ast::ExprStmt( loc, caller ) );
+	return callStmt;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_resume_handler(
+		CatchList &handlers ) {
+	// bool handle(exception * except) {
+	//     HANDLER WRAPPERS { `hander->body`; return true; }
+	// }
+	assert (!handlers.empty());
+	const CodeLocation loc = handlers.front()->location;
+	ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+	ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
+	const ast::DeclWithType * except_obj = func_t->params.back();
+
+	CatchList::iterator it;
+	for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
+		ast::CatchStmt * handler = *it;
+		const CodeLocation loc = handler->location;
+		// Modifiy body.
+		ast::CompoundStmt * handling_code;
+		if (handler->body.as<ast::CompoundStmt>()) {
+			handling_code = 
+			strict_dynamic_cast<ast::CompoundStmt*>( handler->body.get_and_mutate() );
+		} else {
+			handling_code = new ast::CompoundStmt(loc);
+			handling_code->push_back( handler->body );
+		}
+		handling_code->push_back( new ast::ReturnStmt(loc,
+			ast::ConstantExpr::from_bool(loc, true ) ) );
+		handler->body = handling_code;
+
+		// Create the handler.
+		body->push_back( create_single_matcher( except_obj, handler ) );
+		*it = nullptr;
+	}
+
+	body->push_back( new ast::ReturnStmt(loc,
+		ast::ConstantExpr::from_bool(loc, false ) ) );
+	func_t->stmts = body;
+
+	return func_t;
+}
+
+ast::CompoundStmt * TryMutatorCore::create_resume_wrapper(
+		const ast::Stmt * wraps,
+		const ast::FunctionDecl * resume_handler ) {
+	const CodeLocation loc = wraps->location;
+	ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+	// struct __try_resume_node __resume_node
+	//  	__attribute__((cleanup( __cfaehm_try_resume_cleanup )));
+	// ** unwinding of the stack here could cause problems **
+	// ** however I don't think that can happen currently **
+	// __cfaehm_try_resume_setup( &__resume_node, resume_handler );
+
+	ast::ObjectDecl * obj = new ast::ObjectDecl(
+		loc,
+		"__resume_node",
+		new ast::StructInstType(
+			node_decl
+			),
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall,
+		nullptr,
+		{new ast::Attribute("cleanup", {new ast::NameExpr(loc, "__cfaehm_try_resume_cleanup")})}
+		);
+	appendDeclStmt( body, obj );
+
+	ast::UntypedExpr *setup = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
+		"__cfaehm_try_resume_setup" ) );
+	setup->args.push_back( new ast::AddressExpr( loc, new ast::VariableExpr(loc, obj ) ) );
+	setup->args.push_back( new ast::VariableExpr( loc, resume_handler ) );
+
+	body->push_back( new ast::ExprStmt(loc, setup ) );
+
+	body->push_back( wraps );
+	return body;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_finally_wrapper(
+		ast::TryStmt * tryStmt ) {
+	// void finally() { `finally->block` }
+	const ast::FinallyStmt * finally = tryStmt->finally;
+	const ast::CompoundStmt * body = finally->body;
+
+	ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
+	func_t->stmts = body;
+
+	// finally->set_block( nullptr );
+	// delete finally;
+	tryStmt->finally = nullptr;
+
+
+	return func_t;
+}
+
+ast::ObjectDecl * TryMutatorCore::create_finally_hook(
+		ast::FunctionDecl * finally_wrapper ) {
+	// struct __cfaehm_cleanup_hook __finally_hook
+	//   	__attribute__((cleanup( `finally_wrapper` )));
+
+	const CodeLocation loc = finally_wrapper->location;
+	// Make Cleanup Attribute.
+	/*
+	std::list< ast::Attribute * > attributes;
+	{
+		std::list<  > attr_params;
+		attr_params.push_back( nameOf( finally_wrapper ) );
+		attributes.push_back( new Attribute( "cleanup", attr_params ) );
+	}
+	*/
+
+	return new ast::ObjectDecl(
+		loc,
+		"__finally_hook",
+		new ast::StructInstType(
+			hook_decl
+			),
+		nullptr,
+		ast::Storage::Classes{},
+		ast::Linkage::Cforall,
+		nullptr,
+		{new ast::Attribute("cleanup", {new ast::VariableExpr{loc, finally_wrapper}})}
+		);
+}
+
+ast::Stmt * TryMutatorCore::create_resume_rethrow( const ast::ThrowStmt *throwStmt ) {
+	// return false;
+	const CodeLocation loc = throwStmt->location;
+	ast::Stmt * result = new ast::ReturnStmt(loc, 
+		ast::ConstantExpr::from_bool( loc, false )
+		);
+	result->labels = throwStmt->labels;
+	// delete throwStmt; done by postvisit
+	return result;
+}
+
+// Visiting/Mutating Functions
+void TryMutatorCore::previsit( const ast::StructDecl *structDecl ) {
+	if ( !structDecl->body ) {
+		// Skip children?
+		return;
+	} else if ( structDecl->name == "__cfaehm_base_exception_t" ) {
+		assert( nullptr == except_decl );
+		except_decl = structDecl;
+		init_func_types();
+	} else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
+		assert( nullptr == node_decl );
+		node_decl = structDecl;
+	} else if ( structDecl->name == "__cfaehm_cleanup_hook" ) {
+		assert( nullptr == hook_decl );
+		hook_decl = structDecl;
+	}
+}
+
+ast::Stmt * TryMutatorCore::postvisit( const ast::TryStmt *tryStmt ) {
+	assert( except_decl );
+	assert( node_decl );
+	assert( hook_decl );
+
+	const CodeLocation loc = tryStmt->location;
+	ast::TryStmt * mutStmt = mutate(tryStmt);
+	// Generate a prefix for the function names?
+
+	ast::CompoundStmt * block = new ast::CompoundStmt( loc );
+	// ast::CompoundStmt * inner = take_try_block( mutStmt );
+	// this is never mutated so let node deletion do its job?
+	const ast::CompoundStmt * inner = mutStmt->body;
+
+	if ( mutStmt->finally ) {
+		// Define the helper function.
+		ast::FunctionDecl * finally_block =
+			create_finally_wrapper( mutStmt );
+		appendDeclStmt( block, finally_block );
+		// Create and add the finally cleanup hook.
+		appendDeclStmt( block, create_finally_hook( finally_block ) );
+	}
+
+	CatchList termination_handlers;
+	CatchList resumption_handlers;
+
+	for (auto & handler: mutStmt->handlers) {
+		// xxx - should always be unique? mutate as safe const-cast
+		assert(handler->unique());
+		if (handler->kind == ast::ExceptionKind::Resume) {
+			resumption_handlers.push_back(handler.get_and_mutate());
+		}
+		else {
+			termination_handlers.push_back(handler.get_and_mutate());
+		}
+	}
+	// split( mutStmt->handlers,
+	//		termination_handlers, resumption_handlers );
+
+	if ( resumption_handlers.size() ) {
+		// Define the helper function.
+		ast::FunctionDecl * resume_handler =
+			create_resume_handler( resumption_handlers );
+		appendDeclStmt( block, resume_handler );
+		// Prepare hooks
+		inner = create_resume_wrapper( inner, resume_handler );
+	}
+
+	if ( termination_handlers.size() ) {
+		// Define the three helper functions.
+		ast::FunctionDecl * try_wrapper = create_try_wrapper( inner );
+		appendDeclStmt( block, try_wrapper );
+		ast::FunctionDecl * terminate_catch =
+			create_terminate_catch( termination_handlers );
+		appendDeclStmt( block, terminate_catch );
+		ast::FunctionDecl * terminate_match =
+			create_terminate_match( termination_handlers );
+		appendDeclStmt( block, terminate_match );
+		// Build the call to the try wrapper.
+		inner = create_terminate_caller(inner->location,
+			try_wrapper, terminate_catch, terminate_match );
+	}
+
+	// Embed the try block.
+	block->push_back( inner );
+
+	return block;
+}
+
+ast::Stmt * TryMutatorCore::postvisit( const ast::ThrowStmt *throwStmt ) {
+	// Only valid `throwResume;` statements should remain. (2/3 checks)
+	assert( ast::ExceptionKind::Resume == throwStmt->kind && ! throwStmt->expr );
+	return create_resume_rethrow( throwStmt );
+}
+
 } // namespace
 
 void translateThrows( ast::TranslationUnit & transUnit ) {
 	ast::Pass<TranslateThrowsCore>::run( transUnit );
+}
+
+void translateTries( ast::TranslationUnit & transUnit ) {
+	ast::Pass<TryMutatorCore>::run(transUnit);
 }
 
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 451d9580a1907a9ec491628a954f8a1767f660dd)
+++ src/main.cc	(revision 5f3ba117d89cd71b0b82121f2363d27a6752b378)
@@ -404,4 +404,7 @@
 			// Currently not working due to unresolved issues with UniqueExpr
 			PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+
+			PASS( "Translate Tries" , ControlStruct::translateTries( transUnit ) );
+
 			translationUnit = convert( move( transUnit ) );
 		} else {
@@ -469,7 +472,9 @@
 
 			PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+
+			PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 		}
 
-		PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
+		
 
 		PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );