Index: src/ResolvExpr/AdjustExprType.cc
===================================================================
--- src/ResolvExpr/AdjustExprType.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/AdjustExprType.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -66,8 +66,5 @@
 
 	Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
-		PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
-		arrayType->base = nullptr;
-		delete arrayType;
-		return pointerType;
+		return new PointerType{ arrayType->get_qualifiers(), arrayType->base };
 	}
 
Index: src/ResolvExpr/Alternative.cc
===================================================================
--- src/ResolvExpr/Alternative.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/Alternative.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -20,8 +20,11 @@
 #include <utility>                       // for move
 
+#include "Common/GC.h"
+#include "Common/PassVisitor.h"
 #include "Common/utility.h"              // for maybeClone
 #include "ResolvExpr/Cost.h"             // for Cost, Cost::zero, operator<<
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "SynTree/Expression.h"          // for Expression
+#include "SynTree/GcTracer.h"
 #include "SynTree/Type.h"                // for Type
 
@@ -34,35 +37,15 @@
 	Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost )
 		: cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
-
-	Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
-	}
-
-	Alternative &Alternative::operator=( const Alternative &other ) {
-		if ( &other == this ) return *this;
-		delete expr;
-		cost = other.cost;
-		cvtCost = other.cvtCost;
-		expr = maybeClone( other.expr );
-		env = other.env;
+	
+	Alternative::Alternative( const Alternative& o )
+		: cost( o.cost ), cvtCost( o.cvtCost ), expr( maybeClone( o.expr ) ), env( o.env ) {}
+	
+	Alternative & Alternative::operator= ( const Alternative& o ) {
+		if ( &o == this ) return *this;
+		cost = o.cost;
+		cvtCost = o.cvtCost;
+		expr = maybeClone( o.expr );
+		env = o.env;
 		return *this;
-	}
-
-	Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( std::move( other.env ) ) {
-		other.expr = nullptr;
-	}
-
-	Alternative & Alternative::operator=( Alternative && other ) {
-		if ( &other == this )  return *this;
-		delete expr;
-		cost = other.cost;
-		cvtCost = other.cvtCost;
-		expr = other.expr;
-		env = std::move( other.env );
-		other.expr = nullptr;
-		return *this;
-	}
-
-	Alternative::~Alternative() {
-		delete expr;
 	}
 
@@ -96,4 +79,11 @@
 	}
 
+	const GC& operator<< ( const GC& gc, const Alternative& alt ) {
+		PassVisitor<GcTracer> tracer{ gc };
+		maybeAccept( alt.expr, tracer );
+		tracer << alt.env;
+		return gc;
+	}
+
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/Alternative.h
===================================================================
--- src/ResolvExpr/Alternative.h	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/Alternative.h	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -24,4 +24,6 @@
 class Expression;
 
+class GC;
+
 namespace ResolvExpr {
 	struct Alternative {
@@ -30,21 +32,13 @@
 		Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost, const Cost &cvtCost );
 		Alternative( const Alternative &other );
-		Alternative &operator=( const Alternative &other );
-		Alternative( Alternative && other );
-		Alternative &operator=( Alternative && other );
-		~Alternative();
+		Alternative & operator= ( const Alternative &other );
+		Alternative( Alternative&& other ) = default;
+		Alternative & operator= ( Alternative&& other ) = default;
 
 		void print( std::ostream &os, Indenter indent = {} ) const;
 
-		/// Returns the stored expression, but released from management of this Alternative
-		Expression* release_expr() {
-			Expression* tmp = expr;
-			expr = nullptr;
-			return tmp;
-		}
-
 		Cost cost;
 		Cost cvtCost;
-		Expression *expr;
+		Expression * expr;
 		TypeEnvironment env;
 	};
@@ -62,4 +56,6 @@
 		return os;
 	}
+
+	const GC& operator<< ( const GC&, const Alternative& );
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -21,5 +21,5 @@
 #include <list>                    // for _List_iterator, list, _List_const_...
 #include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
-#include <memory>                  // for allocator_traits<>::value_type, unique_ptr
+#include <memory>                  // for allocator_traits<>::value_type
 #include <utility>                 // for pair
 #include <vector>                  // for vector
