Index: src/GenPoly/SpecializeNew.cpp
===================================================================
--- src/GenPoly/SpecializeNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
+++ src/GenPoly/SpecializeNew.cpp	(revision c4c8571a1aaa3100966db2d603b3a32857faebdd)
@@ -230,5 +230,5 @@
 	if ( auto tuple = type.as<ast::TupleType>() ) {
 		std::vector<ast::ptr<ast::Expr>> exprs;
-		for ( const ast::Type * t : *tuple ) {
+		for ( const ast::ptr<ast::Type> & t : *tuple ) {
 			exprs.push_back( structureArg( location, t, begin, end ) );
 		}
@@ -248,6 +248,7 @@
 			if (typeMap.count(typeInst->base)) {
 				ast::TypeInstType * newInst = mutate(typeInst);
-				newInst->expr_id = typeMap[typeInst->base].first;
-				newInst->formal_usage = typeMap[typeInst->base].second;
+				auto const & pair = typeMap[typeInst->base];
+				newInst->expr_id = pair.first;
+				newInst->formal_usage = pair.second;
 				return newInst;
 			}
@@ -462,5 +463,4 @@
 	if ( specialized != expr->arg ) {
 		// Assume that the specialization incorporates the cast.
-		// std::cerr << expr <<std::endl;
 		return specialized;
 	} else {
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
+++ src/InitTweak/InitTweak.cc	(revision c4c8571a1aaa3100966db2d603b3a32857faebdd)
@@ -27,4 +27,5 @@
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
+#include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -770,5 +771,4 @@
 			std::list< Expression * > callExprs;
 			collectCtorDtorCalls( stmt, callExprs );
-			// if ( callExprs.empty() ) return false; // xxx - do I still need this check?
 			return std::all_of( callExprs.begin(), callExprs.end(), pred);
 		}
@@ -901,5 +901,5 @@
 			} else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
 				return varExpr->get_var()->get_name();
-			}	else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
+			} else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
 				return funcName( castExpr->get_arg() );
 			} else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
@@ -923,5 +923,5 @@
 			} else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
 				return varExpr->var->name;
-			}	else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+			} else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
 				return funcName( castExpr->arg );
 			} else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
@@ -991,6 +991,5 @@
 
 	Type * isPointerType( Type * type ) {
-		if ( getPointerBase( type ) ) return type;
-		else return nullptr;
+		return getPointerBase( type ) ? type : nullptr;
 	}
 
@@ -1014,5 +1013,4 @@
 				src = new AddressExpr( src );
 			}
-			// src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
 		}
 		return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
@@ -1167,10 +1165,4 @@
 	}
 
-	bool isConstructor( const std::string & str ) { return str == "?{}"; }
-	bool isDestructor( const std::string & str ) { return str == "^?{}"; }
-	bool isAssignment( const std::string & str ) { return str == "?=?"; }
-	bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
-	bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
-
 	const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
 		const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
@@ -1192,17 +1184,17 @@
 
 bool isAssignment( const ast::FunctionDecl * decl ) {
-	return isAssignment( decl->name ) && isCopyFunction( decl );
+	return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
 }
 
 bool isDestructor( const ast::FunctionDecl * decl ) {
-	return isDestructor( decl->name );
+	return CodeGen::isDestructor( decl->name );
 }
 
 bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
-	return isConstructor( decl->name ) && 1 == decl->params.size();
+	return CodeGen::isConstructor( decl->name ) && 1 == decl->params.size();
 }
 
 bool isCopyConstructor( const ast::FunctionDecl * decl ) {
-	return isConstructor( decl->name ) && 2 == decl->params.size();
+	return CodeGen::isConstructor( decl->name ) && 2 == decl->params.size();
 }
 
@@ -1222,5 +1214,5 @@
 	}
 	const FunctionDecl * isDestructor( const Declaration * decl ) {
-		if ( isDestructor( decl->name ) ) {
+		if ( CodeGen::isDestructor( decl->name ) ) {
 			return dynamic_cast< const FunctionDecl * >( decl );
 		}
@@ -1228,5 +1220,5 @@
 	}
 	const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
-		if ( isConstructor( decl->name ) ) {
+		if ( CodeGen::isConstructor( decl->name ) ) {
 			if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
 				if ( func->type->parameters.size() == 1 ) {