Index: src/CodeGen/Generate.cc
===================================================================
--- src/CodeGen/Generate.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/CodeGen/Generate.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -41,5 +41,5 @@
 		void cleanTree( std::list< Declaration * > & translationUnit ) {
 			PassVisitor<TreeCleaner> cleaner;
-			filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); }, false );
+			filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); } );
 			mutateAll( translationUnit, cleaner );
 		} // cleanTree
@@ -79,5 +79,5 @@
 				}
 				return false;
-			}, false );
+			} );
 		}
 
@@ -85,5 +85,4 @@
 			Statement * callStmt = nullptr;
 			std::swap( stmt->callStmt, callStmt );
-			delete stmt;
 			return callStmt;
 		}
Index: src/Common/GC.cc
===================================================================
--- src/Common/GC.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
+++ src/Common/GC.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -0,0 +1,111 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// GC.cc --
+//
+// Author           : Aaron B. Moss
+// Created On       : Thu Mar 15 14:47:00 2018
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Mar 15 14:47:00 2018
+// Update Count     : 1
+//
+
+#include "GC.h"
+
+#include <algorithm>
+
+GC& GC::get() {
+	static GC gc;
+	return gc;
+}
+
+GC::GC() : mark(false), old(), young(), using_young(false) {
+	old.reserve(70000);
+}
+
+GC::~GC() {
+	for ( GC_Object* o : young ) {
+		delete o;
+	}
+
+	for ( GC_Object* o : old ) {
+		delete o;
+	}
+}
+
+const GC& GC::operator<< (const GC_Traceable* obj) const {
+	if( obj )
+	{
+		bool isMarked = obj->mark == this->mark;
+		if( !isMarked ) {
+			obj->mark = this->mark;
+			obj->trace( *this );
+		}
+	}
+	return *this;
+}
+
+void GC::register_object(GC_Object* obj) {
+	(using_young ? young : old).push_back(obj);
+	obj->mark = this->mark;
+}
+
+void GC::new_generation() {
+	using_young = true;
+}
+
+void GC::collect_young() {
+	// check young generation, just reset mark if not using
+	if ( ! using_young ) {
+		mark = !mark;
+		return;
+	}
+
+	// collect young gen
+	for ( GC_Object*& obj : young ) {
+		if ( obj->mark != mark ) {
+			delete obj;
+			obj = nullptr;
+		}
+	}
+	
+	// move uncollected elements into old gen
+	auto end_live = std::remove( young.begin(), young.end(), nullptr );
+	old.insert( old.end(), young.begin(), end_live );
+	
+	// clear young gen
+	using_young = false;
+	young.clear();
+
+	// reset mark for next collection
+	mark = !mark;
+}
+
+void GC::collect() {
+	// collect old gen
+	for ( GC_Object*& obj : old ) {
+		if ( obj->mark != mark ) {
+			delete obj;
+			obj = nullptr;
+		}
+	}
+
+	// clear collected elements
+	old.erase( std::remove( old.begin(), old.end(), nullptr ), old.end() );
+
+	// collect young gen (also resets mark)
+	collect_young();
+}
+
+GC_Object::GC_Object() {
+	GC::get().register_object( this );
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Common/GC.h
===================================================================
--- src/Common/GC.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
+++ src/Common/GC.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -0,0 +1,117 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// GC.h --
+//
+// Author           : Aaron B. Moss
+// Created On       : Thu Mar 15 14:47:00 2018
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Mar 15 14:47:00 2018
+// Update Count     : 1
+//
+
+#pragma once
+
+#include <vector>
+
+class GC_Traceable;
+class GC_Object;
+
+/// Manually traced and called garbage collector
+class GC {
+	friend class GcTracer;
+public:
+	/// Gets singleton GC instance
+	static GC& get();
+
+	/// Traces a traceable object
+	const GC& operator<< (const GC_Traceable*) const;
+
+	/// Adds a new object to garbage collection
+	void register_object(GC_Object*);
+
+	/// Use young generation for subsequent new objects
+	void new_generation();
+
+	/// Collects the young generation, placing survivors in old generation.
+	/// Old generation is used for subsequent new objects.
+	void collect_young();
+
+	/// Collects all memory; use old generation afterward.
+	void collect();
+
+	/// Collects all contained objects
+	~GC();
+
+private:
+	GC();
+
+	/// The current collection's mark bit
+	bool mark;
+
+	typedef std::vector<class GC_Object*> Generation;
+	Generation old;
+	Generation young;
+	bool using_young;
+};
+
+/// Use young generation until next collection
+inline void new_generation() { GC::get().new_generation(); }
+
+/// no-op default trace
+template<typename T>
+inline const GC& operator<< (const GC& gc, const T& x) { return gc; }
+
+inline void traceAll(const GC& gc) {}
+
+/// Marks all arguments as live in current generation
+template<typename T, typename... Args>
+inline void traceAll(const GC& gc, T& x, Args&... xs) {
+	gc << x;
+	traceAll(gc, xs...);
+}
+
+/// Traces young-generation roots and does a young collection
+template<typename... Args>
+inline void collect_young(Args&... roots) {
+	GC& gc = GC::get();
+	traceAll(gc, roots...);
+	gc.collect_young();
+}
+
+/// Traces roots and collects other elements
+template<typename... Args>
+inline void collect(Args&... roots) {
+	GC& gc = GC::get();
+	traceAll(gc, roots...);
+	gc.collect();
+}
+
+/// Class that is traced by the GC, but not managed by it
+class GC_Traceable {
+	friend class GC;
+	friend class GcTracer;
+
+	mutable bool mark;
+protected:
+	/// override to trace any child objects
+	virtual void trace(const GC& gc) const {}
+};
+
+/// Class that is managed by the GC
+class GC_Object : public GC_Traceable {
+	friend class GC;
+protected:
+	virtual ~GC_Object() {}
+public:
+	GC_Object();
+};
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Common/PassVisitor.h
===================================================================
--- src/Common/PassVisitor.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Common/PassVisitor.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -152,4 +152,6 @@
 	virtual void visit( Attribute * attribute ) override final;
 
+	virtual void visit( TypeSubstitution * sub ) final;
+
 	virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final;
 	virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) override final;
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Common/PassVisitor.impl.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -2556,4 +2556,18 @@
 // TypeSubstitution
 template< typename pass_type >
+void PassVisitor< pass_type >::visit( TypeSubstitution * node ) {
+	VISIT_START( node );
+
+	for ( auto & p : node->typeEnv ) {
+		indexerScopedAccept( p.second, *this );
+	}
+	for ( auto & p : node->varEnv ) {
+		indexerScopedAccept( p.second, *this );
+	}
+
+	VISIT_END( node );
+}
+
+template< typename pass_type >
 TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
 	MUTATE_START( node );
Index: src/Common/module.mk
===================================================================
--- src/Common/module.mk	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Common/module.mk	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -18,3 +18,4 @@
        Common/UniqueName.cc \
        Common/DebugMalloc.cc \
+       Common/GC.cc \
        Common/Assert.cc
Index: src/Common/utility.h
===================================================================
--- src/Common/utility.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Common/utility.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -190,12 +190,9 @@
 
 template <typename E, typename UnaryPredicate, template< typename, typename...> class Container, typename... Args >
-void filter( Container< E *, Args... > & container, UnaryPredicate pred, bool doDelete ) {
+void filter( Container< E *, Args... > & container, UnaryPredicate pred ) {
 	auto i = begin( container );
 	while ( i != end( container ) ) {
 		auto it = next( i );
 		if ( pred( *i ) ) {
-			if ( doDelete ) {
-				delete *i;
-			} // if
 			container.erase( i );
 		} // if
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Concurrency/Keywords.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -291,5 +291,4 @@
 		StructDecl * forward = decl->clone();
 		forward->set_body( false );
-		deleteAll( forward->get_members() );
 		forward->get_members().clear();
 
@@ -355,6 +354,4 @@
 			fixupGenerics(main_type, decl);
 		}
-
-		delete this_decl;
 
 		declsToAddBefore.push_back( forward );
Index: src/Concurrency/Waitfor.cc
===================================================================
--- src/Concurrency/Waitfor.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Concurrency/Waitfor.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -476,6 +476,4 @@
 		}
 
-		delete setter;
-
 		return new VariableExpr( timeout );
 	}
Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ControlStruct/ExceptTranslate.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -204,5 +204,4 @@
 		call->get_args().push_back( throwStmt->get_expr() );
 		throwStmt->set_expr( nullptr );
-		delete throwStmt;
 		return new ExprStmt( call );
 	}
@@ -234,5 +233,4 @@
 			new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
 			) );
-		delete throwStmt;
 		return result;
 	}
@@ -251,5 +249,4 @@
 			);
 		result->labels = throwStmt->labels;
-		delete throwStmt;
 		return result;
 	}
@@ -384,5 +381,4 @@
 		modded_handler->set_cond( nullptr );
 		modded_handler->set_body( nullptr );
-		delete modded_handler;
 		return block;
 	}
@@ -530,5 +526,4 @@
 		CompoundStmt * body = finally->get_block();
 		finally->set_block( nullptr );
-		delete finally;
 		tryStmt->set_finally( nullptr );
 
Index: src/ControlStruct/MLEMutator.cc
===================================================================
--- src/ControlStruct/MLEMutator.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ControlStruct/MLEMutator.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -151,5 +151,4 @@
 
 		// transform break/continue statements into goto to simplify later handling of branches
-		delete branchStmt;
 		return new BranchStmt( exitLabel, BranchStmt::Goto );
 	}
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/GenPoly/Box.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -860,9 +860,7 @@
 			// do not carry over attributes to real type parameters/return values
 			for ( DeclarationWithType * dwt : realType->parameters ) {
-				deleteAll( dwt->get_type()->attributes );
 				dwt->get_type()->attributes.clear();
 			}
 			for ( DeclarationWithType * dwt : realType->returnVals ) {
-				deleteAll( dwt->get_type()->attributes );
 				dwt->get_type()->attributes.clear();
 			}
@@ -985,5 +983,4 @@
 			} // if
 			appExpr->get_args().clear();
-			delete appExpr;
 			return addAssign;
 		}
@@ -1016,5 +1013,4 @@
 						} // if
 						if ( baseType1 || baseType2 ) {
-							delete ret->get_result();
 							ret->set_result( appExpr->get_result()->clone() );
 							if ( appExpr->get_env() ) {
@@ -1023,5 +1019,4 @@
 							} // if
 							appExpr->get_args().clear();
-							delete appExpr;
 							return ret;
 						} // if
@@ -1033,5 +1028,4 @@
 							Expression *ret = appExpr->get_args().front();
 							// fix expr type to remove pointer
-							delete ret->get_result();
 							ret->set_result( appExpr->get_result()->clone() );
 							if ( appExpr->get_env() ) {
@@ -1040,5 +1034,4 @@
 							} // if
 							appExpr->get_args().clear();
-							delete appExpr;
 							return ret;
 						} // if
@@ -1180,5 +1173,4 @@
 						Expression *ret = expr->args.front();
 						expr->args.clear();
-						delete expr;
 						return ret;
 					} // if
@@ -1214,8 +1206,6 @@
 			if ( polytype || needs ) {
 				Expression *ret = addrExpr->arg;
-				delete ret->result;
 				ret->result = addrExpr->result->clone();
 				addrExpr->arg = nullptr;
-				delete addrExpr;
 				return ret;
 			} else {
@@ -1227,5 +1217,4 @@
 			if ( retval && returnStmt->expr ) {
 				assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
-				delete returnStmt->expr;
 				returnStmt->expr = nullptr;
 			} // if
@@ -1270,5 +1259,4 @@
 				}
 			}