@@ -35,4 +35,5 @@
 #include "ResolveTypeof.h"         // for resolveTypeof
 #include "Resolver.h"              // for resolveStmtExpr
+#include "Common/GC.h"             // for new_static_root
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SymTab/Mangler.h"        // for Mangler
@@ -166,5 +167,4 @@
 					candidate->env.apply( newType );
 					mangleName = SymTab::Mangler::mangle( newType );
-					delete newType;
 				}
 				std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
@@ -308,16 +308,16 @@
 		// adds anonymous member interpretations whenever an aggregate value type is seen.
 		// it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
-		std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
+		Expression* aggrExpr = alt.expr->clone();
 		alt.env.apply( aggrExpr->result );
 		Type * aggrType = aggrExpr->result;
 		if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
 			aggrType = aggrType->stripReferences();
-			aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+			aggrExpr = new CastExpr{ aggrExpr, aggrType->clone() };
 		}
 
 		if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) {
-			addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
+			addAggMembers( structInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
 		} else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
-			addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
+			addAggMembers( unionInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
 		} // if
 	}
@@ -354,5 +354,5 @@
 
 	void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) {
-		alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( applicationExpr, env, Cost::zero ) );
 	}
 
@@ -560,5 +560,4 @@
 
 				Expression *varExpr = data.combine( newerAlt.cvtCost );
-				delete varExpr->get_result();
 				varExpr->set_result( adjType->clone() );
 				PRINT(
@@ -574,9 +573,7 @@
 					inferParameters = (*inferParameters)[ id ].inferParams.get();
 				}
-				// XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-				(*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+				
+				(*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType, curDecl->get_type(), varExpr );
 				inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
-			} else {
-				delete adjType;
 			}
 		}
@@ -627,5 +624,5 @@
 	struct ArgPack {
 		std::size_t parent;                ///< Index of parent pack
-		std::unique_ptr<Expression> expr;  ///< The argument stored here
+		Expression* expr;                  ///< The argument stored here
 		Cost cost;                         ///< The cost of this argument
 		TypeEnvironment env;               ///< Environment for this pack
@@ -639,10 +636,10 @@
 
 		ArgPack()
-			: parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
-			  tupleStart(0), nextExpl(0), explAlt(0) {}
+			: parent(0), expr(nullptr), cost(Cost::zero), env(), need(), have(), openVars(), 
+			  nextArg(0), tupleStart(0), nextExpl(0), explAlt(0) {}
 
 		ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
 				const OpenVarSet& openVars)
-			: parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have),
+			: parent(0), expr(nullptr), cost(Cost::zero), env(env), need(need), have(have),
 			  openVars(openVars), nextArg(0), tupleStart(0), nextExpl(0), explAlt(0) {}
 
@@ -651,5 +648,5 @@
 				unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0,
 				unsigned explAlt = 0 )
-			: parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
+			: parent(parent), expr(expr), cost(cost), env(move(env)), need(move(need)),
 			  have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
 			  nextExpl(nextExpl), explAlt(explAlt) {}
@@ -657,7 +654,7 @@
 		ArgPack(const ArgPack& o, TypeEnvironment&& env, AssertionSet&& need, AssertionSet&& have,
 				OpenVarSet&& openVars, unsigned nextArg, Cost added )
-			: parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added),
-			  env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)),
-			  nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
+			: parent(o.parent), expr(o.expr), cost(o.cost + added), env(move(env)), 
+			  need(move(need)), have(move(have)), openVars(move(openVars)), nextArg(nextArg), 
+			  tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
 
 		/// true iff this pack is in the middle of an exploded argument
@@ -674,12 +671,12 @@
 			std::list<Expression*> exprs;
 			const ArgPack* pack = this;
-			if ( expr ) { exprs.push_front( expr.release() ); }
+			if ( expr ) { exprs.push_front( expr ); }
 			while ( pack->tupleStart == 0 ) {
 				pack = &packs[pack->parent];
-				exprs.push_front( pack->expr->clone() );
+				exprs.push_front( pack->expr );
 				cost += pack->cost;
 			}
 			// reset pack to appropriate tuple
-			expr.reset( new TupleExpr( exprs ) );
+			expr = new TupleExpr{ exprs };
 			tupleStart = pack->tupleStart - 1;
 			parent = pack->parent;
