Index: src/AST/Copy.hpp
===================================================================
--- src/AST/Copy.hpp	(revision 6b2d444b03e3fdf10a1f2c2f1f0351a67de058ee)
+++ src/AST/Copy.hpp	(revision cef743061e12a0e8ef990b5a52212149bc0ebc93)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jul 10 16:13:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:22:00 2021
-// Update Count     : 2
+// Last Modified On : Wed Dec 15 11:07:00 2021
+// Update Count     : 3
 //
 
@@ -52,4 +52,14 @@
 Node * deepCopy<Node>( const Node * localRoot );
 
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * shallowCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+	return shallowCopy( localRoot.get() );
+}
+
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * deepCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+	return deepCopy( localRoot.get() );
+}
+
 }
 
Index: src/AST/Node.hpp
===================================================================
--- src/AST/Node.hpp	(revision 6b2d444b03e3fdf10a1f2c2f1f0351a67de058ee)
+++ src/AST/Node.hpp	(revision cef743061e12a0e8ef990b5a52212149bc0ebc93)
@@ -188,4 +188,9 @@
 	}
 
+	ptr_base & operator=( const node_t * node ) {
+		assign( node );
+		return *this;
+	}
+
 	template<typename o_node_t>
 	ptr_base & operator=( const o_node_t * node ) {
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 6b2d444b03e3fdf10a1f2c2f1f0351a67de058ee)
+++ src/AST/Pass.impl.hpp	(revision cef743061e12a0e8ef990b5a52212149bc0ebc93)
@@ -33,11 +33,4 @@
 	/* call the implementation of the previsit of this pass */ \
 	__pass::previsit( core, node, 0 );
-
-#define VISIT( code... ) \
-	/* if this node should visit its children */ \
-	if ( __visit_children() ) { \
-		/* visit the children */ \
-		code \
-	}
 
 #define VISIT_END( type, node ) \
@@ -452,5 +445,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		{
 			guard_symtab guard { *this };
@@ -460,5 +453,5 @@
 		maybe_accept( node, &ObjectDecl::bitfieldWidth );
 		maybe_accept( node, &ObjectDecl::attributes    );
-	)
+	}
 
 	__pass::symtab::addId( core, 0, node );
@@ -475,5 +468,7 @@
 	__pass::symtab::addId( core, 0, node );
 
-	VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
+	if ( __visit_children() ) {
+		maybe_accept( node, &FunctionDecl::withExprs );
+	}
 	{
 		// with clause introduces a level of scope (for the with expression members).
@@ -493,5 +488,5 @@
 			} };
 			__pass::symtab::addId( core, 0, func );
-			VISIT(
+			if ( __visit_children() ) {
 				// parameter declarations
 				maybe_accept( node, &FunctionDecl::params );
@@ -509,5 +504,5 @@
 				maybe_accept( node, &FunctionDecl::stmts );
 				maybe_accept( node, &FunctionDecl::attributes );
-			)
+			}
 		}
 	}
@@ -526,10 +521,10 @@
 	__pass::symtab::addStructFwd( core, 0, node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { * this };
 		maybe_accept( node, &StructDecl::params     );
 		maybe_accept( node, &StructDecl::members    );
 		maybe_accept( node, &StructDecl::attributes );
-	})
+	}
 
 	// this addition replaces the forward declaration
@@ -548,10 +543,10 @@
 	__pass::symtab::addUnionFwd( core, 0, node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { * this };
 		maybe_accept( node, &UnionDecl::params     );
 		maybe_accept( node, &UnionDecl::members    );
 		maybe_accept( node, &UnionDecl::attributes );
-	})
+	}
 
 	__pass::symtab::addUnion( core, 0, node );
@@ -568,10 +563,10 @@
 	__pass::symtab::addEnum( core, 0, node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		// unlike structs, traits, and unions, enums inject their members into the global scope
 		maybe_accept( node, &EnumDecl::params     );
 		maybe_accept( node, &EnumDecl::members    );
 		maybe_accept( node, &EnumDecl::attributes );
-	)
+	}
 
 	VISIT_END( Decl, node );