-//  deleteAll( functions );
 		}
 
@@ -1290,5 +1278,4 @@
 			for ( Declaration * param : functionDecl->type->parameters ) {
 				if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( param ) ) {
-					delete obj->init;
 					obj->init = nullptr;
 				}
@@ -1499,7 +1486,5 @@
 							// polymorphic aggregate members should be converted into monomorphic members.
 							// Using char[size_T] here respects the expected sizing rules of an aggregate type.
-							Type * newType = polyToMonoType( field->type );
-							delete field->type;
-							field->type = newType;
+							field->type = polyToMonoType( field->type );
 						}
 					}
@@ -1524,5 +1509,4 @@
 					stmtsToAddBefore.push_back( new DeclStmt( newBuf ) );
 
-					delete objectDecl->get_init();
 					objectDecl->set_init( new SingleInit( new VariableExpr( newBuf ) ) );
 				}
@@ -1603,6 +1587,4 @@
 			}
 
-			delete memberType;
-			delete memberExpr;
 			return newMemberExpr;
 		}
@@ -1624,5 +1606,4 @@
 						addrExpr->arg = nullptr;
 						std::swap( addrExpr->env, ret->env );
-						delete addrExpr;
 						return ret;
 					}
@@ -1750,7 +1731,5 @@
 			Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
 			if ( findGeneric( ty ) ) {
-				Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
-				delete sizeofExpr;
-				return ret;
+				return new NameExpr( sizeofName( mangleType( ty ) ) );
 			}
 			return sizeofExpr;
@@ -1760,7 +1739,5 @@
 			Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
 			if ( findGeneric( ty ) ) {
-				Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
-				delete alignofExpr;
-				return ret;
+				return new NameExpr( alignofName( mangleType( ty ) ) );
 			}
 			return alignofExpr;
@@ -1777,10 +1754,7 @@
 				if ( i == -1 ) return offsetofExpr;
 
-				Expression *offsetInd = makeOffsetIndex( ty, i );
-				delete offsetofExpr;
-				return offsetInd;
+				return makeOffsetIndex( ty, i );
 			} else if ( dynamic_cast< UnionInstType* >( ty ) ) {
 				// all union members are at offset zero
-				delete offsetofExpr;
 				return new ConstantExpr( Constant::from_ulong( 0 ) );
 			} else return offsetofExpr;
@@ -1822,5 +1796,4 @@
 			}
 
-			delete offsetPackExpr;
 			return ret;
 		}
Index: src/GenPoly/InstantiateGeneric.cc
===================================================================
--- src/GenPoly/InstantiateGeneric.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/GenPoly/InstantiateGeneric.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -58,6 +58,4 @@
 
 		TypeList& operator= ( const TypeList &that ) {
-			deleteAll( params );
-
 			params.clear();
 			cloneAll( that.params, params );
@@ -67,6 +65,4 @@
 
 		TypeList& operator= ( TypeList &&that ) {
-			deleteAll( params );
-
 			params = std::move( that.params );
 
@@ -74,5 +70,5 @@
 		}
 
-		~TypeList() { deleteAll( params ); }
+		~TypeList() {}
 
 		bool operator== ( const TypeList& that ) const {
@@ -293,5 +289,4 @@
 	/// Strips the instances's type parameters
 	void stripInstParams( ReferenceToType *inst ) {
-		deleteAll( inst->get_parameters() );
 		inst->get_parameters().clear();
 	}
@@ -300,6 +295,4 @@
 		substituteMembers( base->get_members(), baseParams, typeSubs );
 
-		// xxx - can't delete type parameters because they may have assertions that are used
-		// deleteAll( baseParams );
 		baseParams.clear();
 
@@ -380,5 +373,4 @@
 			newInst->set_baseStruct( concDecl );
 
-			delete inst;
 			inst = newInst;
 			break;
@@ -390,5 +382,4 @@
 		}
 
-		deleteAll( typeSubs );
 		return inst;
 	}
@@ -430,5 +421,4 @@
 			newInst->set_baseUnion( concDecl );
 
-			delete inst;
 			inst = newInst;
 			break;
@@ -439,5 +429,4 @@
 		}
 
-		deleteAll( typeSubs );
 		return inst;
 	}
@@ -477,5 +466,4 @@
 			ResolvExpr::adjustExprType( ret->result ); // pointer decay
 			std::swap( ret->env, memberExpr->env );
-			delete memberExpr;
 			return ret;
 		}
Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/GenPoly/Lvalue.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -50,5 +50,4 @@
 				assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
 				ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
-				delete ret->result;
 				ret->result = base->clone();
 				ret->result->set_lvalue( true );
@@ -171,5 +170,4 @@
 					return ret;
 				}
-				delete result;
 			}
 			return appExpr;
@@ -214,7 +212,5 @@
 							Type * baseType = InitTweak::getPointerBase( arg->get_result() );
 							assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
-							PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
-							delete arg->get_result();
-							arg->set_result( ptrType );
+							arg->set_result( new PointerType{ Type::Qualifiers(), baseType->clone() } );
 							arg = mkDeref( arg );
 						}
@@ -294,5 +290,4 @@
 						)
 						callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
-						delete callExpr->get_result();
 						callExpr->set_result( refType->clone() );
 						// move environment out to new top-level
@@ -300,5 +295,4 @@
 						castExpr->set_arg( nullptr );
 						castExpr->set_env( nullptr );
-						delete castExpr;
 						return callExpr;
 					}
@@ -318,5 +312,4 @@
 						}
 						ret->env = castExpr->env;
-						delete ret->result;
 						ret->result = castExpr->result;
 						ret->result->set_lvalue( true ); // ensure result is lvalue
@@ -324,5 +317,4 @@
 						castExpr->arg = nullptr;
 						castExpr->result = nullptr;
-						delete castExpr;
 						return ret;
 					} else if ( diff > 0 ) {
@@ -333,10 +325,8 @@
 						}
 						ret->env = castExpr->env;
-						delete ret->result;
 						ret->result = castExpr->result;
 						castExpr->env = nullptr;
 						castExpr->arg = nullptr;
 						castExpr->result = nullptr;
-						delete castExpr;
 						return ret;
 					}
@@ -360,10 +350,8 @@
 					}
 					ret->env = castExpr->env;
-					delete ret->result;
 					ret->result = castExpr->result;
 					castExpr->env = nullptr;
 					castExpr->arg = nullptr;
 					castExpr->result = nullptr;
-					delete castExpr;
 					return ret;
 				} else {
@@ -390,5 +378,4 @@
 					ret->result->set_lvalue( true );  // ensure result is lvalue
 					castExpr->arg = nullptr;
-					delete castExpr;
 				} else {
 					// must keep cast if types are different
@@ -407,5 +394,4 @@
 			Type::Qualifiers qualifiers = refType->get_qualifiers();
 			refType->set_base( nullptr );
-			delete refType;
 			return new PointerType( qualifiers, base );
 		}
@@ -419,5 +405,4 @@
 				ret->set_env( expr->get_env() );
 				expr->set_env( nullptr );
-				delete expr;
 				return ret;
 			} else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
@@ -428,5 +413,4 @@
 				ret->set_env( expr->get_env() );
 				expr->set_env( nullptr );
-				delete expr;
 
 				// conditional expr type may not be either of the argument types, need to unify
@@ -461,5 +445,4 @@
 					arg0 = nullptr;
 					addrExpr->set_env( nullptr );
-					delete addrExpr;
 					return ret;
 				}
@@ -491,5 +474,4 @@
 						addrExpr->set_arg( nullptr );
 						appExpr->set_env( nullptr );
-						delete appExpr;
 						return ret;
 					}
Index: src/GenPoly/ScrubTyVars.cc
===================================================================
--- src/GenPoly/ScrubTyVars.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/GenPoly/ScrubTyVars.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -28,10 +28,7 @@
 		if ( ! tyVars ) {
 			if ( typeInst->get_isFtype() ) {
-				delete typeInst;
-				return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
+				return new PointerType{ Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) };
 			} else {
-				PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-				delete typeInst;
-				return ret;
+				return new PointerType{ Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) };
 			}
 		}
@@ -42,12 +39,7 @@
 			  case TypeDecl::Dtype:
 			  case TypeDecl::Ttype:
-				{
-					PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-					delete typeInst;
-					return ret;
-				}
+				return new PointerType{ Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) };
 			  case TypeDecl::Ftype:
-				delete typeInst;
-				return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
+				return new PointerType{ Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) };
 			} // switch
 		} // if
@@ -57,7 +49,5 @@
 	Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
 		if ( shouldScrub( ty ) ) {
-			PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
-			delete ty;
-			return ret;
+			return new PointerType{ Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) };
 		}
 		return ty;
@@ -104,6 +94,4 @@
 			Type * ret = dynType->acceptMutator( *visitor );
 			ret->get_qualifiers() |= pointer->get_qualifiers();
-			pointer->base = nullptr;
-			delete pointer;
 			return ret;
 		}
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/GenPoly/Specialize.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -193,5 +193,4 @@
 				explodeSimple( new TupleIndexExpr( expr->clone(), i ), out );
 			}
-			delete expr;
 		} else {
 			// non-tuple type - output a clone of the expression
Index: src/InitTweak/FixGlobalInit.cc
===================================================================
--- src/InitTweak/FixGlobalInit.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/InitTweak/FixGlobalInit.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -57,13 +57,9 @@
 		GlobalFixer & fixer = visitor.pass;
 		// don't need to include function if it's empty
-		if ( fixer.initFunction->get_statements()->get_kids().empty() ) {
-			delete fixer.initFunction;
-		} else {
+		if ( ! fixer.initFunction->get_statements()->get_kids().empty() ) {
 			translationUnit.push_back( fixer.initFunction );
 		} // if
 
-		if ( fixer.destroyFunction->get_statements()->get_kids().empty() ) {
-			delete fixer.destroyFunction;
-		} else {
+		if ( ! fixer.destroyFunction->get_statements()->get_kids().empty() ) {
 			translationUnit.push_back( fixer.destroyFunction );
 		} // if
@@ -130,5 +126,4 @@
 				objDecl->set_init( NULL );
 			} // if
-			delete ctorInit;
 		} // if
 	}
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/InitTweak/FixInit.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -454,5 +454,4 @@
 				resolved->env = nullptr;
 			} // if
-			delete stmt;
 			if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
 				// fix newly generated StmtExpr
@@ -554,8 +553,5 @@
 				result = result->clone();
 				env->apply( result );
-				if ( ! InitTweak::isConstructable( result ) ) {
-					delete result;
-					return;
-				}
+				if ( ! InitTweak::isConstructable( result ) ) return;
 
 				// create variable that will hold the result of the stmt expr
@@ -652,5 +648,4 @@
 			std::swap( impCpCtorExpr->env, callExpr->env );
 			assert( impCpCtorExpr->env == nullptr );
-			delete impCpCtorExpr;
 
 			if ( returnDecl ) {
@@ -711,7 +706,5 @@
 			if ( unqMap.count( unqExpr->get_id() ) ) {
 				// take data from other UniqueExpr to ensure consistency
-				delete unqExpr->get_expr();
 				unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
-				delete unqExpr->get_result();
 				unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
 				if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
@@ -824,7 +817,8 @@
 							// create a new object which is never used
 							static UniqueName dummyNamer( "_dummy" );
-							ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
-							delete ctorInit;
-							return dummy;
+							return new ObjectDecl{
+								dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, 
+								new PointerType{ Type::Qualifiers(), new VoidType( Type::Qualifiers() ) }, 
+								0, std::list< Attribute * >{ new Attribute("unused") } };
 						}
 					} else {
@@ -852,5 +846,4 @@
 					objDecl->init = nullptr;
 				} // if