@@ -734,5 +731,5 @@
 
 						results.emplace_back(
-							i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+							i, expl.exprs[results[i].nextExpl], copy(results[i].env),
 							copy(results[i].need), copy(results[i].have),
 							copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
@@ -755,5 +752,5 @@
 							newResult.parent = i;
 							std::list<Expression*> emptyList;
-							newResult.expr.reset( new TupleExpr( emptyList ) );
+							newResult.expr = new TupleExpr{ emptyList };
 							argType = newResult.expr->get_result();
 						} else {
@@ -762,5 +759,5 @@
 							newResult.cost = results[i].cost;
 							newResult.tupleStart = results[i].tupleStart;
-							newResult.expr.reset( results[i].expr->clone() );
+							newResult.expr = results[i].expr;
 							argType = newResult.expr->get_result();
 
@@ -812,5 +809,5 @@
 						// add new result
 						results.emplace_back(
-							i, expl.exprs.front().get(), move(env), copy(results[i].need),
+							i, expl.exprs.front(), move(env), copy(results[i].need),
 							copy(results[i].have), move(openVars), nextArg + 1,
 							nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
@@ -838,5 +835,5 @@
 			if ( results[i].hasExpl() ) {
 				const ExplodedActual& expl = results[i].getExpl( args );
-				Expression* expr = expl.exprs[results[i].nextExpl].get();
+				Expression* expr = expl.exprs[results[i].nextExpl];
 
 				TypeEnvironment env = results[i].env;
@@ -909,5 +906,5 @@
 
 				// consider only first exploded actual
-				Expression* expr = expl.exprs.front().get();
+				Expression* expr = expl.exprs.front();
 				Type* actualType = expr->result->clone();
 
@@ -937,7 +934,7 @@
 
 	template<typename OutputIterator>
-	void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
-			const std::vector<ArgPack>& results, OutputIterator out ) {
-		ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
+	void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, 
+			ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out ) {
+		ApplicationExpr *appExpr = new ApplicationExpr( func.expr );
 		// sum cost and accumulate actuals
 		std::list<Expression*>& args = appExpr->args;
@@ -945,5 +942,5 @@
 		const ArgPack* pack = &result;
 		while ( pack->expr ) {
-			args.push_front( pack->expr->clone() );
+			args.push_front( pack->expr );
 			cost += pack->cost;
 			pack = &results[pack->parent];
@@ -1012,5 +1009,5 @@
 
 						results.emplace_back(
-							i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+							i, expl.exprs[results[i].nextExpl], copy(results[i].env),
 							copy(results[i].need), copy(results[i].have),
 							copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
@@ -1048,5 +1045,5 @@
 						// add new result
 						results.emplace_back(
-							i, expl.exprs.front().get(), move(env), copy(results[i].need),
+							i, expl.exprs.front(), move(env), copy(results[i].need),
 							copy(results[i].have), move(openVars), nextArg + 1, 0,
 							expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
@@ -1083,5 +1080,5 @@
 
 		// find function operators
-		static NameExpr *opExpr = new NameExpr( "?()" );
+		static auto *opExpr = new_static_root<NameExpr>( "?()" );
 		AlternativeFinder funcOpFinder( indexer, env );
 		// it's ok if there aren't any defined function ops
@@ -1115,6 +1112,6 @@
 				)
 				// check if the type is pointer to function
-				if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->result->stripReferences() ) ) {
-					if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->base ) ) {
+				if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) {
+					if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
 						Alternative newFunc( *func );
 						referenceToRvalueConversion( newFunc.expr, newFunc.cost );
@@ -1152,7 +1149,7 @@
 					// check if type is a pointer to function
 					if ( PointerType* pointer = dynamic_cast<PointerType*>(
-							funcOp->expr->result->stripReferences() ) ) {
+							funcOp->expr->get_result()->stripReferences() ) ) {
 						if ( FunctionType* function =
-								dynamic_cast<FunctionType*>( pointer->base ) ) {
+								dynamic_cast<FunctionType*>( pointer->get_base() ) ) {
 							Alternative newFunc( *funcOp );
 							referenceToRvalueConversion( newFunc.expr, newFunc.cost );
@@ -1176,11 +1173,11 @@
 			PRINT(
 				ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc.expr );
-				PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->function->result );
-				FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->base );
-				std::cerr << "Case +++++++++++++ " << appExpr->function << std::endl;
+				PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+				FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
+				std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
 				std::cerr << "formals are:" << std::endl;
-				printAll( function->parameters, std::cerr, 8 );
+				printAll( function->get_parameters(), std::cerr, 8 );
 				std::cerr << "actuals are:" << std::endl;
-				printAll( appExpr->args, std::cerr, 8 );
+				printAll( appExpr->get_args(), std::cerr, 8 );
 				std::cerr << "bindings are:" << std::endl;
 				withFunc.env.print( std::cerr, 8 );
@@ -1223,5 +1220,5 @@
 	bool isLvalue( Expression *expr ) {
 		// xxx - recurse into tuples?
-		return expr->result && ( expr->result->get_lvalue() || dynamic_cast< ReferenceType * >( expr->result ) );
+		return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
 	}
 
@@ -1232,5 +1229,5 @@
 			if ( isLvalue( alt.expr ) ) {
 				alternatives.push_back(
-					Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
+					Alternative{ new AddressExpr( alt.expr ), alt.env, alt.cost } );
 			} // if
 		} // for
@@ -1238,5 +1235,5 @@
 
 	void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
-		alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
+		alternatives.push_back( Alternative{ expr, env, Cost::zero } );
 	}
 