@@ -584,10 +579,10 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &TraitDecl::params     );
 		maybe_accept( node, &TraitDecl::members    );
 		maybe_accept( node, &TraitDecl::attributes );
-	})
+	}
 
 	__pass::symtab::addTrait( core, 0, node );
@@ -602,8 +597,8 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &TypeDecl::base   );
-	})
+	}
 
 	// see A NOTE ON THE ORDER OF TRAVERSAL, above
@@ -612,5 +607,5 @@
 	__pass::symtab::addType( core, 0, node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &TypeDecl::assertions );
 
@@ -619,5 +614,5 @@
 			maybe_accept( node, &TypeDecl::init );
 		}
-	)
+	}
 
 	VISIT_END( Decl, node );
@@ -630,12 +625,14 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &TypedefDecl::base   );
-	})
+	}
 
 	__pass::symtab::addType( core, 0, node );
 
-	VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
+	if ( __visit_children() ) {
+		maybe_accept( node, &TypedefDecl::assertions );
+	}
 
 	VISIT_END( Decl, node );
@@ -648,7 +645,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &AsmDecl::stmt );
-	)
+	}
 
 	VISIT_END( AsmDecl, node );
@@ -661,7 +658,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &DirectiveDecl::stmt );
-	)
+	}
 
 	VISIT_END( DirectiveDecl, node );
@@ -674,8 +671,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &StaticAssertDecl::cond );
 		maybe_accept( node, &StaticAssertDecl::msg  );
-	)
+	}
 
 	VISIT_END( StaticAssertDecl, node );
@@ -687,5 +684,6 @@
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
 	VISIT_START( node );
-	VISIT(
+
+	if ( __visit_children() ) {
 		// Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
 		auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
@@ -704,5 +702,6 @@
 		guard_scope guard3 { *this };
 		maybe_accept( node, &CompoundStmt::kids );
-	)
+	}
+
 	VISIT_END( CompoundStmt, node );
 }
@@ -714,7 +713,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ExprStmt::expr );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -727,10 +726,10 @@
 	VISIT_START( node )
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &AsmStmt::instruction );
 		maybe_accept( node, &AsmStmt::output      );
 		maybe_accept( node, &AsmStmt::input       );
 		maybe_accept( node, &AsmStmt::clobber     );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -752,5 +751,5 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		// if statements introduce a level of scope (for the initialization)
 		guard_symtab guard { *this };
@@ -759,5 +758,5 @@
 		maybe_accept_as_compound( node, &IfStmt::thenPart );
 		maybe_accept_as_compound( node, &IfStmt::elsePart );
-	})
+	}
 
 	VISIT_END( Stmt, node );
@@ -770,5 +769,5 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		// while statements introduce a level of scope (for the initialization)
 		guard_symtab guard { *this };
@@ -776,5 +775,5 @@
 		maybe_accept( node, &WhileStmt::cond  );
 		maybe_accept_as_compound( node, &WhileStmt::body  );
-	})
+	}
 
 	VISIT_END( Stmt, node );
@@ -787,5 +786,5 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		// for statements introduce a level of scope (for the initialization)
 		guard_symtab guard { *this };
@@ -795,5 +794,5 @@
 		maybe_accept( node, &ForStmt::inc   );
 		maybe_accept_as_compound( node, &ForStmt::body  );
-	})
+	}
 
 	VISIT_END( Stmt, node );
@@ -806,8 +805,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &SwitchStmt::cond  );
 		maybe_accept( node, &SwitchStmt::stmts );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -820,8 +819,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &CaseStmt::cond  );
 		maybe_accept( node, &CaseStmt::stmts );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -842,7 +841,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ReturnStmt::expr );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -855,8 +854,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ThrowStmt::expr   );
 		maybe_accept( node, &ThrowStmt::target );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -869,9 +868,9 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &TryStmt::body     );
 		maybe_accept( node, &TryStmt::handlers );
 		maybe_accept( node, &TryStmt::finally  );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -884,5 +883,5 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		// catch statements introduce a level of scope (for the caught exception)
 		guard_symtab guard { *this };