-				delete ctorInit;
 			} // if
 			return objDecl;
@@ -1228,5 +1221,4 @@
 			ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
 			declsToAddBefore.push_back( tmp );
-			delete ctorExpr;
 
 			// build assignment and replace constructor's first argument with new temporary
@@ -1237,5 +1229,4 @@
 			// resolve assignment and dispose of new env
 			ResolvExpr::findVoidExpression( assign, indexer );
-			delete assign->env;
 			assign->env = nullptr;
 
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/InitTweak/InitTweak.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -122,5 +122,5 @@
 	public:
 		ExprImpl( Expression * expr ) : arg( expr ) {}
-		virtual ~ExprImpl() { delete arg; }
+		virtual ~ExprImp() = default;
 
 		virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -166,5 +166,4 @@
 
 	void InitExpander::clearArrayIndices() {
-		deleteAll( indices );
 		indices.clear();
 	}
@@ -263,5 +262,4 @@
 		build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
 		if ( block->get_kids().empty() ) {
-			delete block;
 			return nullptr;
 		} else {
Index: src/MakeLibCfa.cc
===================================================================
--- src/MakeLibCfa.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/MakeLibCfa.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -65,10 +65,8 @@
 		struct ZeroOneReplacer {
 			ZeroOneReplacer( Type * t ) : type( t ) {}
-			~ZeroOneReplacer() { delete type; }
 			Type * type = nullptr;
 
 			Type * common( Type * t ) {
 				if ( ! type ) return t;
-				delete t;
 				return type->clone();
 			}
Index: src/Makefile.in
===================================================================
--- src/Makefile.in	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Makefile.in	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -163,4 +163,5 @@
 	Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \
 	Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \
+	Common/driver_cfa_cpp-GC.$(OBJEXT) \
 	Common/driver_cfa_cpp-Assert.$(OBJEXT) \
 	ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \
@@ -249,4 +250,5 @@
 	SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
+	SynTree/driver_cfa_cpp-GcTracer.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
 	Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
@@ -485,8 +487,8 @@
 	CodeTools/TrackLoc.cc Concurrency/Keywords.cc \
 	Concurrency/Waitfor.cc Common/SemanticError.cc \
-	Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \
-	ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
-	ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
-	ControlStruct/ForExprMutator.cc \
+	Common/UniqueName.cc Common/DebugMalloc.cc Common/GC.cc \
+	Common/Assert.cc ControlStruct/LabelGenerator.cc \
+	ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
+	ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
 	ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
 	GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
@@ -526,7 +528,8 @@
 	SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
 	SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
-	SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
-	Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
-	Tuples/Explode.cc Virtual/ExpandCasts.cc
+	SynTree/Attribute.cc SynTree/GcTracer.cc \
+	SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
+	Tuples/TupleExpansion.cc Tuples/Explode.cc \
+	Virtual/ExpandCasts.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
 	${cfa_cpplib_PROGRAMS}}
@@ -670,4 +673,6 @@
 	Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
+	Common/$(DEPDIR)/$(am__dirstamp)
+Common/driver_cfa_cpp-GC.$(OBJEXT): Common/$(am__dirstamp) \
 	Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \
@@ -912,4 +917,6 @@
 SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
 	SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-GcTracer.$(OBJEXT): SynTree/$(am__dirstamp) \
+	SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
 	SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
@@ -973,4 +980,5 @@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-GC.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
@@ -1045,4 +1053,5 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-FunctionDecl.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-FunctionType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Initializer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-NamedTypeDecl.Po@am__quote@
@@ -1294,4 +1303,18 @@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
 
+Common/driver_cfa_cpp-GC.o: Common/GC.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-GC.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo -c -o Common/driver_cfa_cpp-GC.o `test -f 'Common/GC.cc' || echo '$(srcdir)/'`Common/GC.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo Common/$(DEPDIR)/driver_cfa_cpp-GC.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='Common/GC.cc' object='Common/driver_cfa_cpp-GC.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-GC.o `test -f 'Common/GC.cc' || echo '$(srcdir)/'`Common/GC.cc
+
+Common/driver_cfa_cpp-GC.obj: Common/GC.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-GC.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo -c -o Common/driver_cfa_cpp-GC.obj `if test -f 'Common/GC.cc'; then $(CYGPATH_W) 'Common/GC.cc'; else $(CYGPATH_W) '$(srcdir)/Common/GC.cc'; fi`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo Common/$(DEPDIR)/driver_cfa_cpp-GC.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='Common/GC.cc' object='Common/driver_cfa_cpp-GC.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-GC.obj `if test -f 'Common/GC.cc'; then $(CYGPATH_W) 'Common/GC.cc'; else $(CYGPATH_W) '$(srcdir)/Common/GC.cc'; fi`
+
 Common/driver_cfa_cpp-Assert.o: Common/Assert.cc
 @am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc
@@ -2497,4 +2520,18 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
+
+SynTree/driver_cfa_cpp-GcTracer.o: SynTree/GcTracer.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-GcTracer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo -c -o SynTree/driver_cfa_cpp-GcTracer.o `test -f 'SynTree/GcTracer.cc' || echo '$(srcdir)/'`SynTree/GcTracer.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SynTree/GcTracer.cc' object='SynTree/driver_cfa_cpp-GcTracer.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-GcTracer.o `test -f 'SynTree/GcTracer.cc' || echo '$(srcdir)/'`SynTree/GcTracer.cc
+
+SynTree/driver_cfa_cpp-GcTracer.obj: SynTree/GcTracer.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-GcTracer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo -c -o SynTree/driver_cfa_cpp-GcTracer.obj `if test -f 'SynTree/GcTracer.cc'; then $(CYGPATH_W) 'SynTree/GcTracer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/GcTracer.cc'; fi`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SynTree/GcTracer.cc' object='SynTree/driver_cfa_cpp-GcTracer.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-GcTracer.obj `if test -f 'SynTree/GcTracer.cc'; then $(CYGPATH_W) 'SynTree/GcTracer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/GcTracer.cc'; fi`
 
 SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Parser/DeclarationNode.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -986,5 +986,4 @@
 					obj->location = cur->location;
 					* out++ = obj;
-					delete agg;
 				} else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
 					UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Parser/ExpressionNode.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -427,5 +427,4 @@
 	Type * targetType = maybeMoveBuildType( decl_node );
 	if ( dynamic_cast< VoidType * >( targetType ) ) {
-		delete targetType;
 		return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
 	} else {
@@ -451,7 +450,5 @@
 
 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
-	Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
-	delete member;
-	return ret;
+	return new UntypedOffsetofExpr{ maybeMoveBuildType( decl_node ), member->get_name() };
 } // build_offsetOf
 
Index: src/ResolvExpr/AdjustExprType.cc
===================================================================
--- src/ResolvExpr/AdjustExprType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/AdjustExprType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -66,12 +66,9 @@
 
 	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 };
 	}
 
 	Type * AdjustExprType::postmutate( FunctionType * functionType ) {
-		return new PointerType( Type::Qualifiers(), functionType );
+		return new PointerType{ Type::Qualifiers(), functionType };
 	}
 
@@ -80,12 +77,10 @@
 		if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
 			if ( eqvClass.data.kind == TypeDecl::Ftype ) {
-				PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
-				return pointerType;
+				return new PointerType{ Type::Qualifiers(), typeInst };
 			}
 		} else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
 			if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
 				if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
-					PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
-					return pointerType;
+					return new PointerType{ Type::Qualifiers(), typeInst };
 				} // if
 			} // if
Index: src/ResolvExpr/Alternative.cc
===================================================================
--- src/ResolvExpr/Alternative.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/Alternative.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -34,36 +34,4 @@
 	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;
-		return *this;
-	}
-
-	Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( 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 = other.env;
-		other.expr = nullptr;
-		return *this;
-	}
-
-	Alternative::~Alternative() {
-		delete expr;
-	}
 
 	void Alternative::print( std::ostream &os, Indenter indent ) const {
Index: src/ResolvExpr/Alternative.h
===================================================================
--- src/ResolvExpr/Alternative.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/Alternative.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -29,22 +29,12 @@
 		Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost );
 		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( const Alternative &other ) = default;
+		Alternative &operator=( const 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;
 	};
Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -165,5 +165,4 @@
 					candidate->env.apply( newType );
 					mangleName = SymTab::Mangler::mangle( newType );
-					delete newType;
 				}
 				std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
@@ -568,5 +567,4 @@
 
 				Expression *varExpr = data.combine( newerAlt.cvtCost );
-				delete varExpr->get_result();
 				varExpr->set_result( adjType->clone() );
 				PRINT(
@@ -585,6 +583,4 @@
 				(*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
 				inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
-			} else {
-				delete adjType;
 			}
 		}
@@ -1264,5 +1260,4 @@
 				componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
 			}
-			delete argExpr;
 			assert( componentExprs.size() > 0 );
 			// produce the tuple of casts
@@ -1600,5 +1595,4 @@
 			alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
 		} // for
-		delete newFirstArg;
 	}
 
Index: src/ResolvExpr/ResolveTypeof.cc
===================================================================
--- src/ResolvExpr/ResolveTypeof.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -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 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/Resolver.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -138,5 +138,4 @@
 					castExpr->arg = nullptr;
 					std::swap( expr->env, castExpr->env );
-					delete castExpr;
 				}
 			}
@@ -198,5 +197,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;
@@ -244,5 +242,4 @@
 		Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
 		finishExpr( newExpr, env, untyped->env );
-		delete untyped;
 		untyped = newExpr;
 	}
@@ -418,5 +415,4 @@
 			caseStmt->condition = castExpr->arg;
 			castExpr->arg = nullptr;
-			delete castExpr;
 		}
 	}
@@ -700,5 +696,4 @@
 		std::swap( initExpr->env, newExpr->env );
 		std::swap( initExpr->inferParams, newExpr->inferParams ) ;
-		delete initExpr;
 
 		// get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
@@ -718,5 +713,4 @@
 							ce->set_arg( nullptr );
 							std::swap( ce->env, newExpr->env );
-							delete ce;
 						}
 					}
@@ -769,8 +763,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 );
 	}
@@ -798,5 +790,4 @@
 
 		// found a constructor - can get rid of C-style initializer
-		delete ctorInit->init;
 		ctorInit->init = nullptr;
 
@@ -805,10 +796,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 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/TypeEnvironment.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -59,11 +59,6 @@
 	EqvClass &EqvClass::operator=( const EqvClass &other ) {
 		if ( this == &other ) return *this;
-		delete type;
 		initialize( other, *this );
 		return *this;
-	}
-
-	EqvClass::~EqvClass() {
-		delete type;
 	}
 
@@ -147,5 +142,4 @@
 ///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
 					sub.add( *theVar, newTypeInst );
-					delete newTypeInst;
 				} // if
 			} // for
@@ -188,7 +182,5 @@
 					if ( secondClass->type ) {
 						if ( newClass.type ) {
-							Type *newType = combineFunc( newClass.type, secondClass->type );
-							delete newClass.type;
-							newClass.type = newType;
+							newClass.type = combineFunc( newClass.type, secondClass->type );
 							newClass.allowWidening = newClass.allowWidening && secondClass->allowWidening;
 						} else {
Index: src/ResolvExpr/TypeEnvironment.h
===================================================================
--- src/ResolvExpr/TypeEnvironment.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/TypeEnvironment.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -67,5 +67,4 @@
 		EqvClass( const EqvClass &other );
 		EqvClass &operator=( const EqvClass &other );
-		~EqvClass();
 		void print( std::ostream &os, Indenter indent = {} ) const;
 	};
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/Unify.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -99,8 +99,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 +120,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 );
 	}
 