@@ -1258,5 +1255,4 @@
 				componentExprs.push_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) );
 			}
-			delete argExpr;
 			assert( componentExprs.size() > 0 );
 			// produce the tuple of casts
@@ -1334,5 +1330,5 @@
 		for ( Alternative & alt : finder.alternatives ) {
 			alternatives.push_back( Alternative(
-				new VirtualCastExpr( alt.expr->clone(), castExpr->get_result()->clone() ),
+				new VirtualCastExpr( alt.expr, castExpr->get_result()->clone() ),
 				alt.env, alt.cost ) );
 		}
@@ -1356,5 +1352,4 @@
 			Expression * aggrExpr = agg->expr->clone();
 			referenceToRvalueConversion( aggrExpr, cost );
-			std::unique_ptr<Expression> guard( aggrExpr );
 
 			// find member of the given type
@@ -1370,5 +1365,5 @@
 
 	void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
-		alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( memberExpr, env, Cost::zero ) );
 	}
 
@@ -1405,5 +1400,5 @@
 
 	void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) {
-		alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( constantExpr, env, Cost::zero ) );
 	}
 
@@ -1425,5 +1420,5 @@
 			Alternative &choice = winners.front();
 			referenceToRvalueConversion( choice.expr, choice.cost );
-			alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+			alternatives.push_back( Alternative( new SizeofExpr( choice.expr ), choice.env, Cost::zero ) );
 		} // if
 	}
@@ -1446,5 +1441,5 @@
 			Alternative &choice = winners.front();
 			referenceToRvalueConversion( choice.expr, choice.cost );
-			alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+			alternatives.push_back( Alternative( new AlignofExpr( choice.expr ), choice.env, Cost::zero ) );
 		} // if
 	}
@@ -1475,9 +1470,9 @@
 
 	void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) {
-		alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( offsetofExpr, env, Cost::zero ) );
 	}
 
 	void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) {
-		alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( offsetPackExpr, env, Cost::zero ) );
 	}
 
@@ -1557,5 +1552,5 @@
 				compositeEnv.simpleCombine( second.env );
 
-				LogicalExpr *newExpr = new LogicalExpr( first.expr->clone(), second.expr->clone(), logicalExpr->get_isAnd() );
+				LogicalExpr *newExpr = new LogicalExpr( first.expr, second.expr, logicalExpr->get_isAnd() );
 				alternatives.push_back( Alternative( newExpr, compositeEnv, first.cost + second.cost ) );
 			}