@@ -890,5 +889,5 @@
 		maybe_accept( node, &CatchStmt::cond );
 		maybe_accept_as_compound( node, &CatchStmt::body );
-	})
+	}
 
 	VISIT_END( Stmt, node );
@@ -901,7 +900,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &FinallyStmt::body );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -914,7 +913,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &SuspendStmt::then   );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -934,5 +933,5 @@
 		// }
 
-	VISIT({
+	if ( __visit_children() ) {
 		std::vector<WaitForStmt::Clause> new_clauses;
 		new_clauses.reserve( node->clauses.size() );
@@ -965,5 +964,5 @@
 			node = n;
 		}
-	})
+	}
 
 	#define maybe_accept(field) \
@@ -977,5 +976,5 @@
 		}
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( timeout.time );
 		maybe_accept( timeout.stmt );
@@ -983,5 +982,5 @@
 		maybe_accept( orElse.stmt  );
 		maybe_accept( orElse.cond  );
-	)
+	}
 
 	#undef maybe_accept
@@ -996,5 +995,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &WithStmt::exprs );
 		{
@@ -1004,5 +1003,6 @@
 			maybe_accept( node, &WithStmt::stmt );
 		}
-	)
+	}
+
 	VISIT_END( Stmt, node );
 }
@@ -1022,7 +1022,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &DeclStmt::decl );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -1037,7 +1037,7 @@
 	// For now this isn't visited, it is unclear if this causes problem
 	// if all tests are known to pass, remove this code
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-	)
+	}
 
 	VISIT_END( Stmt, node );
@@ -1050,4 +1050,5 @@
 	VISIT_START( node );
 
+<<<<<<< HEAD
 	VISIT(
 		maybe_accept( node, &MutexStmt::mutexObjs );
@@ -1059,4 +1060,12 @@
 		}
 	)
+=======
+	if ( __visit_children() ) {
+		// mutex statements introduce a level of scope (for the initialization)
+		guard_symtab guard { *this };
+		maybe_accept( node, &MutexStmt::stmt );
+		maybe_accept( node, &MutexStmt::mutexObjs );
+	}
+>>>>>>> e21f2536b7495654ded040259b42b7e2325b8360
 
 	VISIT_END( Stmt, node );
@@ -1069,5 +1078,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		{
 			guard_symtab guard { *this };
@@ -1076,5 +1085,5 @@
 		maybe_accept( node, &ApplicationExpr::func );
 		maybe_accept( node, &ApplicationExpr::args );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1087,5 +1096,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		{
 			guard_symtab guard { *this };
@@ -1094,5 +1103,5 @@
 
 		maybe_accept( node, &UntypedExpr::args );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1105,8 +1114,8 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &NameExpr::result );
-	})
+	}
 
 	VISIT_END( Expr, node );
@@ -1119,10 +1128,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &CastExpr::result );
 		}
 		maybe_accept( node, &CastExpr::arg );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1135,10 +1145,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &KeywordCastExpr::result );
 		}
 		maybe_accept( node, &KeywordCastExpr::arg );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1151,10 +1162,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &VirtualCastExpr::result );
 		}
 		maybe_accept( node, &VirtualCastExpr::arg );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1167,10 +1179,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &AddressExpr::result );
 		}
 		maybe_accept( node, &AddressExpr::arg );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1183,8 +1196,8 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &LabelAddressExpr::result );
-	})
+	}
 
 	VISIT_END( Expr, node );
@@ -1197,5 +1210,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedMemberExpr::result );
@@ -1203,5 +1217,5 @@
 		maybe_accept( node, &UntypedMemberExpr::aggregate );
 		maybe_accept( node, &UntypedMemberExpr::member    );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1214,10 +1228,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &MemberExpr::result );
 		}
 		maybe_accept( node, &MemberExpr::aggregate );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1230,8 +1245,8 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &VariableExpr::result );
-	})
+	}
 
 	VISIT_END( Expr, node );
@@ -1244,8 +1259,8 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &ConstantExpr::result );
-	})
+	}
 
 	VISIT_END( Expr, node );