@@ -176,5 +170,4 @@
 					if ( common ) {
 						common->get_qualifiers() = Type::Qualifiers();
-						delete curClass.type;
 						curClass.type = common;
 						env.add( curClass );
@@ -239,5 +232,4 @@
 				if ( common ) {
 					common->get_qualifiers() = Type::Qualifiers();
-					delete class1.type;
 					class1.type = common;
 				} // if
@@ -272,6 +264,4 @@
 			env.add( newClass );
 		} // if
-		delete type1;
-		delete type2;
 		return result;
 	}
@@ -282,12 +272,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 );
 	}
 
@@ -544,5 +527,4 @@
 					// expand ttype parameter into its actual type
 					if ( eqvClass.type ) {
-						delete typeInst;
 						return eqvClass.type->clone();
 					}
@@ -569,5 +551,4 @@
 				dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
 			}
-			delete dcl;
 		}
 	}
Index: src/ResolvExpr/Unify.h
===================================================================
--- src/ResolvExpr/Unify.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/ResolvExpr/Unify.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -64,10 +64,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 );
 	}
 
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SymTab/Autogen.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -214,5 +214,4 @@
 	void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
 		FunctionDecl * decl = functionDecl->clone();
-		delete decl->statements;
 		decl->statements = nullptr;
 		declsToAdd.push_back( decl );
@@ -333,5 +332,4 @@
 		} catch ( SemanticErrorException err ) {
 			// okay if decl does not resolve - that means the function should not be generated
-			delete dcl;
 		}
 	}
@@ -373,5 +371,4 @@
 			// do not carry over field's attributes to parameter type
 			Type * paramType = field->get_type()->clone();
-			deleteAll( paramType->attributes );
 			paramType->attributes.clear();
 			// add a parameter corresponding to this field
@@ -383,5 +380,4 @@
 			resolve( ctor );
 		}
-		delete memCtorType;
 	}
 
@@ -511,5 +507,4 @@
 			// do not carry over field's attributes to parameter type
 			Type * paramType = field->get_type()->clone();
-			deleteAll( paramType->attributes );
 			paramType->attributes.clear();
 			// add a parameter corresponding to this field
@@ -524,5 +519,4 @@
 			break;
 		}
-		delete memCtorType;
 	}
 
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SymTab/Autogen.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -97,5 +97,4 @@
 		// return if adding reference fails - will happen on default constructor and destructor
 		if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
-			delete fExpr;
 			return listInit;
 		}
Index: src/SymTab/FixFunction.cc
===================================================================
--- src/SymTab/FixFunction.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SymTab/FixFunction.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -28,10 +28,8 @@
 
 	DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
-		// can't delete function type because it may contain assertions, so transfer ownership to new object
-		ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
-		functionDecl->attributes.clear();
-		functionDecl->type = nullptr;
-		delete functionDecl;
-		return pointer;
+		return new ObjectDecl{ 
+			functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, 
+			new PointerType{ Type::Qualifiers(), functionDecl->type }, 
+			nullptr, functionDecl->attributes };
 	}
 
@@ -42,9 +40,5 @@
 	Type * FixFunction::postmutate(ArrayType *arrayType) {
 		// need to recursively mutate the base type in order for multi-dimensional arrays to work.
-		PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
-		arrayType->base = nullptr;
-		arrayType->dimension = nullptr;
-		delete arrayType;
-		return pointerType;
+		return new PointerType{ arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic };
 	}
 
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SymTab/Validate.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -310,5 +310,5 @@
 		} // if
 		// Always remove the hoisted aggregate from the inner structure.
-		GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
+		GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion ); } );
 	}
 
@@ -365,5 +365,4 @@
 			// one void is the only thing in the list; remove it.
 			if ( containsVoid ) {
-				delete dwts.front();
 				dwts.clear();
 			}
@@ -492,5 +491,4 @@
 				}
 			}
-			deleteAll( td->assertions );
 			td->assertions.clear();
 		} // for
@@ -608,5 +606,4 @@
 					// expand trait instance into all of its members
 					expandAssertions( traitInst, back_inserter( type->assertions ) );
-					delete traitInst;
 				} else {
 					// pass other assertions through
@@ -682,5 +679,5 @@
 			SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
 		}
-		filter( translationUnit, isTypedef, true );
+		filter( translationUnit, isTypedef );
 	}
 
@@ -696,5 +693,4 @@
 				ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
 			} else {
-				deleteAll( ret->attributes );
 				ret->attributes.clear();
 			}
@@ -709,5 +705,4 @@
 				mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
 			} // if
-			delete typeInst;
 			return ret;
 		} else {
@@ -795,9 +790,7 @@
 		if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
 			// replace the current object declaration with a function declaration
-			FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
-			objDecl->get_attributes().clear();
-			objDecl->set_type( nullptr );
-			delete objDecl;
-			return newDecl;
+			return new FunctionDecl{ 
+				objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), 
+				funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() };
 		} // if
 		return objDecl;
@@ -823,5 +816,5 @@
 			} // if
 			return false;
-		}, true);
+		} );
 		return compoundStmt;
 	}
@@ -831,5 +824,5 @@
 	template<typename AggDecl>
 	AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
-		filter( aggDecl->members, isTypedef, true );
+		filter( aggDecl->members, isTypedef );
 		return aggDecl;
 	}
@@ -961,8 +954,6 @@
 		static UniqueName indexName( "_compLit" );
 
-		ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
-		compLitExpr->set_result( nullptr );
-		compLitExpr->set_initializer( nullptr );
-		delete compLitExpr;
+		ObjectDecl * tempvar = new ObjectDecl{ 
+			indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() };
 		declsToAddBefore.push_back( tempvar );					// add modified temporary to current block
 		return new VariableExpr( tempvar );
@@ -1000,5 +991,4 @@
 			// ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
 			ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
-			deleteAll( retVals );
 			retVals.clear();
 			retVals.push_back( newRet );
@@ -1041,7 +1031,5 @@
 			if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( inner->arg ) ) {
 				if ( labels.count( nameExpr->name ) ) {
-					Label name = nameExpr->name;
-					delete addrExpr;
-					return new LabelAddressExpr( name );
+					return new LabelAddressExpr{ nameExpr->name };
 				}
 			}
Index: src/SynTree/AddressExpr.cc
===================================================================
--- src/SynTree/AddressExpr.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/AddressExpr.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -58,8 +58,4 @@
 }
 
-AddressExpr::~AddressExpr() {
-	delete arg;
-}
-
 void AddressExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Address of:" << std::endl;
@@ -75,5 +71,4 @@
 }
 LabelAddressExpr::LabelAddressExpr( const LabelAddressExpr & other ) : Expression( other ), arg( other.arg ) {}
-LabelAddressExpr::~LabelAddressExpr() {}
 
 void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
Index: src/SynTree/AggregateDecl.cc
===================================================================
--- src/SynTree/AggregateDecl.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/AggregateDecl.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -33,10 +33,4 @@
 	cloneAll( other.attributes, attributes );
 	body = other.body;
-}
-
-AggregateDecl::~AggregateDecl() {
-	deleteAll( attributes );
-	deleteAll( parameters );
-	deleteAll( members );
 }
 
Index: src/SynTree/ApplicationExpr.cc
===================================================================
--- src/SynTree/ApplicationExpr.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/ApplicationExpr.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -43,10 +43,4 @@
 }
 
-ParamEntry::~ParamEntry() {
-	delete actualType;
-	delete formalType;
-	delete expr;
-}
-
 ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
 	PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );
@@ -61,9 +55,4 @@
 		Expression( other ), function( maybeClone( other.function ) ) {
 	cloneAll( other.args, args );
-}
-
-ApplicationExpr::~ApplicationExpr() {
-	delete function;
-	deleteAll( args );
 }
 
Index: src/SynTree/ArrayType.cc
===================================================================
--- src/SynTree/ArrayType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/ArrayType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -34,9 +34,4 @@
 }
 
-ArrayType::~ArrayType() {
-	delete base;
-	delete dimension;
-}
-
 void ArrayType::print( std::ostream &os, Indenter indent ) const {
 	Type::print( os, indent );
Index: src/SynTree/AttrType.cc
===================================================================
--- src/SynTree/AttrType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/AttrType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -37,9 +37,4 @@
 }
 
-AttrType::~AttrType() {
-	delete expr;
-	delete type;
-}
-
 void AttrType::print( std::ostream &os, Indenter indent ) const {
 	Type::print( os, indent );
Index: src/SynTree/Attribute.cc
===================================================================
--- src/SynTree/Attribute.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Attribute.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -23,8 +23,4 @@
 Attribute::Attribute( const Attribute &other ) : name( other.name ) {
 	cloneAll( other.parameters, parameters );
-}
-
-Attribute::~Attribute() {
-	deleteAll( parameters );
 }
 
Index: src/SynTree/Attribute.h
===================================================================
--- src/SynTree/Attribute.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Attribute.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -36,5 +36,4 @@
 	Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {}
 	Attribute( const Attribute &other );
-	virtual ~Attribute();
 
 	std::string get_name() const { return name; }
Index: src/SynTree/BaseSyntaxNode.h
===================================================================
--- src/SynTree/BaseSyntaxNode.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/BaseSyntaxNode.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -17,13 +17,13 @@
 
 #include "Common/CodeLocation.h"
+#include "Common/GC.h"
 #include "Common/Indenter.h"
+
 class Visitor;
 class Mutator;
 
-class BaseSyntaxNode {
-  public:
+class BaseSyntaxNode : GC_Object {
+public:
 	CodeLocation location;
-
-	virtual ~BaseSyntaxNode() {}
 
 	virtual BaseSyntaxNode * clone() const = 0;
Index: src/SynTree/CommaExpr.cc
===================================================================
--- src/SynTree/CommaExpr.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/CommaExpr.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -34,9 +34,4 @@
 }
 
-CommaExpr::~CommaExpr() {
-	delete arg1;
-	delete arg2;
-}
-
 void CommaExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Comma Expression:" << std::endl;
Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/CompoundStmt.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -68,8 +68,4 @@
 }
 
-CompoundStmt::~CompoundStmt() {
-	deleteAll( kids );
-}
-
 void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "CompoundStmt" << endl;
Index: src/SynTree/Constant.cc
===================================================================
--- src/SynTree/Constant.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Constant.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -27,6 +27,4 @@
 	type = other.type->clone();
 }
-
-Constant::~Constant() { delete type; }
 
 Constant Constant::from_bool( bool b ) {
Index: src/SynTree/Constant.h
===================================================================
--- src/SynTree/Constant.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Constant.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -30,6 +30,5 @@
 	Constant( Type * type, std::string rep, double val );
 	Constant( const Constant & other );
-	virtual ~Constant();
-
+	
 	virtual Constant * clone() const { return new Constant( *this ); }
 
Index: src/SynTree/DeclStmt.cc
===================================================================
--- src/SynTree/DeclStmt.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/DeclStmt.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -29,8 +29,4 @@
 }
 
-DeclStmt::~DeclStmt() {
-	delete decl;
-}
-
 void DeclStmt::print( std::ostream &os, Indenter indent ) const {
 	assert( decl != 0 );
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Declaration.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -38,7 +38,4 @@
 }
 
-Declaration::~Declaration() {
-}
-
 void Declaration::fixUniqueId() {
 	// don't need to set unique ID twice
@@ -68,8 +65,4 @@
 }
 