@@ -1590,5 +1585,5 @@
 					Type* commonType = nullptr;
 					if ( unify( second.expr->result, third.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-						ConditionalExpr *newExpr = new ConditionalExpr( first.expr->clone(), second.expr->clone(), third.expr->clone() );
+						ConditionalExpr *newExpr = new ConditionalExpr( first.expr, second.expr, third.expr );
 						newExpr->result = commonType ? commonType : second.expr->result->clone();
 						// convert both options to the conditional result type
@@ -1609,7 +1604,6 @@
 		secondFinder.findWithAdjustment( commaExpr->get_arg2() );
 		for ( const Alternative & alt : secondFinder.alternatives ) {
-			alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
+			alternatives.push_back( Alternative( new CommaExpr( newFirstArg, alt.expr ), alt.env, alt.cost ) );
 		} // for
-		delete newFirstArg;
 	}
 
@@ -1632,5 +1626,5 @@
 				Type* commonType = nullptr;
 				if ( unify( first.expr->result, second.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-					RangeExpr * newExpr = new RangeExpr( first.expr->clone(), second.expr->clone() );
+					RangeExpr * newExpr = new RangeExpr( first.expr, second.expr );
 					newExpr->result = commonType ? commonType : first.expr->result->clone();
 					newAlt.expr = newExpr;
@@ -1660,9 +1654,9 @@
 
 	void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) {
-		alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( tupleExpr, env, Cost::zero ) );
 	}
 
 	void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
-		alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( impCpCtorExpr, env, Cost::zero ) );
 	}
 
@@ -1673,14 +1667,14 @@
 		finder.findWithoutPrune( ctorExpr->get_callExpr() );
 		for ( Alternative & alt : finder.alternatives ) {
-			alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
+			alternatives.push_back( Alternative( new ConstructorExpr( alt.expr ), alt.env, alt.cost ) );
 		}
 	}
 
 	void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) {
-		alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( tupleExpr, env, Cost::zero ) );
 	}
 
 	void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) {
-		alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
+		alternatives.push_back( Alternative( tupleAssignExpr, env, Cost::zero ) );
 	}
 
@@ -1690,5 +1684,5 @@
 		for ( Alternative & alt : finder.alternatives ) {
 			// ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
-			UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
+			UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr, unqExpr->get_id() );
 			alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
 		}
@@ -1741,5 +1735,5 @@
 					// count one safe conversion for each value that is thrown away
 					thisCost.incSafe( discardedValues );
-					Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
+					Alternative newAlt( new InitExpr( restructureCast( alt.expr, toType, true ), initAlt.designation ), newEnv, alt.cost, thisCost );
 					inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
 				}
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/ConversionCost.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -20,4 +20,5 @@
 #include <string>                        // for operator==, string
 
+#include "Common/GC.h"                   // for new_static_root
 #include "ResolvExpr/Cost.h"             // for Cost
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
@@ -357,6 +358,6 @@
 	void ConversionCost::postvisit( EnumInstType * ) {
 		static Type::Qualifiers q;
-		static BasicType integer( q, BasicType::SignedInt );
-		cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
+		static BasicType* integer = new_static_root<BasicType>( q, BasicType::SignedInt );
+		cost = costFunc( integer, dest, indexer, env );  // safe if dest >= int
 		if ( cost < Cost::unsafe ) {
 			cost.incSafe();
Index: src/ResolvExpr/ExplodedActual.h
===================================================================
--- src/ResolvExpr/ExplodedActual.h	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/ExplodedActual.h	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -16,5 +16,4 @@
 #pragma once
 
-#include <memory>
 #include <vector>
 
@@ -29,5 +28,5 @@
 		TypeEnvironment env;
 		Cost cost;
-		std::vector< std::unique_ptr<Expression> > exprs;
+		std::vector< Expression* > exprs;
 
 		ExplodedActual() : env(), cost(Cost::zero), exprs() {}
Index: src/ResolvExpr/ResolveTypeof.cc
===================================================================
--- src/ResolvExpr/ResolveTypeof.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -70,9 +70,5 @@
 			Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
 			assert( newExpr->result && ! newExpr->result->isVoid() );
-			Type * newType = newExpr->result;
-			newExpr->result = nullptr;
-			delete typeofType;
-			delete newExpr;
-			return newType;
+			return newExpr->result;
 		} // if
 		return typeofType;
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/Resolver.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -22,4 +22,5 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "Common/GC.h"                   // for new_generation, collect_young
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
@@ -158,5 +159,4 @@
 					castExpr->arg = nullptr;
 					std::swap( expr->env, castExpr->env );
-					delete castExpr;
 				}
 			}