@@ -1258,5 +1273,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &SizeofExpr::result );
@@ -1267,5 +1283,5 @@
 			maybe_accept( node, &SizeofExpr::expr );
 		}
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1278,5 +1294,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &AlignofExpr::result );
@@ -1287,5 +1304,5 @@
 			maybe_accept( node, &AlignofExpr::expr );
 		}
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1298,10 +1315,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedOffsetofExpr::result );
 		}
 		maybe_accept( node, &UntypedOffsetofExpr::type   );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1314,10 +1332,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &OffsetofExpr::result );
 		}
 		maybe_accept( node, &OffsetofExpr::type   );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1330,10 +1349,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &OffsetPackExpr::result );
 		}
 		maybe_accept( node, &OffsetPackExpr::type   );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1346,5 +1366,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &LogicalExpr::result );
@@ -1352,5 +1373,5 @@
 		maybe_accept( node, &LogicalExpr::arg1 );
 		maybe_accept( node, &LogicalExpr::arg2 );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1363,5 +1384,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &ConditionalExpr::result );
@@ -1370,5 +1392,5 @@
 		maybe_accept( node, &ConditionalExpr::arg2 );
 		maybe_accept( node, &ConditionalExpr::arg3 );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1381,5 +1403,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &CommaExpr::result );
@@ -1387,5 +1410,5 @@
 		maybe_accept( node, &CommaExpr::arg1 );
 		maybe_accept( node, &CommaExpr::arg2 );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1398,10 +1421,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &TypeExpr::result );
 		}
 		maybe_accept( node, &TypeExpr::type );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1414,5 +1438,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &AsmExpr::result );
@@ -1420,5 +1445,5 @@
 		maybe_accept( node, &AsmExpr::constraint );
 		maybe_accept( node, &AsmExpr::operand    );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1431,10 +1456,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &ImplicitCopyCtorExpr::result );
 		}
 		maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1447,10 +1473,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &ConstructorExpr::result );
 		}
 		maybe_accept( node, &ConstructorExpr::callExpr );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1463,10 +1490,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &CompoundLiteralExpr::result );
 		}
 		maybe_accept( node, &CompoundLiteralExpr::init );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1479,5 +1507,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &RangeExpr::result );
@@ -1485,5 +1514,5 @@
 		maybe_accept( node, &RangeExpr::low    );
 		maybe_accept( node, &RangeExpr::high   );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1496,10 +1525,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedTupleExpr::result );
 		}
 		maybe_accept( node, &UntypedTupleExpr::exprs  );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1512,10 +1542,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &TupleExpr::result );
 		}
 		maybe_accept( node, &TupleExpr::exprs  );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1528,10 +1559,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &TupleIndexExpr::result );
 		}
 		maybe_accept( node, &TupleIndexExpr::tuple  );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1544,10 +1576,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &TupleAssignExpr::result );
 		}
 		maybe_accept( node, &TupleAssignExpr::stmtExpr );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1560,5 +1593,6 @@
 	VISIT_START( node );
 
-	VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
+	if ( __visit_children() ) {
+		// don't want statements from outer CompoundStmts to be added to this StmtExpr
 		// get the stmts that will need to be spliced in
 		auto stmts_before = __pass::stmtsToAddBefore( core, 0);
@@ -1577,5 +1611,5 @@
 		maybe_accept( node, &StmtExpr::returnDecls );
 		maybe_accept( node, &StmtExpr::dtors       );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1588,10 +1622,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &UniqueExpr::result );
 		}
 		maybe_accept( node, &UniqueExpr::expr   );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1604,5 +1639,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &UntypedInitExpr::result );
@@ -1610,5 +1646,5 @@
 		maybe_accept( node, &UntypedInitExpr::expr   );
 		// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1621,5 +1657,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &InitExpr::result );
@@ -1627,5 +1664,5 @@
 		maybe_accept( node, &InitExpr::expr   );
 		maybe_accept( node, &InitExpr::designation );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1638,5 +1675,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &DeletedExpr::result );
