Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision 93744b58e740b700af32339b06e691f172b99706)
+++ src/AST/Pass.hpp	(revision 0e42794749c9addc38d4d8d473bfad3c2c643545)
@@ -33,5 +33,5 @@
 #include "AST/Visitor.hpp"
 
-#include "SymTab/Indexer.h"
+#include "AST/SymbolTable.hpp"
 
 // Private prelude header, needed for some of the magic tricks this class pulls off
@@ -61,5 +61,5 @@
 //                          postvisit/postmutate teminates.
 // | WithVisitorRef       - provides an pointer to the templated visitor wrapper
-// | WithIndexer          - provides indexer functionality (i.e. up-to-date symbol table)
+// | WithSymbolTable      - provides symbol table functionality
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
@@ -206,8 +206,8 @@
 
 private:
-	/// Internal RAII guard for indexer features
-	struct guard_indexer {
-		guard_indexer( Pass<pass_t> & pass ): pass( pass ) { __pass::indexer::enter(pass, 0); }
-		~guard_indexer()                                   { __pass::indexer::leave(pass, 0); }
+	/// Internal RAII guard for symbol table features
+	struct guard_symtab {
+		guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
+		~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
 		Pass<pass_t> & pass;
 	};
@@ -294,7 +294,7 @@
 };
 
-/// Use when the templated visitor should update the indexer
-struct WithIndexer {
-	SymTab::Indexer indexer;
+/// Use when the templated visitor should update the symbol table
+struct WithSymbolTable {
+	SymbolTable symtab;
 };
 }
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 93744b58e740b700af32339b06e691f172b99706)
+++ src/AST/Pass.impl.hpp	(revision 0e42794749c9addc38d4d8d473bfad3c2c643545)
@@ -398,5 +398,5 @@
 	VISIT(
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &ObjectDecl::type );
 		}
@@ -406,5 +406,5 @@
 	)
 
-	__pass::indexer::addId( pass, 0, node );
+	__pass::symtab::addId( pass, 0, node );
 
 	VISIT_END( DeclWithType, node );
@@ -417,15 +417,15 @@
 	VISIT_START( node );
 
-	__pass::indexer::addId( pass, 0, node );
+	__pass::symtab::addId( pass, 0, node );
 
 	VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
 	{
 		// with clause introduces a level of scope (for the with expression members).
-		// with clause exprs are added to the indexer before parameters so that parameters
+		// with clause exprs are added to the symbol table before parameters so that parameters
 		// shadow with exprs and not the other way around.
-		guard_indexer guard { *this };
-		__pass::indexer::addWith( pass, 0, node->withExprs, node );
+		guard_symtab guard { *this };
+		__pass::symtab::addWith( pass, 0, node->withExprs, node );
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			// implicit add __func__ identifier as specified in the C manual 6.4.2.2
 			static ast::ObjectDecl func(
@@ -436,5 +436,5 @@
 				)
 			);
-			__pass::indexer::addId( pass, 0, &func );
+			__pass::symtab::addId( pass, 0, &func );
 			VISIT(
 				maybe_accept( node, &FunctionDecl::type );
@@ -460,8 +460,8 @@
 	// make up a forward declaration and add it before processing the members
 	// needs to be on the heap because addStruct saves the pointer
-	__pass::indexer::addStructFwd( pass, 0, node );
-
-	VISIT({
-		guard_indexer guard { * this };
+	__pass::symtab::addStructFwd( pass, 0, node );
+
+	VISIT({
+		guard_symtab guard { * this };
 		maybe_accept( node, &StructDecl::params  );
 		maybe_accept( node, &StructDecl::members );
@@ -469,5 +469,5 @@
 
 	// this addition replaces the forward declaration
-	__pass::indexer::addStruct( pass, 0, node );
+	__pass::symtab::addStruct( pass, 0, node );
 
 	VISIT_END( Decl, node );
@@ -481,13 +481,13 @@
 
 	// make up a forward declaration and add it before processing the members
-	__pass::indexer::addUnionFwd( pass, 0, node );
-
-	VISIT({
-		guard_indexer guard { * this };
+	__pass::symtab::addUnionFwd( pass, 0, node );
+
+	VISIT({
+		guard_symtab guard { * this };
 		maybe_accept( node, &UnionDecl::params  );
 		maybe_accept( node, &UnionDecl::members );
 	})
 
-	__pass::indexer::addUnion( pass, 0, node );
+	__pass::symtab::addUnion( pass, 0, node );
 
 	VISIT_END( Decl, node );
@@ -500,5 +500,5 @@
 	VISIT_START( node );
 
-	__pass::indexer::addEnum( pass, 0, node );
+	__pass::symtab::addEnum( pass, 0, node );
 
 	VISIT(
@@ -518,10 +518,10 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &TraitDecl::params  );
 		maybe_accept( node, &TraitDecl::members );
 	})
 
-	__pass::indexer::addTrait( pass, 0, node );
+	__pass::symtab::addTrait( pass, 0, node );
 
 	VISIT_END( Decl, node );
@@ -535,5 +535,5 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &TypeDecl::params );
 		maybe_accept( node, &TypeDecl::base   );
@@ -543,5 +543,5 @@
 	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
 	// and may depend on the type itself
-	__pass::indexer::addType( pass, 0, node );
+	__pass::symtab::addType( pass, 0, node );
 
 	VISIT(
@@ -549,5 +549,5 @@
 
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &TypeDecl::init );
 		}
@@ -564,10 +564,10 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &TypedefDecl::params );
 		maybe_accept( node, &TypedefDecl::base   );
 	})
 