@@ -167,4 +167,7 @@
 		void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
 			assertf( untyped, "expected a non-null expression." );
+
+			auto guard = new_generation();  // set up GC generation for this top-level expression
+
 			TypeEnvironment env;
 			AlternativeFinder finder( indexer, env );
@@ -207,7 +210,9 @@
 			Alternative & choice = winners.front();
 			if ( findDeletedExpr( choice.expr ) ) {
+				trace( choice.expr );
 				SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
 			}
 			alt = std::move( choice );
+			trace( alt );
 		}
 
@@ -218,5 +223,4 @@
 			findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
 			finishExpr( choice.expr, choice.env, untyped->env );
-			delete untyped;
 			untyped = choice.expr;
 			choice.expr = nullptr;
@@ -241,21 +245,15 @@
 		assertf( expr, "expected a non-null expression." );
 
-		static CastExpr untyped( nullptr ); // cast to void
-		untyped.location = expr->location;
+		auto untyped = new CastExpr{ expr }; // cast to void
+		untyped->location = expr->location;
 
 		// set up and resolve expression cast to void
-		untyped.arg = expr;
 		Alternative choice;
-		findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
+		findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, true );
 		CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
 		env = std::move( choice.env );
 
 		// clean up resolved expression
-		Expression * ret = castExpr->arg;
-		castExpr->arg = nullptr;
-
-		// unlink the arg so that it isn't deleted twice at the end of the program
-		untyped.arg = nullptr;
-		return ret;
+		return castExpr->arg;
 	}
 
@@ -265,5 +263,4 @@
 		Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
 		finishExpr( newExpr, env, untyped->env );
-		delete untyped;
 		untyped = newExpr;
 	}
@@ -449,5 +446,4 @@
 				castExpr->arg = nullptr;
 				std::swap( newExpr->env, castExpr->env );
-				delete castExpr;
 			}
 			caseStmt->condition = newExpr;
@@ -747,5 +743,4 @@
 		// and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
 		newExpr->spliceInferParams( initExpr );
-		delete initExpr;
 
 		// get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
@@ -765,5 +760,4 @@
 							ce->set_arg( nullptr );
 							std::swap( ce->env, newExpr->env );
-							delete ce;
 						}
 					}
@@ -816,8 +810,6 @@
 		// could not find valid constructor, or found an intrinsic constructor
 		// fall back on C-style initializer
-		delete ctorInit->get_ctor();
-		ctorInit->set_ctor( NULL );
-		delete ctorInit->get_dtor();
-		ctorInit->set_dtor( NULL );
+		ctorInit->set_ctor( nullptr );
+		ctorInit->set_dtor( nullptr );
 		maybeAccept( ctorInit->get_init(), *visitor );
 	}
@@ -845,5 +837,4 @@
 
 		// found a constructor - can get rid of C-style initializer
-		delete ctorInit->init;
 		ctorInit->init = nullptr;
 
@@ -852,10 +843,8 @@
 		// to clean up generated code.
 		if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
-			delete ctorInit->ctor;
 			ctorInit->ctor = nullptr;
 		}
 
 		if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
-			delete ctorInit->dtor;
 			ctorInit->dtor = nullptr;
 		}
Index: src/ResolvExpr/TypeEnvironment.cc
===================================================================
--- src/ResolvExpr/TypeEnvironment.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/TypeEnvironment.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -17,8 +17,9 @@
 #include <algorithm>                   // for copy, set_intersection
 #include <iterator>                    // for ostream_iterator, insert_iterator
-#include <memory>                      // for unique_ptr
 #include <utility>                     // for pair, move
 
+#include "Common/PassVisitor.h"        // for PassVisitor<GcTracer>
 #include "Common/utility.h"            // for maybeClone