-AsmDecl::~AsmDecl() {
-	delete stmt;
-}
-
 void AsmDecl::print( std::ostream &os, Indenter indent ) const {
 	stmt->print( os, indent );
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Declaration.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -45,5 +45,4 @@
 	Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
 	Declaration( const Declaration &other );
-	virtual ~Declaration();
 
 	const std::string &get_name() const { return name; }
@@ -87,6 +86,5 @@
 	DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
 	DeclarationWithType( const DeclarationWithType &other );
-	virtual ~DeclarationWithType();
-
+	
 	std::string get_mangleName() const { return mangleName; }
 	DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
@@ -126,5 +124,4 @@
 				const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 	ObjectDecl( const ObjectDecl &other );
-	virtual ~ObjectDecl();
 
 	virtual Type * get_type() const override { return type; }
@@ -156,5 +153,4 @@
 				  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 	FunctionDecl( const FunctionDecl &other );
-	virtual ~FunctionDecl();
 
 	virtual Type * get_type() const override { return type; }
@@ -184,5 +180,4 @@
 	NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
 	NamedTypeDecl( const NamedTypeDecl &other );
-	virtual ~NamedTypeDecl();
 
 	Type *get_base() const { return base; }
@@ -219,5 +214,4 @@
 	TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
 	TypeDecl( const TypeDecl &other );
-	virtual ~TypeDecl();
 
 	Kind get_kind() const { return kind; }
@@ -268,6 +262,5 @@
 	AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
 	AggregateDecl( const AggregateDecl &other );
-	virtual ~AggregateDecl();
-
+	
 	std::list<Declaration*>& get_members() { return members; }
 	std::list<TypeDecl*>& get_parameters() { return parameters; }
@@ -353,5 +346,4 @@
 	AsmDecl( AsmStmt *stmt );
 	AsmDecl( const AsmDecl &other );
-	virtual ~AsmDecl();
 
 	AsmStmt *get_stmt() { return stmt; }
Index: src/SynTree/DeclarationWithType.cc
===================================================================
--- src/SynTree/DeclarationWithType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/DeclarationWithType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -34,9 +34,4 @@
 }
 
-DeclarationWithType::~DeclarationWithType() {
-	deleteAll( attributes );
-	delete asmName;
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Expression.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -52,5 +52,4 @@
 Expression::~Expression() {
 	delete env;
-	delete result;
 }
 
@@ -74,6 +73,4 @@
 ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
 }
-
-ConstantExpr::~ConstantExpr() {}
 
 void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
@@ -120,8 +117,4 @@
 }
 
-VariableExpr::~VariableExpr() {
-	// don't delete the declaration, since it points somewhere else in the tree
-}
-
 VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
 	VariableExpr * funcExpr = new VariableExpr( func );
@@ -150,9 +143,4 @@
 }
 
-SizeofExpr::~SizeofExpr() {
-	delete expr;
-	delete type;
-}
-
 void SizeofExpr::print( std::ostream &os, Indenter indent) const {
 	os << "Sizeof Expression on: ";
@@ -176,9 +164,4 @@
 }
 
-AlignofExpr::~AlignofExpr() {
-	delete expr;
-	delete type;
-}
-
 void AlignofExpr::print( std::ostream &os, Indenter indent) const {
 	os << "Alignof Expression on: ";
@@ -196,8 +179,4 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
 	Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
-
-UntypedOffsetofExpr::~UntypedOffsetofExpr() {
-	delete type;
-}
 
 void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
@@ -217,8 +196,4 @@
 	Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
-OffsetofExpr::~OffsetofExpr() {
-	delete type;
-}
-
 void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
 	os << "Offsetof Expression on member " << member->name << " of ";
@@ -234,6 +209,4 @@
 OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 
-OffsetPackExpr::~OffsetPackExpr() { delete type; }
-
 void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Offset pack expression on ";
@@ -252,10 +225,4 @@
 AttrExpr::AttrExpr( const AttrExpr &other ) :
 		Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
-}
-
-AttrExpr::~AttrExpr() {
-	delete attr;
-	delete expr;
-	delete type;
 }
 
@@ -280,8 +247,4 @@
 
 CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
-}
-
-CastExpr::~CastExpr() {
-	delete arg;
 }
 
@@ -306,8 +269,4 @@
 }
 
-VirtualCastExpr::~VirtualCastExpr() {
-	delete arg;
-}
-
 void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Virtual Cast of:" << std::endl << indent+1;
@@ -332,9 +291,4 @@
 }
 
-UntypedMemberExpr::~UntypedMemberExpr() {
-	delete aggregate;
-	delete member;
-}
-
 void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Untyped Member Expression, with field: " << std::endl << indent+1;
@@ -363,9 +317,4 @@
 }
 
-MemberExpr::~MemberExpr() {
-	// don't delete the member declaration, since it points somewhere else in the tree
-	delete aggregate;
-}
-
 void MemberExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Member Expression, with field: " << std::endl;
@@ -383,9 +332,4 @@
 		Expression( other ), function( maybeClone( other.function ) ) {
 	cloneAll( other.args, args );
-}
-
-UntypedExpr::~UntypedExpr() {
-	delete function;
-	deleteAll( args );
 }
 
@@ -436,6 +380,4 @@
 }
 
-NameExpr::~NameExpr() {}
-
 void NameExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Name: " << get_name();
@@ -450,9 +392,4 @@
 LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
 		Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
-}
-
-LogicalExpr::~LogicalExpr() {
-	delete arg1;
-	delete arg2;
 }
 
@@ -470,10 +407,4 @@
 ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
 		Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
-}
-
-ConditionalExpr::~ConditionalExpr() {
-	delete arg1;
-	delete arg2;
-	delete arg3;
 }
 
@@ -513,8 +444,4 @@
 ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() {
 	set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
-	delete callExpr;
-	deleteAll( tempDecls );
-	deleteAll( returnDecls );
-	deleteAll( dtors );
 }
 
@@ -541,8 +468,4 @@
 }
 
-ConstructorExpr::~ConstructorExpr() {
-	delete callExpr;
-}
-
 void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
 	os <<  "Constructor Expression: " << std::endl << indent+1;
@@ -559,8 +482,4 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
-
-CompoundLiteralExpr::~CompoundLiteralExpr() {
-	delete initializer;
-}
 
 void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
@@ -589,13 +508,7 @@
 	cloneAll( other.dtors, dtors );
 }