-	__pass::indexer::addType( pass, 0, node );
+	__pass::symtab::addType( pass, 0, node );
 
 	VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
@@ -611,7 +611,7 @@
 		// do not enter a new scope if inFunction is true - needs to check old state before the assignment
 		auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
-			if ( ! inFunction ) __pass::indexer::enter(pass, 0);
+			if ( ! inFunction ) __pass::symtab::enter(pass, 0);
 		}, [this, inFunction = this->inFunction]() {
-			if ( ! inFunction ) __pass::indexer::leave(pass, 0);
+			if ( ! inFunction ) __pass::symtab::leave(pass, 0);
 		});
 		ValueGuard< bool > guard2( inFunction );
@@ -669,5 +669,5 @@
 	VISIT({
 		// if statements introduce a level of scope (for the initialization)
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &IfStmt::inits    );
 		maybe_accept( node, &IfStmt::cond     );
@@ -687,5 +687,5 @@
 	VISIT({
 		// while statements introduce a level of scope (for the initialization)
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &WhileStmt::inits );
 		maybe_accept( node, &WhileStmt::cond  );
@@ -704,5 +704,5 @@
 	VISIT({
 		// for statements introduce a level of scope (for the initialization)
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &ForStmt::inits );
 		maybe_accept( node, &ForStmt::cond  );
@@ -800,5 +800,5 @@
 	VISIT({
 		// catch statements introduce a level of scope (for the caught exception)
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &CatchStmt::decl );
 		maybe_accept( node, &CatchStmt::cond );
@@ -901,6 +901,6 @@
 		{
 			// catch statements introduce a level of scope (for the caught exception)
-			guard_indexer guard { *this };
-			__pass::indexer::addWith( pass, 0, node->exprs, node );
+			guard_symtab guard { *this };
+			__pass::symtab::addWith( pass, 0, node->exprs, node );
 			maybe_accept( node, &WithStmt::stmt );
 		}
@@ -953,5 +953,5 @@
 	VISIT(
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &ApplicationExpr::result );
 		}
@@ -971,5 +971,5 @@
 	VISIT(
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedExpr::result );
 		}
@@ -988,5 +988,5 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &NameExpr::result );
 	})
@@ -1002,5 +1002,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &CastExpr::result );
 		}
@@ -1018,5 +1018,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &KeywordCastExpr::result );
 		}
@@ -1034,5 +1034,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &VirtualCastExpr::result );
 		}
@@ -1050,5 +1050,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &AddressExpr::result );
 		}
@@ -1066,5 +1066,5 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &LabelAddressExpr::result );
 	})
@@ -1080,5 +1080,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedMemberExpr::result );
 		}
@@ -1097,5 +1097,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &MemberExpr::result );
 		}
@@ -1113,5 +1113,5 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &VariableExpr::result );
 	})
@@ -1127,5 +1127,5 @@
 
 	VISIT({
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &ConstantExpr::result );
 	})
@@ -1141,5 +1141,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &SizeofExpr::result );
 		}
@@ -1161,5 +1161,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &AlignofExpr::result );
 		}
@@ -1181,5 +1181,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedOffsetofExpr::result );
 		}
@@ -1197,5 +1197,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &OffsetofExpr::result );
 		}
@@ -1213,5 +1213,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &OffsetPackExpr::result );
 		}
@@ -1229,5 +1229,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &LogicalExpr::result );
 		}
@@ -1246,5 +1246,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &ConditionalExpr::result );
 		}
@@ -1264,5 +1264,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &CommaExpr::result );
 		}
@@ -1281,5 +1281,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &TypeExpr::result );
 		}
@@ -1297,5 +1297,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &AsmExpr::result );
 		}
@@ -1315,5 +1315,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &ImplicitCopyCtorExpr::result );
 		}
@@ -1331,5 +1331,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &ConstructorExpr::result );
 		}
@@ -1347,5 +1347,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &CompoundLiteralExpr::result );
 		}