+#include "SynTree/GcTracer.h"          // for PassVisitor<GcTracer>
 #include "SynTree/Type.h"              // for Type, FunctionType, Type::Fora...
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
@@ -77,5 +78,4 @@
 	EqvClass &EqvClass::operator=( const EqvClass &other ) {
 		if ( this == &other ) return *this;
-		delete type;
 		initialize( other, *this );
 		return *this;
@@ -84,9 +84,7 @@
 	EqvClass &EqvClass::operator=( EqvClass &&other ) {
 		if ( this == &other ) return *this;
-		delete type;
 		
 		vars = std::move(other.vars);
 		type = other.type;
-		other.type = nullptr;
 		allowWidening = std::move(other.allowWidening);
 		data = std::move(other.data);
@@ -95,13 +93,5 @@
 	}
 
-	EqvClass::~EqvClass() {
-		delete type;
-	}
-
-	void EqvClass::set_type( Type* ty ) {
-		if ( ty == type ) return;
-		delete type;
-		type = ty;
-	}
+	void EqvClass::set_type( Type* ty ) { type = ty; }
 
 	void EqvClass::print( std::ostream &os, Indenter indent ) const {
@@ -175,5 +165,4 @@
 					TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
 					sub.add( *theVar, newTypeInst );
-					delete newTypeInst;
 				} // if
 			} // for
@@ -261,7 +250,7 @@
 				Type *common = 0;
 				// attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-				std::unique_ptr< Type > newType( curClass->type->clone() );
+				Type *newType = curClass->type->clone();
 				newType->get_qualifiers() = typeInst->get_qualifiers();
-				if ( unifyInexact( newType.get(), bindTo, *this, need, have, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
+				if ( unifyInexact( newType, bindTo, *this, need, have, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
 					if ( common ) {
 						common->get_qualifiers() = Type::Qualifiers{};
@@ -319,8 +308,8 @@
 		if ( type1 && type2 ) {
 			// both classes bound, merge if bound types can be unified
-			std::unique_ptr<Type> newType1{ type1->clone() }, newType2{ type2->clone() };
+			Type *newType1 = type1->clone(), *newType2 = type2->clone();
 			WidenMode newWidenMode{ widen1, widen2 };
 			Type *common = 0;
-			if ( unifyInexact( newType1.get(), newType2.get(), *this, need, have, openVars, newWidenMode, indexer, common ) ) {
+			if ( unifyInexact( newType1, newType2, *this, need, have, openVars, newWidenMode, indexer, common ) ) {
 				class1->vars.insert( class2->vars.begin(), class2->vars.end() );
 				class1->allowWidening = widen1 && widen2;
@@ -370,4 +359,11 @@
 		return out;
 	}
+
+	PassVisitor<GcTracer> & operator<<( PassVisitor<GcTracer> & gc, const TypeEnvironment & env ) {
+		for ( const EqvClass & c : env ) {
+			maybeAccept( c.type, gc );
+		}
+		return gc;
+	}
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/TypeEnvironment.h
===================================================================
--- src/ResolvExpr/TypeEnvironment.h	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/TypeEnvironment.h	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -29,4 +29,8 @@
 #include "SynTree/Type.h"              // for Type, Type::ForallList
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
+
+template< typename Pass >
+class PassVisitor;
+class GcTracer;
 
 namespace ResolvExpr {
@@ -83,5 +87,4 @@
 		EqvClass &operator=( const EqvClass &other );
 		EqvClass &operator=( EqvClass &&other );
-		~EqvClass();
 		void print( std::ostream &os, Indenter indent = {} ) const;
 
@@ -148,4 +151,6 @@
 
 	std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env );
+
+	PassVisitor<GcTracer> & operator<<( PassVisitor<GcTracer> & gc, const TypeEnvironment & env );
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/Unify.cc	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -17,5 +17,4 @@
 #include <iterator>               // for back_insert_iterator, back_inserter
 #include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
-#include <memory>                 // for unique_ptr
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
@@ -99,8 +98,5 @@
 		findOpenVars( newSecond, openVars, closedVars, needAssertions, haveAssertions, true );
 
-		bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-		delete newFirst;
-		delete newSecond;
-		return result;
+		return unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 	}
 
@@ -123,8 +119,5 @@
 ///   newSecond->print( std::cerr );
 ///   std::cerr << std::endl;
-		bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-		delete newFirst;
-		delete newSecond;
-		return result;
+		return unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 	}
 
@@ -134,12 +127,5 @@
 		findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
 		Type *commonType = 0;
-		if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
-			if ( commonType ) {
-				delete commonType;
-			} // if
-			return true;
-		} else {
-			return false;
-		} // if
+		return unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType );
 	}
 
@@ -335,5 +321,5 @@
 
 	template< typename Iterator, typename Func >
-	std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end, Func & toType ) {
+	Type* combineTypes( Iterator begin, Iterator end, Func & toType ) {
 		std::list< Type * > types;
 		for ( ; begin != end; ++begin ) {
@@ -341,5 +327,5 @@
 			flatten( toType( *begin ), back_inserter( types ) );
 		}
-		return std::unique_ptr<Type>( new TupleType( Type::Qualifiers(), types ) );
+		return new TupleType{ Type::Qualifiers(), types };
 	}
 
@@ -356,8 +342,8 @@
 			if ( isTtype1 && ! isTtype2 ) {
 				// combine all of the things in list2, then unify
-				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else if ( isTtype2 && ! isTtype1 ) {
 				// combine all of the things in list1, then unify
-				return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
 				return false;
@@ -369,5 +355,5 @@
 			Type * t1 = (*list1Begin)->get_type();
 			if ( Tuples::isTtype( t1 ) ) {
-				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else return false;
 		} else if ( list2Begin != list2End ) {
@@ -375,5 +361,5 @@
 			Type * t2 = (*list2Begin)->get_type();
 			if ( Tuples::isTtype( t2 ) ) {
-				return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else return false;
 		} else {
@@ -394,5 +380,4 @@
 				// expand ttype parameter into its actual type
 				if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
-					delete typeInst;
 					return eqvClass->type->clone();
 				}
@@ -418,5 +403,4 @@
 				dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
 			}
-			delete dcl;
 		}
 	}
@@ -427,6 +411,6 @@
 			// flatten the parameter lists for both functions so that tuple structure
 			// doesn't affect unification. Must be a clone so that the types don't change.
-			std::unique_ptr<FunctionType> flatFunc( functionType->clone() );
-			std::unique_ptr<FunctionType> flatOther( otherFunction->clone() );
+			FunctionType* flatFunc = functionType->clone();
+			FunctionType* flatOther = otherFunction->clone();
 			flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env );
 			flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env );