-StmtExpr::~StmtExpr() {
-	delete statements;
-	deleteAll( dtors );
-	deleteAll( returnDecls );
-}
 void StmtExpr::computeResult() {
 	assert( statements );
 	std::list< Statement * > & body = statements->kids;
-	delete result;
 	result = nullptr;
 	if ( ! returnDecls.empty() ) {
@@ -640,9 +553,5 @@
 UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
-UniqueExpr::~UniqueExpr() {
-	delete expr;
-	delete object;
-	delete var;
-}
+
 void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Unique Expression with id:" << id << std::endl << indent+1;
@@ -657,14 +566,7 @@
 InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
 InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
-InitAlternative::~InitAlternative() {
-	delete type;
-	delete designation;
-}
 
 UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
 UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
-UntypedInitExpr::~UntypedInitExpr() {
-	delete expr;
-}
 
 void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
@@ -684,8 +586,4 @@
 }
 InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
-InitExpr::~InitExpr() {
-	delete expr;
-	delete designation;
-}
 
 void InitExpr::print( std::ostream & os, Indenter indent ) const {
@@ -701,7 +599,4 @@
 }
 DeletedExpr::DeletedExpr( const DeletedExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), deleteStmt( other.deleteStmt ) {}
-DeletedExpr::~DeletedExpr() {
-	delete expr;
-}
 
 void DeletedExpr::print( std::ostream & os, Indenter indent ) const {
Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Expression.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -41,5 +41,4 @@
 	ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
 	ParamEntry( const ParamEntry & other );
-	~ParamEntry();
 	ParamEntry & operator=( const ParamEntry & other );
 
@@ -53,4 +52,7 @@
 /// Expression is the root type for all expressions
 class Expression : public BaseSyntaxNode {
+  protected:
+	virtual ~Expression();
+
   public:
 	Type * result;
@@ -61,5 +63,4 @@
 	Expression();
 	Expression( const Expression & other );
-	virtual ~Expression();
 
 	Type *& get_result() { return result; }
@@ -89,5 +90,4 @@
 	ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
 	ApplicationExpr( const ApplicationExpr & other );
-	virtual ~ApplicationExpr();
 
 	Expression * get_function() const { return function; }
@@ -111,5 +111,4 @@
 	UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
 	UntypedExpr( const UntypedExpr & other );
-	virtual ~UntypedExpr();
 
 	Expression * get_function() const { return function; }
@@ -136,5 +135,4 @@
 	NameExpr( std::string name );
 	NameExpr( const NameExpr & other );
-	virtual ~NameExpr();
 
 	const std::string & get_name() const { return name; }
@@ -157,5 +155,4 @@
 	AddressExpr( Expression * arg );
 	AddressExpr( const AddressExpr & other );
-	virtual ~AddressExpr();
 
 	Expression * get_arg() const { return arg; }
@@ -176,5 +173,4 @@
 	LabelAddressExpr( const Label &arg );
 	LabelAddressExpr( const LabelAddressExpr & other );
-	virtual ~LabelAddressExpr();
 
 	virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
@@ -192,5 +188,4 @@
 	CastExpr( Expression * arg, Type * toType );
 	CastExpr( const CastExpr & other );
-	virtual ~CastExpr();
 
 	Expression * get_arg() const { return arg; }
@@ -210,5 +205,4 @@
 	VirtualCastExpr( Expression * arg, Type * toType );
 	VirtualCastExpr( const VirtualCastExpr & other );
-	virtual ~VirtualCastExpr();
 
 	Expression * get_arg() const { return arg; }
@@ -229,5 +223,4 @@
 	UntypedMemberExpr( Expression * member, Expression * aggregate );
 	UntypedMemberExpr( const UntypedMemberExpr & other );
-	virtual ~UntypedMemberExpr();
 
 	Expression * get_member() const { return member; }
@@ -251,5 +244,4 @@
 	MemberExpr( DeclarationWithType * member, Expression * aggregate );
 	MemberExpr( const MemberExpr & other );
-	virtual ~MemberExpr();
 
 	DeclarationWithType * get_member() const { return member; }
@@ -272,5 +264,4 @@
 	VariableExpr( DeclarationWithType * var );
 	VariableExpr( const VariableExpr & other );
-	virtual ~VariableExpr();
 
 	DeclarationWithType * get_var() const { return var; }
@@ -292,5 +283,4 @@
 	ConstantExpr( Constant constant );
 	ConstantExpr( const ConstantExpr & other );
-	virtual ~ConstantExpr();
 
 	Constant * get_constant() { return & constant; }
@@ -316,5 +306,4 @@
 	SizeofExpr( const SizeofExpr & other );
 	SizeofExpr( Type * type );
-	virtual ~SizeofExpr();
 
 	Expression * get_expr() const { return expr; }
@@ -341,5 +330,4 @@
 	AlignofExpr( const AlignofExpr & other );
 	AlignofExpr( Type * type );
-	virtual ~AlignofExpr();
 
 	Expression * get_expr() const { return expr; }
@@ -364,5 +352,4 @@
 	UntypedOffsetofExpr( Type * type, const std::string & member );
 	UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
-	virtual ~UntypedOffsetofExpr();
 
 	std::string get_member() const { return member; }
@@ -385,5 +372,4 @@
 	OffsetofExpr( Type * type, DeclarationWithType * member );
 	OffsetofExpr( const OffsetofExpr & other );
-	virtual ~OffsetofExpr();
 
 	Type * get_type() const { return type; }
@@ -405,5 +391,4 @@
 	OffsetPackExpr( StructInstType * type );
 	OffsetPackExpr( const OffsetPackExpr & other );
-	virtual ~OffsetPackExpr();
 
 	StructInstType * get_type() const { return type; }
@@ -427,5 +412,4 @@
 	AttrExpr( const AttrExpr & other );
 	AttrExpr( Expression * attr, Type * type );
-	virtual ~AttrExpr();
 
 	Expression * get_attr() const { return attr; }
@@ -452,5 +436,4 @@
 	LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
 	LogicalExpr( const LogicalExpr & other );
-	virtual ~LogicalExpr();
 
 	bool get_isAnd() const { return isAnd; }
@@ -478,5 +461,4 @@
 	ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
 	ConditionalExpr( const ConditionalExpr & other );
-	virtual ~ConditionalExpr();
 
 	Expression * get_arg1() const { return arg1; }
@@ -501,5 +483,4 @@
 	CommaExpr( Expression * arg1, Expression * arg2 );
 	CommaExpr( const CommaExpr & other );
-	virtual ~CommaExpr();
 
 	Expression * get_arg1() const { return arg1; }
@@ -521,5 +502,4 @@
 	TypeExpr( Type * type );
 	TypeExpr( const TypeExpr & other );
-	virtual ~TypeExpr();
 
 	Type * get_type() const { return type; }
@@ -541,5 +521,4 @@
 	AsmExpr( Expression * inout, Expression * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
 	AsmExpr( const AsmExpr & other );
-	virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
 
 	Expression * get_inout() const { return inout; }
@@ -563,4 +542,7 @@
 /// along with a set of copy constructor calls, one for each argument.
 class ImplicitCopyCtorExpr : public Expression {
+protected:
+	virtual ~ImplicitCopyCtorExpr();
+
 public:
 	ApplicationExpr * callExpr;
@@ -571,5 +553,4 @@
 	ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
 	ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
-	virtual ~ImplicitCopyCtorExpr();
 
 	ApplicationExpr * get_callExpr() const { return callExpr; }
@@ -593,5 +574,4 @@
 	ConstructorExpr( Expression * callExpr );
 	ConstructorExpr( const ConstructorExpr & other );
-	~ConstructorExpr();
 
 	Expression * get_callExpr() const { return callExpr; }
@@ -611,5 +591,4 @@
 	CompoundLiteralExpr( Type * type, Initializer * initializer );
 	CompoundLiteralExpr( const CompoundLiteralExpr & other );
-	virtual ~CompoundLiteralExpr();
 
 	Initializer * get_initializer() const { return initializer; }
@@ -648,5 +627,4 @@
 	UntypedTupleExpr( const std::list< Expression * > & exprs );
 	UntypedTupleExpr( const UntypedTupleExpr & other );
-	virtual ~UntypedTupleExpr();
 
 	std::list<Expression*>& get_exprs() { return exprs; }
@@ -665,5 +643,4 @@
 	TupleExpr( const std::list< Expression * > & exprs );
 	TupleExpr( const TupleExpr & other );
-	virtual ~TupleExpr();
 
 	std::list<Expression*>& get_exprs() { return exprs; }
@@ -683,5 +660,4 @@
 	TupleIndexExpr( Expression * tuple, unsigned int index );
 	TupleIndexExpr( const TupleIndexExpr & other );
-	virtual ~TupleIndexExpr();
 
 	Expression * get_tuple() const { return tuple; }
@@ -703,5 +679,4 @@
 	TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
 	TupleAssignExpr( const TupleAssignExpr & other );
-	virtual ~TupleAssignExpr();
 
 	TupleAssignExpr * set_stmtExpr( StmtExpr * newValue ) { stmtExpr = newValue; return this; }
@@ -723,5 +698,4 @@
 	StmtExpr( CompoundStmt * statements );
 	StmtExpr( const StmtExpr & other );
-	virtual ~StmtExpr();
 
 	CompoundStmt * get_statements() const { return statements; }
@@ -748,5 +722,4 @@
 	UniqueExpr( Expression * expr, long long idVal = -1 );
 	UniqueExpr( const UniqueExpr & other );
-	~UniqueExpr();
 
 	Expression * get_expr() const { return expr; }
@@ -778,5 +751,4 @@
 	InitAlternative( const InitAlternative & other );
 	InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
-	~InitAlternative();
 };
 
@@ -788,5 +760,4 @@
 	UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
 	UntypedInitExpr( const UntypedInitExpr & other );
-	~UntypedInitExpr();
 
 	Expression * get_expr() const { return expr; }
@@ -808,5 +779,4 @@
 	InitExpr( Expression * expr, Designation * designation );
 	InitExpr( const InitExpr & other );
-	~InitExpr();
 
 	Expression * get_expr() const { return expr; }
@@ -830,5 +800,4 @@
 	DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt );
 	DeletedExpr( const DeletedExpr & other );
-	~DeletedExpr();
 
 	virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
Index: src/SynTree/FunctionDecl.cc
===================================================================
--- src/SynTree/FunctionDecl.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/FunctionDecl.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -52,10 +52,4 @@
 	}
 	cloneAll( other.withExprs, withExprs );
-}
-
-FunctionDecl::~FunctionDecl() {
-	delete type;
-	delete statements;
-	deleteAll( withExprs );
 }
 
Index: src/SynTree/FunctionType.cc
===================================================================
--- src/SynTree/FunctionType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/FunctionType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -31,9 +31,4 @@
 	cloneAll( other.returnVals, returnVals );
 	cloneAll( other.parameters, parameters );
-}
-
-FunctionType::~FunctionType() {
-	deleteAll( returnVals );
-	deleteAll( parameters );
 }
 
Index: src/SynTree/GcTracer.cc
===================================================================
--- src/SynTree/GcTracer.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
+++ src/SynTree/GcTracer.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -0,0 +1,29 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// GcTracer.cc --
+//
+// Author           : Aaron B. Moss
+// Created On       : Thu Mar 15 14:47:00 2018
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Mar 15 14:47:00 2018
+// Update Count     : 1
+//
+
+#include "GcTracer.h"
+
+#include "Expression.h"
+#include "TypeSubstitution.h"
+
+void GcTracer::postvisit( Expression * expr ) {
+
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/GcTracer.h
===================================================================
--- src/SynTree/GcTracer.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
+++ src/SynTree/GcTracer.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -0,0 +1,62 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// GcTracer.h --
+//
+// Author           : Aaron B. Moss
+// Created On       : Thu Mar 15 14:47:00 2018
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Mar 15 14:47:00 2018
+// Update Count     : 1
+//
+
+#pragma once
+
+#include <list>
+
+#include "BaseSyntaxNode.h"
+#include "Expression.h"
+
+#include "Common/GC.h"
+#include "Common/PassVisitor.h"
+
+class Expression;
+
+/// Implements `trace` method for syntax nodes
+class GcTracer final : public WithShortCircuiting, public WithVisitorRef<GcTracer> {
+	const GC& gc;
+
+public:
+	GcTracer( const GC& gc ) : gc(gc) {}
+
+	void previsit( BaseSyntaxNode * node ) {
+		// skip tree if already seen
+		if ( node->mark == gc.mark ) {
+			visit_children = false;
+			return;
+		}
+
+		// mark node
+		node->mark = gc.mark;
+	}
+
+	void postvisit( Expression* expr ) {
+		maybeAccept( expr->env, *visitor );
+	}
+};
+
+/// Traces entire translation unit recursively
+static inline const GC& operator<< ( const GC& gc, const std::list<Declaration*>& translationUnit ) {
+	PassVisitor<GcTracer> tracer{ gc };
+	acceptAll( translationUnit, tracer );
+	return gc;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Initializer.cc
===================================================================
--- src/SynTree/Initializer.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Initializer.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -32,10 +32,4 @@
 }
 
-Designation::~Designation() {
-	// std::cerr << "destroying designation" << std::endl;
-	deleteAll( designators );
-	// std::cerr << "finished destroying designation" << std::endl;
-}
-
 void Designation::print( std::ostream &os, Indenter indent ) const {
 	if ( ! designators.empty() ) {
@@ -52,5 +46,4 @@
 Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
 }
-Initializer::~Initializer() {}
 
 SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
@@ -58,8 +51,4 @@
 
 SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
-}
-
-SingleInit::~SingleInit() {
-	delete value;
 }
 
@@ -87,9 +76,4 @@
 }
 
-ListInit::~ListInit() {
-	deleteAll( initializers );
-	deleteAll( designations );
-}
-
 void ListInit::print( std::ostream &os, Indenter indent ) const {
 	os << "Compound initializer: " << std::endl;
@@ -110,10 +94,4 @@
 ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
 ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ) {
-}
-
-ConstructorInit::~ConstructorInit() {
-	delete ctor;
-	delete dtor;
-	delete init;
 }
 
Index: src/SynTree/Initializer.h
===================================================================
--- src/SynTree/Initializer.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Initializer.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -33,5 +33,4 @@
 	Designation( const std::list< Expression * > & designators );
 	Designation( const Designation & other );
-	virtual ~Designation();
 
 	std::list< Expression * > & get_designators() { return designators; }
@@ -50,5 +49,4 @@
 	Initializer( bool maybeConstructed );
 	Initializer( const Initializer & other );
-	virtual ~Initializer();
 
 	bool get_maybeConstructed() { return maybeConstructed; }
@@ -70,5 +68,4 @@
 	SingleInit( Expression *value, bool maybeConstructed = false );
 	SingleInit( const SingleInit &other );
-	virtual ~SingleInit();
 
 	Expression *get_value() { return value; }
@@ -91,5 +88,4 @@
 			  const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
 	ListInit( const ListInit & other );
-	virtual ~ListInit();
 
 	std::list<Designation *> & get_designations() { return designations; }
@@ -123,5 +119,4 @@
 	ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
 	ConstructorInit( const ConstructorInit &other );
-	virtual ~ConstructorInit();
 
 	void set_ctor( Statement * newValue ) { ctor = newValue; }
Index: src/SynTree/NamedTypeDecl.cc
===================================================================
--- src/SynTree/NamedTypeDecl.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/NamedTypeDecl.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -30,10 +30,4 @@
 	cloneAll( other.parameters, parameters );
 	cloneAll( other.assertions, assertions );
-}
-
-NamedTypeDecl::~NamedTypeDecl() {
-	delete base;
-	deleteAll( parameters );
-	deleteAll( assertions );
 }
 
Index: src/SynTree/ObjectDecl.cc
===================================================================
--- src/SynTree/ObjectDecl.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/ObjectDecl.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -32,10 +32,4 @@
 ObjectDecl::ObjectDecl( const ObjectDecl &other )
 	: Parent( other ), type( maybeClone( other.type ) ), init( maybeClone( other.init ) ), bitfieldWidth( maybeClone( other.bitfieldWidth ) ) {
-}
-
-ObjectDecl::~ObjectDecl() {
-	delete type;
-	delete init;
-	delete bitfieldWidth;
 }
 
Index: src/SynTree/PointerType.cc
===================================================================
--- src/SynTree/PointerType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/PointerType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -36,9 +36,4 @@
 }
 
-PointerType::~PointerType() {
-	delete base;
-	delete dimension;
-}
-
 void PointerType::print( std::ostream &os, Indenter indent ) const {
 	Type::print( os, indent );
Index: src/SynTree/ReferenceToType.cc
===================================================================
--- src/SynTree/ReferenceToType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/ReferenceToType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -32,8 +32,4 @@
 ReferenceToType::ReferenceToType( const ReferenceToType &other ) : Type( other ), name( other.name ), hoistType( other.hoistType ) {
 	cloneAll( other.parameters, parameters );
-}
-
-ReferenceToType::~ReferenceToType() {
-	deleteAll( parameters );
 }
 
@@ -170,7 +166,4 @@
 }
 