@@ -1363,5 +1363,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &RangeExpr::result );
 		}
@@ -1380,5 +1380,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedTupleExpr::result );
 		}
@@ -1396,5 +1396,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &TupleExpr::result );
 		}
@@ -1412,5 +1412,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &TupleIndexExpr::result );
 		}
@@ -1428,5 +1428,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &TupleAssignExpr::result );
 		}
@@ -1454,5 +1454,5 @@
 
 		{
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &StmtExpr::result );
 		}
@@ -1472,5 +1472,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UniqueExpr::result );
 		}
@@ -1488,5 +1488,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedInitExpr::result );
 		}
@@ -1505,5 +1505,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &InitExpr::result );
 		}
@@ -1522,5 +1522,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &DeletedExpr::result );
 		}
@@ -1539,5 +1539,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &DefaultArgExpr::result );
 		}
@@ -1555,5 +1555,5 @@
 
 	VISIT({
-			guard_indexer guard { *this };
+			guard_symtab guard { *this };
 			maybe_accept( node, &GenericExpr::result );
 		}
@@ -1566,5 +1566,5 @@
 			const Type * type = nullptr;
 			if( assoc.type ) {
-				guard_indexer guard { *this };
+				guard_symtab guard { *this };
 				type = assoc.type->accept( *this );
 				if( type != assoc.type ) mutated = true;
@@ -1682,8 +1682,8 @@
 	VISIT_START( node );
 
-	__pass::indexer::addStruct( pass, 0, node->name );
-
-	VISIT({
-		guard_indexer guard { *this };
+	__pass::symtab::addStruct( pass, 0, node->name );
+
+	VISIT({
+		guard_symtab guard { *this };
 		maybe_accept( node, &StructInstType::forall );
 		maybe_accept( node, &StructInstType::params );
@@ -1699,8 +1699,8 @@
 	VISIT_START( node );
 
-	__pass::indexer::addStruct( pass, 0, node->name );
+	__pass::symtab::addStruct( pass, 0, node->name );
 
 	{
-		guard_indexer guard { *this };
+		guard_symtab guard { *this };
 		maybe_accept( node, &UnionInstType::forall );
 		maybe_accept( node, &UnionInstType::params );
@@ -1893,5 +1893,5 @@
 			std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
 			for ( const auto & p : node->typeEnv ) {
-				guard_indexer guard { *this };
+				guard_symtab guard { *this };
 				auto new_node = p.second->accept( *this );
 				if (new_node != p.second) mutated = false;
@@ -1909,5 +1909,5 @@
 			std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
 			for ( const auto & p : node->varEnv ) {
-				guard_indexer guard { *this };
+				guard_symtab guard { *this };
 				auto new_node = p.second->accept( *this );
 				if (new_node != p.second) mutated = false;
Index: src/AST/Pass.proto.hpp
===================================================================
--- src/AST/Pass.proto.hpp	(revision 93744b58e740b700af32339b06e691f172b99706)
+++ src/AST/Pass.proto.hpp	(revision 0e42794749c9addc38d4d8d473bfad3c2c643545)
@@ -265,11 +265,11 @@
 	};
 
-	// Finally certain pass desire an up to date indexer automatically
-	// detect the presence of a member name indexer and call all the members appropriately
-	namespace indexer {
+	// Finally certain pass desire an up to date symbol table automatically
+	// detect the presence of a member name `symtab` and call all the members appropriately
+	namespace symtab {
 		// Some simple scoping rules
 		template<typename pass_t>
-		static inline auto enter( pass_t & pass, int ) -> decltype( pass.indexer.enterScope(), void() ) {
-			pass.indexer.enterScope();
+		static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
+			pass.symtab.enterScope();
 		}
 
@@ -278,6 +278,6 @@
 
 		template<typename pass_t>
-		static inline auto leave( pass_t & pass, int ) -> decltype( pass.indexer.leaveScope(), void() ) {
-			pass.indexer.leaveScope();
+		static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
+			pass.symtab.leaveScope();
 		}
 
@@ -285,10 +285,10 @@
 		static inline auto leave( pass_t &, long ) {}
 
-		// The indexer has 2 kind of functions mostly, 1 argument and 2 arguments
+		// The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
 		// Create macro to condense these common patterns
-		#define INDEXER_FUNC1( func, type ) \
+		#define SYMTAB_FUNC1( func, type ) \
 		template<typename pass_t> \
-		static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.indexer.func( arg ), void() ) {\
-			pass.indexer.func( arg ); \
+		static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\
+			pass.symtab.func( arg ); \
 		} \
 		\
@@ -296,8 +296,8 @@
 		static inline void func( pass_t &, long, type ) {}
 
-		#define INDEXER_FUNC2( func, type1, type2 ) \
+		#define SYMTAB_FUNC2( func, type1, type2 ) \
 		template<typename pass_t> \
-		static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.indexer.func( arg1, arg2 ), void () ) {\
-			pass.indexer.func( arg1, arg2 ); \
+		static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\
+			pass.symtab.func( arg1, arg2 ); \
 		} \
 			\
@@ -305,18 +305,18 @@
 		static inline void func( pass_t &, long, type1, type2 ) {}
 
-		INDEXER_FUNC1( addId     , const DeclWithType *  );
-		INDEXER_FUNC1( addType   , const NamedTypeDecl * );
-		INDEXER_FUNC1( addStruct , const StructDecl *    );
-		INDEXER_FUNC1( addEnum   , const EnumDecl *      );
-		INDEXER_FUNC1( addUnion  , const UnionDecl *     );
-		INDEXER_FUNC1( addTrait  , const TraitDecl *     );
-		INDEXER_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
+		SYMTAB_FUNC1( addId     , const DeclWithType *  );
+		SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+		SYMTAB_FUNC1( addStruct , const StructDecl *    );
+		SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+		SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+		SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+		SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
 
 		// A few extra functions have more complicated behaviour, they are hand written
 		template<typename pass_t>
-		static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
+		static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) {
 			ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
 			fwd->params = decl->params;
-			pass.indexer.addStruct( fwd );
+			pass.symtab.addStruct( fwd );
 		}
 
@@ -325,8 +325,8 @@
 
 		template<typename pass_t>
-		static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
+		static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) {
 			UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
 			fwd->params = decl->params;
-			pass.indexer.addUnion( fwd );
+			pass.symtab.addUnion( fwd );
 		}
 
@@ -335,7 +335,7 @@
 
 		template<typename pass_t>
-		static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
-			if ( ! pass.indexer.lookupStruct( str ) ) {
-				pass.indexer.addStruct( str );
+		static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) {
+			if ( ! pass.symtab.lookupStruct( str ) ) {
+				pass.symtab.addStruct( str );
 			}
 		}
@@ -345,7 +345,7 @@
 
 		template<typename pass_t>
-		static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
-			if ( ! pass.indexer.lookupUnion( str ) ) {
-				pass.indexer.addUnion( str );
+		static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) {
+			if ( ! pass.symtab.lookupUnion( str ) ) {
+				pass.symtab.addUnion( str );
 			}
 		}
@@ -354,6 +354,6 @@
 		static inline void addUnion( pass_t &, long, const std::string & ) {}
 
-		#undef INDEXER_FUNC1
-		#undef INDEXER_FUNC2
+		#undef SYMTAB_FUNC1
+		#undef SYMTAB_FUNC2
 	};
 };
Index: src/AST/SymbolTable.hpp
===================================================================
--- src/AST/SymbolTable.hpp	(revision 93744b58e740b700af32339b06e691f172b99706)
+++ src/AST/SymbolTable.hpp	(revision 0e42794749c9addc38d4d8d473bfad3c2c643545)
@@ -123,11 +123,11 @@
 	void addType( const NamedTypeDecl * decl );
 	/// Adds a struct declaration to the symbol table by name
-	void addStruct( const std::string &id );
+	void addStruct( const std::string & id );
 	/// Adds a struct declaration to the symbol table
 	void addStruct( const StructDecl * decl );
 	/// Adds an enum declaration to the symbol table
-	void addEnum( const EnumDecl *decl );
+	void addEnum( const EnumDecl * decl );
 	/// Adds a union declaration to the symbol table by name
-	void addUnion( const std::string &id );
+	void addUnion( const std::string & id );
 	/// Adds a union declaration to the symbol table
 	void addUnion( const UnionDecl * decl );
Index: src/AST/porting.md
===================================================================
--- src/AST/porting.md	(revision 93744b58e740b700af32339b06e691f172b99706)
+++ src/AST/porting.md	(revision 0e42794749c9addc38d4d8d473bfad3c2c643545)
@@ -109,10 +109,10 @@
     * `SymTab::Indexer` => `ast::SymbolTable`
     * `SymTab/Indexer.{h,cc}` => `AST/SymbolTable.{hpp,cpp}`
-    * **TODO** `WithIndexer` => `WithSymbolTable`
+    * `WithIndexer` => `WithSymbolTable`
       * `indexer` => `symTab`
     * `IdData::deleteStmt` => `IdData::deleter`
     * `lookupId()` now returns a vector rather than an out-param list
-    * To avoid name collisions:
-      * `SymTab::Mangler` => `Mangle`
+  * To avoid name collisions:
+    * `SymTab::Mangler` => `Mangle`
   * `ResolvExpr::TypeEnvironment` => `ast::TypeEnvironment`
     * in `AST/TypeEnvironment.hpp`