@@ -569,8 +553,8 @@
 			if ( isTtype1 && ! isTtype2 ) {
 				// combine all of the things in list2, then unify
-				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else if ( isTtype2 && ! isTtype1 ) {
 				// combine all of the things in list1, then unify
-				return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
 				return false;
@@ -582,5 +566,5 @@
 			Type * t1 = *list1Begin;
 			if ( Tuples::isTtype( t1 ) ) {
-				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else return false;
 		} else if ( list2Begin != list2End ) {
@@ -588,5 +572,5 @@
 			Type * t2 = *list2Begin;
 			if ( Tuples::isTtype( t2 ) ) {
-				return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+				return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
 			} else return false;
 		} else {
@@ -597,6 +581,6 @@
 	void Unify::postvisit(TupleType *tupleType) {
 		if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
-			std::unique_ptr<TupleType> flat1( tupleType->clone() );
-			std::unique_ptr<TupleType> flat2( otherTuple->clone() );
+			TupleType* flat1 = tupleType->clone();
+			TupleType* flat2 = otherTuple->clone();
 			std::list<Type *> types1, types2;
 
@@ -605,6 +589,6 @@
 			flat2->acceptMutator( expander );
 
-			flatten( flat1.get(), back_inserter( types1 ) );
-			flatten( flat2.get(), back_inserter( types2 ) );
+			flatten( flat1, back_inserter( types1 ) );
+			flatten( flat2, back_inserter( types2 ) );
 
 			result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
Index: src/ResolvExpr/Unify.h
===================================================================
--- src/ResolvExpr/Unify.h	(revision d286cf68892dfb231fb65f0127f47f3d593ac9f1)
+++ src/ResolvExpr/Unify.h	(revision 28f3a190cabb48116467ce6e1ebc74a38dac95b7)
@@ -54,10 +54,5 @@
 	bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
 		std::list< Type* > commonTypes;
-		if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
-			deleteAll( commonTypes );
-			return true;
-		} else {
-			return false;
-		} // if
+		return unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes );
 	}