-TraitInstType::~TraitInstType() {
-}
-
 bool TraitInstType::isComplete() const { assert( false ); }
 
@@ -183,9 +176,4 @@
 
 TypeInstType::TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {
-}
-
-
-TypeInstType::~TypeInstType() {
-	// delete baseType; //This is shared and should not be deleted
 }
 
Index: src/SynTree/ReferenceType.cc
===================================================================
--- src/SynTree/ReferenceType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/ReferenceType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -28,8 +28,4 @@
 }
 
-ReferenceType::~ReferenceType() {
-	delete base;
-}
-
 int ReferenceType::referenceDepth() const {
 	return base->referenceDepth()+1;
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Statement.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -44,13 +44,7 @@
 }
 
-Statement::~Statement() {}
-
 ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
-
-ExprStmt::~ExprStmt() {
-	delete expr;
-}
 
 void ExprStmt::print( std::ostream &os, Indenter indent ) const {
@@ -66,11 +60,4 @@
   cloneAll( other.input, input );
   cloneAll( other.clobber, clobber );
-}
-
-AsmStmt::~AsmStmt() {
-	delete instruction;
-	deleteAll( output );
-	deleteAll( input );
-	deleteAll( clobber );
 }
 
@@ -122,8 +109,4 @@
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
 
-ReturnStmt::~ReturnStmt() {
-	delete expr;
-}
-
 void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Return Statement, returning: ";
@@ -141,11 +124,4 @@
 	Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {
 	cloneAll( other.initialization, initialization );
-}
-
-IfStmt::~IfStmt() {
-	deleteAll( initialization );
-	delete condition;
-	delete thenPart;
-	delete elsePart;
 }
 
@@ -185,10 +161,4 @@
 }
 
-SwitchStmt::~SwitchStmt() {
-	delete condition;
-	// destroy statements
-	deleteAll( statements );
-}
-
 void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Switch on condition: ";
@@ -209,9 +179,4 @@
 	Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
 	cloneAll( other.stmts, stmts );
-}
-
-CaseStmt::~CaseStmt() {
-	delete condition;
-	deleteAll( stmts );
 }
 
@@ -243,9 +208,4 @@
 }
 
-WhileStmt::~WhileStmt() {
-	delete body;
-	delete condition;
-}
-
 void WhileStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "While on condition: " << endl ;
@@ -265,11 +225,4 @@
 		cloneAll( other.initialization, initialization );
 
-}
-
-ForStmt::~ForStmt() {
-	deleteAll( initialization );
-	delete condition;
-	delete increment;
-	delete body;
 }
 
@@ -311,9 +264,4 @@
 ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
 	Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
-}
-
-ThrowStmt::~ThrowStmt() {
-	delete expr;
-	delete target;
 }
 
@@ -336,10 +284,4 @@
 }
 
-TryStmt::~TryStmt() {
-	delete block;
-	deleteAll( handlers );
-	delete finallyBlock;
-}
-
 void TryStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Try Statement" << endl;
@@ -370,9 +312,4 @@
 }
 
-CatchStmt::~CatchStmt() {
-	delete decl;
-	delete body;
-}
-
 void CatchStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
@@ -397,8 +334,4 @@
 
 FinallyStmt::FinallyStmt( const FinallyStmt & other ) : Statement( other ), block( maybeClone( other.block ) ) {
-}
-
-FinallyStmt::~FinallyStmt() {
-	delete block;
 }
 
@@ -434,20 +367,4 @@
 }
 
-WaitForStmt::~WaitForStmt() {
-	for( auto & clause : clauses ) {
-		delete clause.target.function;
-		deleteAll( clause.target.arguments );
-		delete clause.statement;
-		delete clause.condition;
-	}
-
-	delete timeout.time;
-	delete timeout.statement;
-	delete timeout.condition;
-
-	delete orelse.statement;
-	delete orelse.condition;
-}
-
 void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Waitfor Statement" << endl;
@@ -460,8 +377,4 @@
 WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
 	cloneAll( other.exprs, exprs );
-}
-WithStmt::~WithStmt() {
-	deleteAll( exprs );
-	delete stmt;
 }
 
@@ -489,8 +402,4 @@
 }
 
-ImplicitCtorDtorStmt::~ImplicitCtorDtorStmt() {
-	delete callStmt;
-}
-
 void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
 	os << "Implicit Ctor Dtor Statement" << endl;
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Statement.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -38,5 +38,4 @@
 
 	Statement( const std::list<Label> & labels = {} );
-	virtual ~Statement();
 
 	std::list<Label> & get_labels() { return labels; }
@@ -56,5 +55,4 @@
 	CompoundStmt( std::list<Statement *> stmts );
 	CompoundStmt( const CompoundStmt &other );
-	virtual ~CompoundStmt();
 
 	std::list<Statement*>& get_kids() { return kids; }
@@ -84,5 +82,4 @@
 	ExprStmt( Expression *expr );
 	ExprStmt( const ExprStmt &other );
-	virtual ~ExprStmt();
 
 	Expression *get_expr() { return expr; }
@@ -105,5 +102,4 @@
 	AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
 	AsmStmt( const AsmStmt &other );
-	virtual ~AsmStmt();
 
 	bool get_voltile() { return voltile; }
@@ -136,5 +132,4 @@
 			std::list<Statement *> initialization = std::list<Statement *>() );
 	IfStmt( const IfStmt &other );
-	virtual ~IfStmt();
 
 	std::list<Statement *> &get_initialization() { return initialization; }
@@ -159,5 +154,4 @@
 	SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
 	SwitchStmt( const SwitchStmt &other );
-	virtual ~SwitchStmt();
 
 	Expression *get_condition() { return condition; }
@@ -181,5 +175,4 @@
 	CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
 	CaseStmt( const CaseStmt &other );
-	virtual ~CaseStmt();
 
 	static CaseStmt * makeDefault( const std::list<Label> & labels = {}, std::list<Statement *> stmts = std::list<Statement *>() );
@@ -212,5 +205,4 @@
 	       Statement *body, bool isDoWhile = false );
 	WhileStmt( const WhileStmt &other );
-	virtual ~WhileStmt();
 
 	Expression *get_condition() { return condition; }
@@ -237,5 +229,4 @@
 	     Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
 	ForStmt( const ForStmt &other );
-	virtual ~ForStmt();
 
 	std::list<Statement *> &get_initialization() { return initialization; }
@@ -290,5 +281,4 @@
 	ReturnStmt( Expression *expr );
 	ReturnStmt( const ReturnStmt &other );
-	virtual ~ReturnStmt();
 
 	Expression *get_expr() { return expr; }
@@ -311,5 +301,4 @@
 	ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
 	ThrowStmt( const ThrowStmt &other );
-	virtual ~ThrowStmt();
 
 	Kind get_kind() { return kind; }
@@ -333,5 +322,4 @@
 	TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
 	TryStmt( const TryStmt &other );
-	virtual ~TryStmt();
 
 	CompoundStmt *get_block() const { return block; }
@@ -360,5 +348,4 @@
 	           Expression *cond, Statement *body );
 	CatchStmt( const CatchStmt &other );
-	virtual ~CatchStmt();
 
 	Kind get_kind() { return kind; }
@@ -382,5 +369,4 @@
 	FinallyStmt( CompoundStmt *block );
 	FinallyStmt( const FinallyStmt &other );
-	virtual ~FinallyStmt();
 
 	CompoundStmt *get_block() const { return block; }
@@ -409,5 +395,4 @@
 	WaitForStmt();
 	WaitForStmt( const WaitForStmt & );
-	virtual ~WaitForStmt();
 
 	std::vector<Clause> clauses;
@@ -438,5 +423,4 @@
 	WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
 	WithStmt( const WithStmt & other );
-	virtual ~WithStmt();
 
 	virtual WithStmt * clone() const override { return new WithStmt( *this ); }
@@ -454,5 +438,4 @@
 	DeclStmt( Declaration *decl );
 	DeclStmt( const DeclStmt &other );
-	virtual ~DeclStmt();
 
 	Declaration *get_decl() const { return decl; }
@@ -476,5 +459,4 @@
 	ImplicitCtorDtorStmt( Statement * callStmt );
 	ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
-	virtual ~ImplicitCtorDtorStmt();
 
 	Statement *get_callStmt() const { return callStmt; }
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TupleExpr.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -35,8 +35,4 @@
 }
 
-UntypedTupleExpr::~UntypedTupleExpr() {
-	deleteAll( exprs );
-}
-
 void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Untyped Tuple:" << std::endl;
@@ -51,8 +47,4 @@
 TupleExpr::TupleExpr( const TupleExpr &other ) : Expression( other ) {
 	cloneAll( other.exprs, exprs );
-}
-
-TupleExpr::~TupleExpr() {
-	deleteAll( exprs );
 }
 
@@ -72,8 +64,4 @@
 
 TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
-}
-
-TupleIndexExpr::~TupleIndexExpr() {
-	delete tuple;
 }
 
@@ -105,8 +93,4 @@
 }
 
-TupleAssignExpr::~TupleAssignExpr() {
-	delete stmtExpr;
-}
-
 void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
 	os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
Index: src/SynTree/TupleType.cc
===================================================================
--- src/SynTree/TupleType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TupleType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -43,9 +43,4 @@
 }
 
-TupleType::~TupleType() {
-	deleteAll( types );
-	deleteAll( members );
-}
-
 void TupleType::print( std::ostream &os, Indenter indent ) const {
 	Type::print( os, indent );
Index: src/SynTree/Type.cc
===================================================================
--- src/SynTree/Type.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Type.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -57,9 +57,4 @@
 }
 
-Type::~Type() {
-	deleteAll( forall );
-	deleteAll( attributes );
-}
-
 // These must remain in the same order as the corresponding bit fields.
 const char * Type::FuncSpecifiersNames[] = { "inline", "fortran", "_Noreturn" };
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/Type.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -141,5 +141,4 @@
 	Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
 	Type( const Type & other );
-	virtual ~Type();
 
 	Qualifiers & get_qualifiers() { return tq; }
@@ -261,5 +260,4 @@
 	PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 	PointerType( const PointerType& );
-	virtual ~PointerType();
 
 	Type *get_base() { return base; }
@@ -291,5 +289,4 @@
 	ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 	ArrayType( const ArrayType& );
-	virtual ~ArrayType();
 
 	Type *get_base() { return base; }
@@ -319,5 +316,4 @@
 	ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 	ReferenceType( const ReferenceType & );
-	virtual ~ReferenceType();
 
 	Type *get_base() { return base; }
@@ -352,5 +348,4 @@
 	FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 	FunctionType( const FunctionType& );
-	virtual ~FunctionType();
 
 	std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
@@ -376,5 +371,4 @@
 	ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
 	ReferenceToType( const ReferenceToType & other );
-	virtual ~ReferenceToType();
 
 	const std::string & get_name() const { return name; }
@@ -503,5 +497,4 @@
 	TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 	TraitInstType( const TraitInstType & other );
-	~TraitInstType();
 
 	virtual bool isComplete() const override;
@@ -525,5 +518,4 @@
 	TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 	TypeInstType( const TypeInstType & other );
-	~TypeInstType();
 
 	TypeDecl *get_baseType() const { return baseType; }
@@ -549,5 +541,4 @@
 	TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 	TupleType( const TupleType& );
-	virtual ~TupleType();
 
 	typedef std::list<Type*> value_type;