@@ -1644,5 +1682,5 @@
 		maybe_accept( node, &DeletedExpr::expr );
 		// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1655,10 +1693,11 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &DefaultArgExpr::result );
 		}
 		maybe_accept( node, &DefaultArgExpr::expr );
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1671,5 +1710,6 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
+		{
 			guard_symtab guard { *this };
 			maybe_accept( node, &GenericExpr::result );
@@ -1700,5 +1740,5 @@
 			node = n;
 		}
-	)
+	}
 
 	VISIT_END( Expr, node );
@@ -1729,8 +1769,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		// xxx - should PointerType visit/mutate dimension?
 		maybe_accept( node, &PointerType::base );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1743,8 +1783,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ArrayType::dimension );
 		maybe_accept( node, &ArrayType::base );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1757,7 +1797,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ReferenceType::base );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1770,8 +1810,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &QualifiedType::parent );
 		maybe_accept( node, &QualifiedType::child );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1784,5 +1824,5 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		// guard_forall_subs forall_guard { *this, node };
 		// mutate_forall( node );
@@ -1790,5 +1830,5 @@
 		maybe_accept( node, &FunctionType::returns );
 		maybe_accept( node, &FunctionType::params  );
-	})
+	}
 
 	VISIT_END( Type, node );
@@ -1803,8 +1843,8 @@
 	__pass::symtab::addStruct( core, 0, node->name );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &StructInstType::params );
-	})
+	}
 
 	VISIT_END( Type, node );
@@ -1819,8 +1859,8 @@
 	__pass::symtab::addUnion( core, 0, node->name );
 
-	VISIT({
+	if ( __visit_children() ) {
 		guard_symtab guard { *this };
 		maybe_accept( node, &UnionInstType::params );
-	})
+	}
 
 	VISIT_END( Type, node );
@@ -1833,7 +1873,7 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		maybe_accept( node, &EnumInstType::params );
-	})
+	}
 
 	VISIT_END( Type, node );
@@ -1846,7 +1886,7 @@
 	VISIT_START( node );
 
-	VISIT({
+	if ( __visit_children() ) {
 		maybe_accept( node, &TraitInstType::params );
-	})
+	}
 
 	VISIT_END( Type, node );
@@ -1859,5 +1899,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		{
 			maybe_accept( node, &TypeInstType::params );
@@ -1865,5 +1905,5 @@
 		// ensure that base re-bound if doing substitution
 		__pass::forall::replace( core, 0, node );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1876,8 +1916,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &TupleType::types );
 		maybe_accept( node, &TupleType::members );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1890,7 +1930,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &TypeofType::expr );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1903,7 +1943,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &VTableType::base );
-	)
+	}
 
 	VISIT_END( Type, node );
@@ -1953,5 +1993,7 @@
 	VISIT_START( node );
 
-	VISIT( maybe_accept( node, &Designation::designators ); )
+	if ( __visit_children() ) {
+		maybe_accept( node, &Designation::designators );
+	}
 
 	VISIT_END( Designation, node );
@@ -1964,7 +2006,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &SingleInit::value );
-	)
+	}
 
 	VISIT_END( Init, node );
@@ -1977,8 +2019,8 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ListInit::designations );
 		maybe_accept( node, &ListInit::initializers );
-	)
+	}
 
 	VISIT_END( Init, node );
@@ -1991,9 +2033,9 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &ConstructorInit::ctor );
 		maybe_accept( node, &ConstructorInit::dtor );
 		maybe_accept( node, &ConstructorInit::init );
-	)
+	}
 
 	VISIT_END( Init, node );
@@ -2006,7 +2048,7 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		maybe_accept( node, &Attribute::params );
-	)
+	}
 
 	VISIT_END( Attribute, node );
@@ -2019,5 +2061,5 @@
 	VISIT_START( node );
 
-	VISIT(
+	if ( __visit_children() ) {
 		{
 			bool mutated = false;
@@ -2035,5 +2077,5 @@
 			}
 		}
-	)
+	}
 
 	VISIT_END( TypeSubstitution, node );
@@ -2041,4 +2083,3 @@
 
 #undef VISIT_START
-#undef VISIT
 #undef VISIT_END