@@ -583,5 +574,4 @@
 	TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 	TypeofType( const TypeofType& );
-	virtual ~TypeofType();
 
 	Expression *get_expr() const { return expr; }
@@ -606,5 +596,4 @@
 	AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 	AttrType( const AttrType& );
-	virtual ~AttrType();
 
 	const std::string & get_name() const { return name; }
Index: src/SynTree/TypeDecl.cc
===================================================================
--- src/SynTree/TypeDecl.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TypeDecl.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -25,8 +25,4 @@
 
 TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
-}
-
-TypeDecl::~TypeDecl() {
-  delete init;
 }
 
Index: src/SynTree/TypeExpr.cc
===================================================================
--- src/SynTree/TypeExpr.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TypeExpr.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -26,8 +26,4 @@
 }
 
-TypeExpr::~TypeExpr() {
-	delete type;
-}
-
 void TypeExpr::print( std::ostream &os, Indenter indent ) const {
 	if ( type ) type->print( os, indent );
Index: src/SynTree/TypeSubstitution.cc
===================================================================
--- src/SynTree/TypeSubstitution.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TypeSubstitution.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -26,13 +26,4 @@
 }
 
-TypeSubstitution::~TypeSubstitution() {
-	for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-		delete( i->second );
-	}
-	for ( VarEnvType::iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
-		delete( i->second );
-	}
-}
-
 TypeSubstitution &TypeSubstitution::operator=( const TypeSubstitution &other ) {
 	if ( this == &other ) return *this;
@@ -57,17 +48,9 @@
 
 void TypeSubstitution::add( std::string formalType, Type *actualType ) {
-	TypeEnvType::iterator i = typeEnv.find( formalType );
-	if ( i != typeEnv.end() ) {
-		delete i->second;
-	} // if
 	typeEnv[ formalType ] = actualType->clone();
 }
 
 void TypeSubstitution::remove( std::string formalType ) {
-	TypeEnvType::iterator i = typeEnv.find( formalType );
-	if ( i != typeEnv.end() ) {
-		delete i->second;
-		typeEnv.erase( formalType );
-	} // if
+	typeEnv.erase( formalType );
 }
 
@@ -155,5 +138,4 @@
 		Type * newtype = i->second->clone();
 		newtype->get_qualifiers() |= inst->get_qualifiers();
-		delete inst;
 		return newtype;
 	} // if
@@ -166,5 +148,4 @@
 	} else {
 		subCount++;
-		delete nameExpr;
 		return i->second->clone();
 	} // if
Index: src/SynTree/TypeSubstitution.h
===================================================================
--- src/SynTree/TypeSubstitution.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TypeSubstitution.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -35,5 +35,4 @@
 	TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
 	TypeSubstitution( const TypeSubstitution &other );
-	virtual ~TypeSubstitution();
 
 	TypeSubstitution &operator=( const TypeSubstitution &other );
@@ -101,8 +100,4 @@
 			if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
 				if ( formal->get_name() != "" ) {
-					TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
-					if ( i != typeEnv.end() ) {
-						delete i->second;
-					} // if
 					typeEnv[ formal->get_name() ] = actual->get_type()->clone();
 				} // if
Index: src/SynTree/TypeofType.cc
===================================================================
--- src/SynTree/TypeofType.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/TypeofType.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -29,8 +29,4 @@
 }
 
-TypeofType::~TypeofType() {
-	delete expr;
-}
-
 void TypeofType::print( std::ostream &os, Indenter indent ) const {
 	Type::print( os, indent );
Index: src/SynTree/module.mk
===================================================================
--- src/SynTree/module.mk	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/SynTree/module.mk	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -48,4 +48,5 @@
        SynTree/TypeSubstitution.cc \
        SynTree/Attribute.cc \
+       SynTree/GcTracer.cc \
        SynTree/VarExprReplacer.cc
 
Index: src/Tuples/Explode.cc
===================================================================
--- src/Tuples/Explode.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Tuples/Explode.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -70,6 +70,5 @@
 				// should now be a tuple of references rather than a reference to a tuple.
 				// Still, this code is a bit awkward, and could use some improvement.
-				UniqueExpr * newUniqueExpr = new UniqueExpr( applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
-				delete uniqueExpr;
+				UniqueExpr * newUniqueExpr = new UniqueExpr{ applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() };
 				if ( castAdded ) {
 					// if a cast was added by applyCast, then unique expr now has one more layer of reference
@@ -88,9 +87,5 @@
 				// field is consistent with the type of the tuple expr, since the field
 				// may have changed from type T to T&.
-				Expression * expr = tupleExpr->get_tuple();
-				tupleExpr->set_tuple( nullptr );
-				TupleIndexExpr * ret = new TupleIndexExpr( expr, tupleExpr->get_index() );
-				delete tupleExpr;
-				return ret;
+				return new TupleIndexExpr{ tupleExpr->get_tuple(), tupleExpr->get_index() };
 			}
 		};
Index: src/Tuples/Explode.h
===================================================================
--- src/Tuples/Explode.h	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Tuples/Explode.h	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -27,5 +27,5 @@
 namespace SymTab {
 class Indexer;
-}  // namespace SymTab
+}  // namespace SymTabf
 
 namespace Tuples {
@@ -67,5 +67,5 @@
 				for ( ResolvExpr::Alternative & alt : alts ) {
 					// distribute reference cast over all components
-					append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
+					append( std::forward<Output>(out), distributeReference( alt.expr ),
 						alt.env, alt.cost, alt.cvtCost );
 				}
@@ -96,7 +96,5 @@
 					TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
 					explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
-					delete idx;
 				}
-				delete arg;
 			}
 		} else {
Index: src/Tuples/TupleExpansion.cc
===================================================================
--- src/Tuples/TupleExpansion.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Tuples/TupleExpansion.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -45,10 +45,4 @@
 
 			std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
-
-			~UniqueExprExpander() {
-				for ( std::pair<const int, Expression *> & p : decls ) {
-					delete p.second;
-				}
-			}
 		};
 
@@ -111,7 +105,4 @@
 				UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
 				inner->location = newMemberExpr->location = loc;
-				memberExpr->member = nullptr;
-				memberExpr->aggregate = nullptr;
-				delete memberExpr;
 				return newMemberExpr->acceptMutator( expander );
 			} else {
@@ -135,5 +126,4 @@
 				expr->location = memberExpr->location;
 			}
-			delete aggr;
 			tupleExpr->location = memberExpr->location;
 			return tupleExpr;
@@ -181,5 +171,4 @@
 			decls[id] = condExpr;
 		}
-		delete unqExpr;
 		return decls[id]->clone();
 	}
@@ -191,5 +180,4 @@
 		ret->set_env( assnExpr->get_env() );
 		assnExpr->set_env( nullptr );
-		delete assnExpr;
 		return ret;
 	}
@@ -222,5 +210,4 @@
 			newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
 		}
-		delete tupleType;
 		return newType;
 	}
@@ -233,5 +220,4 @@
 		TypeSubstitution * env = tupleExpr->get_env();
 		tupleExpr->set_env( nullptr );
-		delete tupleExpr;
 
 		StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
@@ -275,9 +261,6 @@
 		TypeSubstitution * env = tupleExpr->get_env();
 
-		// remove data from shell and delete it
-		tupleExpr->set_result( nullptr );
-		tupleExpr->get_exprs().clear();
+		// remove data from shell
 		tupleExpr->set_env( nullptr );
-		delete tupleExpr;
 
 		return replaceTupleExpr( result, exprs, env );
Index: src/Virtual/ExpandCasts.cc
===================================================================
--- src/Virtual/ExpandCasts.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/Virtual/ExpandCasts.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -139,5 +139,5 @@
 		ObjectDecl * table = found->second;
 
-		Expression * result = new CastExpr(
+		return new CastExpr{
 			//new ApplicationExpr(
 				//new AddressExpr( new VariableExpr( vcast_decl ) ),
@@ -158,10 +158,5 @@
 				} ),
 			castExpr->get_result()->clone()
-			);
-
-		castExpr->set_arg( nullptr );
-		castExpr->set_result( nullptr );
-		delete castExpr;
-		return result;
+		};
 	}
 
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 61718416c4ecce46bb8d5202cc875d5e197c5cfd)
+++ src/main.cc	(revision 68f9c43ecf1873cbb5f06aee682704b56612ed16)
@@ -37,4 +37,5 @@
 #include "Common/PassVisitor.h"
 #include "Common/CompilerError.h"           // for CompilerError
+#include "Common/GC.h"						// for GC
 #include "Common/SemanticError.h"           // for SemanticError
 #include "Common/UnimplementedError.h"      // for UnimplementedError
@@ -57,4 +58,5 @@
 #include "SymTab/Validate.h"                // for validate
 #include "SynTree/Declaration.h"            // for Declaration
+#include "SynTree/GcTracer.h"               // for GC << TranslationUnit
 #include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
@@ -64,5 +66,4 @@
 
 #define OPTPRINT(x) if ( errorp ) cerr << x << endl;
-
 
 LinkageSpec::Spec linkage = LinkageSpec::Cforall;
@@ -233,4 +234,5 @@
 		delete parseTree;
 		parseTree = nullptr;
+		collect( translationUnit );
 
 		if ( astp ) {
@@ -242,8 +244,6 @@
 		OPTPRINT( "validate" )
 		SymTab::validate( translationUnit, symtabp );
-		if ( symtabp ) {
-			deleteAll( translationUnit );
-			return 0;
-		} // if
+		collect( translationUnit );
+		if ( symtabp ) return 0;
 
 		if ( expraltp ) {
@@ -266,4 +266,5 @@
 		OPTPRINT( "expandMemberTuples" );
 		Tuples::expandMemberTuples( translationUnit );
+		collect( translationUnit );
 		if ( libcfap ) {
 			// generate the bodies of cfa library functions
@@ -273,5 +274,4 @@
 		if ( declstatsp ) {
 			CodeTools::printDeclStats( translationUnit );
-			deleteAll( translationUnit );
 			return 0;
 		}
@@ -286,4 +286,5 @@
 		OPTPRINT( "resolve" )
 		ResolvExpr::resolve( translationUnit );
+		collect( translationUnit );
 		if ( exprp ) {
 			dump( translationUnit );
@@ -294,4 +295,5 @@
 		OPTPRINT( "fixInit" )
 		InitTweak::fix( translationUnit, filename, libcfap || treep );
+		collect( translationUnit );
 		if ( ctorinitp ) {
 			dump ( translationUnit );
@@ -313,4 +315,5 @@
 		OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
 		Tuples::expandTuples( translationUnit );
+		collect( translationUnit );
 		if ( tuplep ) {
 			dump( translationUnit );
@@ -323,19 +326,21 @@
 		OPTPRINT("instantiateGenerics")
 		GenPoly::instantiateGeneric( translationUnit );
+		collect( translationUnit );
 		if ( genericsp ) {
 			dump( translationUnit );
 			return 0;
 		}
+
 		OPTPRINT( "convertLvalue" )
 		GenPoly::convertLvalue( translationUnit );
-
-
+		collect( translationUnit );
 		if ( bboxp ) {
 			dump( translationUnit );
 			return 0;
 		} // if
+
 		OPTPRINT( "box" )
 		GenPoly::box( translationUnit );
-
+		collect( translationUnit );
 		if ( bcodegenp ) {
 			dump( translationUnit );
@@ -383,5 +388,4 @@
 	} // try
 
-	deleteAll( translationUnit );
 	return 0;
 } // main
@@ -568,5 +572,4 @@
 		printAll( decls, out );
 	}
-	deleteAll( translationUnit );
 } // dump
 
