Context Navigation

source: src/AST/Pass.impl.hpp@ 93c10de

Visit:

ADT ast-experimental

Last change on this file since 93c10de was db6cdc0, checked in by JiadaL <j82liang@…>, 3 years ago
Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
Property mode set to `100644`
File size: 65.1 KB

Rev	Line
[04124c4]	1	//
	2	// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
	3	//
	4	// The contents of this file are covered under the licence agreement in the
	5	// file "LICENCE" distributed with Cforall.
	6	//
[e0016a5]	7	// ast::Pass.impl.hpp --
[04124c4]	8	//
	9	// Author : Thierry Delisle
	10	// Created On : Thu May 09 15::37::05 2019
	11	// Last Modified By :
	12	// Last Modified On :
	13	// Update Count :
	14	//
	15
[f47f887]	16	#pragma once
[04124c4]	17	// IWYU pragma: private, include "AST/Pass.hpp"
[f47f887]	18
[6d51bd7]	19	#include <type_traits>
	20	#include <unordered_map>
	21
[293dc1c]	22	#include "AST/TranslationUnit.hpp"
[c671112]	23	#include "AST/TypeSubstitution.hpp"
	24
[f47f887]	25	#define VISIT_START( node ) \
[04124c4]	26	using namespace ast; \
[a9762dc]	27	/* back-up the last known code location */ \
[95e5018]	28	__attribute__((unused)) auto loc_guard = ast::__pass::make_location_guard( core, node, 0 ); \
[f47f887]	29	/* back-up the visit children */ \
[7ff3e522]	30	__attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
[f47f887]	31	/* setup the scope for passes that want to run code at exit */ \
[7ff3e522]	32	__attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \
[c15085d]	33	/* begin tracing memory allocation if requested by this pass */ \
[7ff3e522]	34	__pass::beginTrace( core, 0 ); \
[f47f887]	35	/* call the implementation of the previsit of this pass */ \
[7ff3e522]	36	__pass::previsit( core, node, 0 );
[f47f887]	37
	38	#define VISIT_END( type, node ) \
	39	/* call the implementation of the postvisit of this pass */ \
[7ff3e522]	40	auto __return = __pass::postvisit( core, node, 0 ); \
[f47f887]	41	assertf(__return, "post visit should never return null"); \
[c15085d]	42	/* end tracing memory allocation if requested by this pass */ \
[7ff3e522]	43	__pass::endTrace( core, 0 ); \
[f47f887]	44	return __return;
	45
	46	#ifdef PEDANTIC_PASS_ASSERT
[6d51bd7]	47	#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
	48	#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
[f47f887]	49	#else
[6d51bd7]	50	#define __pedantic_pass_assert(...)
[f47f887]	51	#define __pedantic_pass_assertf(...)
	52	#endif
	53
	54	namespace ast {
[d3aa64f1]	55	template<typename node_t>
	56	node_t * shallowCopy( const node_t * node );
	57
[f47f887]	58	namespace __pass {
	59	// Check if this is either a null pointer or a pointer to an empty container
	60	template<typename T>
	61	static inline bool empty( T * ptr ) {
	62	return !ptr \|\| ptr->empty();
	63	}
	64
[d3aa64f1]	65	template< typename core_t, typename node_t >
	66	static inline node_t* mutate(const node_t *node) {
	67	return std::is_base_of<PureVisitor, core_t>::value ? ::ast::shallowCopy(node) : ::ast::mutate(node);
	68	}
	69
[6d51bd7]	70	//------------------------------
	71	template<typename it_t, template <class...> class container_t>
	72	static inline void take_all( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
[f47f887]	73	if(empty(decls)) return;
	74
[6d51bd7]	75	std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
[8a5530c]	76	return new DeclStmt( decl->location, decl );
[f47f887]	77	});
	78	decls->clear();
	79	if(mutated) *mutated = true;
	80	}
	81
[6d51bd7]	82	template<typename it_t, template <class...> class container_t>
[f8143a6]	83	static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
	84	if(empty(stmts)) return;
[f47f887]	85
[f8143a6]	86	std::move(stmts->begin(), stmts->end(), it);
	87	stmts->clear();
[f47f887]	88	if(mutated) *mutated = true;
	89	}
	90
[6d51bd7]	91	//------------------------------
	92	/// Check if should be skipped, different for pointers and containers
[f47f887]	93	template<typename node_t>
[6d51bd7]	94	bool skip( const ast::ptr<node_t> & val) {
	95	return !val;
[f47f887]	96	}
	97
[6d51bd7]	98	template< template <class...> class container_t, typename node_t >
	99	bool skip( const container_t<ast::ptr< node_t >> & val ) {
	100	return val.empty();
[f47f887]	101	}
	102
[6d51bd7]	103	//------------------------------
	104	/// Get the value to visit, different for pointers and containers
	105	template<typename node_t>
	106	auto get( const ast::ptr<node_t> & val, int ) -> decltype(val.get()) {
	107	return val.get();
	108	}
[f47f887]	109
[6d51bd7]	110	template<typename node_t>
	111	const node_t & get( const node_t & val, long) {
	112	return val;
	113	}
[f47f887]	114
[6d51bd7]	115	//------------------------------
	116	/// Check if value was mutated, different for pointers and containers
	117	template<typename lhs_t, typename rhs_t>
	118	bool differs( const lhs_t * old_val, const rhs_t * new_val ) {
	119	return old_val != new_val;
	120	}
	121
	122	template< template <class...> class container_t, typename node_t >
	123	bool differs( const container_t<ast::ptr< node_t >> &, const container_t<ast::ptr< node_t >> & new_val ) {
	124	return !new_val.empty();
[f47f887]	125	}
	126	}
	127
[f8143a6]	128	template< typename node_t >
	129	template< typename object_t, typename super_t, typename field_t >
[eb211bf]	130	void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
[f8143a6]	131	object->*field = value;
	132	}
	133
[7ff3e522]	134	template< typename core_t >
[f47f887]	135	template< typename node_t >
[7ff3e522]	136	auto ast::Pass< core_t >::call_accept( const node_t * node )
[eb211bf]	137	-> typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
[8a5530c]	138	{
[f47f887]	139	__pedantic_pass_assert( __visit_children() );
[e0e9a0b]	140	__pedantic_pass_assert( node );
[f47f887]	141
[6d51bd7]	142	static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
	143	static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
	144
[f8143a6]	145	auto nval = node->accept( *this );
[eb211bf]	146	__pass::result1<
[f8143a6]	147	typename std::remove_pointer< decltype( node->accept(*this) ) >::type
	148	> res;
	149	res.differs = nval != node;
	150	res.value = nval;
	151	return res;
[f47f887]	152	}
	153
[7ff3e522]	154	template< typename core_t >
[eb211bf]	155	__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
[f47f887]	156	__pedantic_pass_assert( __visit_children() );
	157	__pedantic_pass_assert( expr );
	158
[f8143a6]	159	auto nval = expr->accept( *this );
	160	return { nval != expr, nval };
[f47f887]	161	}
	162
[7ff3e522]	163	template< typename core_t >
[eb211bf]	164	__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
[f47f887]	165	__pedantic_pass_assert( __visit_children() );
	166	__pedantic_pass_assert( stmt );
	167
[f8143a6]	168	const ast::Stmt * nval = stmt->accept( *this );
	169	return { nval != stmt, nval };
[490fb92e]	170	}
	171
[9e23b446]	172	template< typename core_t >
	173	__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
	174	__pedantic_pass_assert( __visit_children() );
	175	__pedantic_pass_assert( expr );
	176
	177	const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
	178	if ( typeSubs_ptr && expr->env ) {
	179	*typeSubs_ptr = expr->env;
	180	}
	181
	182	auto nval = expr->accept( *this );
	183	return { nval != expr, nval };
	184	}
	185
[490fb92e]	186	template< typename core_t >
[eb211bf]	187	__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
[490fb92e]	188	__pedantic_pass_assert( __visit_children() );
	189	__pedantic_pass_assert( stmt );
	190
[f47f887]	191	// add a few useful symbols to the scope
	192	using __pass::empty;
	193
	194	// get the stmts/decls that will need to be spliced in
[a8b87d3]	195	auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
	196	auto stmts_after = __pass::stmtsToAddAfter ( core, 0 );
	197	auto decls_before = __pass::declsToAddBefore( core, 0 );
	198	auto decls_after = __pass::declsToAddAfter ( core, 0 );
[f47f887]	199
	200	// These may be modified by subnode but most be restored once we exit this statemnet.
[b2a11ba]	201	ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::typeSubs( core, 0 ) );
[23f99e1]	202	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
	203	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
	204	ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
	205	ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
[f47f887]	206
	207	// Now is the time to actually visit the node
[6d51bd7]	208	const ast::Stmt * nstmt = stmt->accept( *this );
[f47f887]	209
	210	// If the pass doesn't want to add anything then we are done
	211	if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
[f8143a6]	212	return { nstmt != stmt, nstmt };
[f47f887]	213	}
	214
	215	// Make sure that it is either adding statements or declartions but not both
	216	// this is because otherwise the order would be awkward to predict
	217	assert(( empty( stmts_before ) && empty( stmts_after ))
	218	\|\| ( empty( decls_before ) && empty( decls_after )) );
	219
	220	// Create a new Compound Statement to hold the new decls/stmts
[6d51bd7]	221	ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
[f47f887]	222
	223	// Take all the declarations that go before
	224	__pass::take_all( std::back_inserter( compound->kids ), decls_before );
	225	__pass::take_all( std::back_inserter( compound->kids ), stmts_before );
	226
	227	// Insert the original declaration
[6d51bd7]	228	compound->kids.emplace_back( nstmt );
[f47f887]	229
	230	// Insert all the declarations that go before
	231	__pass::take_all( std::back_inserter( compound->kids ), decls_after );
	232	__pass::take_all( std::back_inserter( compound->kids ), stmts_after );
	233
[f8143a6]	234	return {true, compound};
[f47f887]	235	}
	236
[6d51bd7]	237	template< template <class...> class container_t >
[f8143a6]	238	template< typename object_t, typename super_t, typename field_t >
[eb211bf]	239	void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
[f8143a6]	240	auto & container = object->*field;
	241	__pedantic_pass_assert( container.size() <= values.size() );
	242
	243	auto cit = enumerate(container).begin();
	244
	245	container_t<ptr<Stmt>> nvals;
[eb211bf]	246	for (delta & d : values) {
	247	if ( d.is_old ) {
[f8143a6]	248	__pedantic_pass_assert( cit.idx <= d.old_idx );
	249	std::advance( cit, d.old_idx - cit.idx );
	250	nvals.push_back( std::move( (*cit).val) );
	251	} else {
[eb211bf]	252	nvals.push_back( std::move(d.new_val) );
[f8143a6]	253	}
	254	}
	255
[eb211bf]	256	container = std::move(nvals);
	257	}
	258
	259	template< template <class...> class container_t >
	260	template< template <class...> class incontainer_t >
	261	void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
	262	if (!stmts \|\| stmts->empty()) return;
	263
	264	std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
	265	[](ast::ptr<ast::Stmt>& stmt) -> delta {
	266	return delta( stmt.release(), -1, false );
	267	});
	268	stmts->clear();
	269	differs = true;
	270	}
	271
	272	template< template<class...> class container_t >
	273	template< template<class...> class incontainer_t >
	274	void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
	275	if (!decls \|\| decls->empty()) return;
	276
	277	std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
	278	[](ast::ptr<ast::Decl>& decl) -> delta {
	279	auto loc = decl->location;
	280	auto stmt = new DeclStmt( loc, decl.release() );
	281	return delta( stmt, -1, false );
	282	});
	283	decls->clear();
	284	differs = true;
[f8143a6]	285	}
	286
	287	template< typename core_t >
	288	template< template <class...> class container_t >
[eb211bf]	289	__pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
[f47f887]	290	__pedantic_pass_assert( __visit_children() );
	291	if( statements.empty() ) return {};
	292
	293	// We are going to aggregate errors for all these statements
	294	SemanticErrorException errors;
	295
	296	// add a few useful symbols to the scope
	297	using __pass::empty;
	298
	299	// get the stmts/decls that will need to be spliced in
[6739590]	300	auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
	301	auto stmts_after = __pass::stmtsToAddAfter ( core, 0 );
	302	auto decls_before = __pass::declsToAddBefore( core, 0 );
	303	auto decls_after = __pass::declsToAddAfter ( core, 0 );
[f47f887]	304
	305	// These may be modified by subnode but most be restored once we exit this statemnet.
[23f99e1]	306	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
	307	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
	308	ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
	309	ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
[f47f887]	310
	311	// update pass statitistics
	312	pass_visitor_stats.depth++;
	313	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	314	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	315
[eb211bf]	316	__pass::resultNstmt<container_t> new_kids;
[f8143a6]	317	for( auto value : enumerate( statements ) ) {
[f47f887]	318	try {
[f8143a6]	319	size_t i = value.idx;
	320	const Stmt * stmt = value.val;
[f47f887]	321	__pedantic_pass_assert( stmt );
[6d51bd7]	322	const ast::Stmt * new_stmt = stmt->accept( *this );
[f47f887]	323	assert( new_stmt );
[f8143a6]	324	if(new_stmt != stmt ) { new_kids.differs = true; }
[f47f887]	325
	326	// Make sure that it is either adding statements or declartions but not both
	327	// this is because otherwise the order would be awkward to predict
	328	assert(( empty( stmts_before ) && empty( stmts_after ))
	329	\|\| ( empty( decls_before ) && empty( decls_after )) );
	330
	331	// Take all the statements which should have gone after, N/A for first iteration
[f8143a6]	332	new_kids.take_all( decls_before );
	333	new_kids.take_all( stmts_before );
[f47f887]	334
	335	// Now add the statement if there is one
[f8143a6]	336	if(new_stmt != stmt) {
	337	new_kids.values.emplace_back( new_stmt, i, false );
	338	} else {
	339	new_kids.values.emplace_back( nullptr, i, true );
	340	}
[f47f887]	341
	342	// Take all the declarations that go before
[f8143a6]	343	new_kids.take_all( decls_after );
	344	new_kids.take_all( stmts_after );
[f47f887]	345	}
	346	catch ( SemanticErrorException &e ) {
	347	errors.append( e );
	348	}
	349	}
	350	pass_visitor_stats.depth--;
	351	if ( !errors.isEmpty() ) { throw errors; }
	352
[f8143a6]	353	return new_kids;
	354	}
	355
	356	template< template <class...> class container_t, typename node_t >
	357	template< typename object_t, typename super_t, typename field_t >
[eb211bf]	358	void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
[f8143a6]	359	auto & container = object->*field;
	360	__pedantic_pass_assert( container.size() == values.size() );
	361
	362	for(size_t i = 0; i < container.size(); i++) {
	363	// Take all the elements that are different in 'values'
	364	// and swap them into 'container'
[8631c84]	365	if( values[i] != nullptr ) swap(container[i], values[i]);
[f8143a6]	366	}
	367
	368	// Now the original containers should still have the unchanged values
	369	// but also contain the new values
[f47f887]	370	}
	371
[7ff3e522]	372	template< typename core_t >
[6d51bd7]	373	template< template <class...> class container_t, typename node_t >
[eb211bf]	374	__pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
[f47f887]	375	__pedantic_pass_assert( __visit_children() );
	376	if( container.empty() ) return {};
	377	SemanticErrorException errors;
	378
	379	pass_visitor_stats.depth++;
	380	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	381	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	382
	383	bool mutated = false;
[f8143a6]	384	container_t<ptr<node_t>> new_kids;
[f47f887]	385	for ( const node_t * node : container ) {
	386	try {
	387	__pedantic_pass_assert( node );
[6d51bd7]	388	const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
[f8143a6]	389	if(new_stmt != node ) {
	390	mutated = true;
	391	new_kids.emplace_back( new_stmt );
	392	} else {
	393	new_kids.emplace_back( nullptr );
	394	}
[f47f887]	395
	396	}
	397	catch( SemanticErrorException &e ) {
	398	errors.append( e );
	399	}
	400	}
[f8143a6]	401
	402	__pedantic_pass_assert( new_kids.size() == container.size() );
[f47f887]	403	pass_visitor_stats.depth--;
	404	if ( ! errors.isEmpty() ) { throw errors; }
	405
[eb211bf]	406	return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
[6d51bd7]	407	}
	408
[7ff3e522]	409	template< typename core_t >
[2377ca2]	410	template<typename node_t, typename super_t, typename field_t>
[7ff3e522]	411	void ast::Pass< core_t >::maybe_accept(
[6d51bd7]	412	const node_t * & parent,
[2377ca2]	413	field_t super_t::*field
[6d51bd7]	414	) {
[2377ca2]	415	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
[6d51bd7]	416
[2377ca2]	417	if(__pass::skip(parent->*field)) return;
	418	const auto & old_val = __pass::get(parent->*field, 0);
[6d51bd7]	419
	420	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
	421
	422	auto new_val = call_accept( old_val );
	423
[f8143a6]	424	static_assert( !std::is_same<const ast::Node , decltype(new_val)>::value / \|\| std::is_same<int, decltype(old_val)>::value */, "ERROR");
[6d51bd7]	425
[f8143a6]	426	if( new_val.differs ) {
[d3aa64f1]	427	auto new_parent = __pass::mutate<core_t>(parent);
[2377ca2]	428	new_val.apply(new_parent, field);
[6d51bd7]	429	parent = new_parent;
	430	}
[f47f887]	431	}
[6d51bd7]	432
[9e23b446]	433	template< typename core_t >
	434	template<typename node_t, typename super_t, typename field_t>
	435	void ast::Pass< core_t >::maybe_accept_top(
	436	const node_t * & parent,
	437	field_t super_t::*field
	438	) {
	439	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
	440
	441	if(__pass::skip(parent->*field)) return;
	442	const auto & old_val = __pass::get(parent->*field, 0);
	443
	444	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
	445
	446	auto new_val = call_accept_top( old_val );
	447
	448	static_assert( !std::is_same<const ast::Node , decltype(new_val)>::value / \|\| std::is_same<int, decltype(old_val)>::value */, "ERROR");
	449
	450	if( new_val.differs ) {
	451	auto new_parent = __pass::mutate<core_t>(parent);
	452	new_val.apply(new_parent, field);
	453	parent = new_parent;
	454	}
	455	}
	456
[490fb92e]	457	template< typename core_t >
[2377ca2]	458	template<typename node_t, typename super_t, typename field_t>
[490fb92e]	459	void ast::Pass< core_t >::maybe_accept_as_compound(
	460	const node_t * & parent,
[2377ca2]	461	field_t super_t::*child
[490fb92e]	462	) {
[2377ca2]	463	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
[490fb92e]	464
	465	if(__pass::skip(parent->*child)) return;
	466	const auto & old_val = __pass::get(parent->*child, 0);
	467
	468	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
	469
	470	auto new_val = call_accept_as_compound( old_val );
	471
	472	static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value \|\| std::is_same<int, decltype(old_val)>::value, "ERROR");
	473
[f8143a6]	474	if( new_val.differs ) {
[490fb92e]	475	auto new_parent = __pass::mutate<core_t>(parent);
[f8143a6]	476	new_val.apply( new_parent, child );
[490fb92e]	477	parent = new_parent;
	478	}
	479	}
	480
[f47f887]	481	}
	482
	483	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	484	//========================================================================================================================================================================
	485	//========================================================================================================================================================================
	486	//========================================================================================================================================================================
	487	//========================================================================================================================================================================
	488	//========================================================================================================================================================================
	489	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	490
[7ff3e522]	491	template< typename core_t >
	492	inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
[04124c4]	493	// We are going to aggregate errors for all these statements
	494	SemanticErrorException errors;
	495
	496	// add a few useful symbols to the scope
	497	using __pass::empty;
	498
	499	// get the stmts/decls that will need to be spliced in
[7ff3e522]	500	auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
	501	auto decls_after = __pass::declsToAddAfter ( visitor.core, 0);
[04124c4]	502
	503	// update pass statitistics
	504	pass_visitor_stats.depth++;
	505	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	506	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	507
	508	for ( std::list< ast::ptr<ast::Decl> >::iterator i = decls.begin(); ; ++i ) {
	509	// splice in new declarations after previous decl
	510	if ( !empty( decls_after ) ) { decls.splice( i, *decls_after ); }
	511
	512	if ( i == decls.end() ) break;
	513
	514	try {
	515	// run visitor on declaration
	516	ast::ptr<ast::Decl> & node = *i;
	517	assert( node );
	518	node = node->accept( visitor );
	519	}
	520	catch( SemanticErrorException &e ) {
[e00c22f]	521	if (__pass::on_error (visitor.core, *i, 0))
[0dd9a5e]	522	errors.append( e );
[04124c4]	523	}
	524
	525	// splice in new declarations before current decl
	526	if ( !empty( decls_before ) ) { decls.splice( i, *decls_before ); }
	527	}
	528	pass_visitor_stats.depth--;
	529	if ( !errors.isEmpty() ) { throw errors; }
	530	}
	531
[293dc1c]	532	template< typename core_t >
	533	inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
[c600df1]	534	if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
	535	ValueGuard<const TranslationUnit > guard( ptr );
	536	*ptr = &unit;
	537	return ast::accept_all( unit.decls, visitor );
	538	} else {
	539	return ast::accept_all( unit.decls, visitor );
	540	}
[293dc1c]	541	}
	542
[f47f887]	543	// A NOTE ON THE ORDER OF TRAVERSAL
	544	//
	545	// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is
	546	// no such thing as a recursive type or typedef.
	547	//
	548	// typedef struct { T *x; } T; // never allowed
	549	//
	550	// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
	551	// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
	552	// declaration).
	553	//
	554	// struct T { struct T *x; }; // allowed
	555	//
	556	// It is important to add the complete type to the symbol table after the members/base has been traversed, since that
	557	// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
	558	// queried later in this pass.
	559
	560	//--------------------------------------------------------------------------
	561	// ObjectDecl
[7ff3e522]	562	template< typename core_t >
	563	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
[f47f887]	564	VISIT_START( node );
	565
[e21f253]	566	if ( __visit_children() ) {
[f47f887]	567	{
[0e42794]	568	guard_symtab guard { *this };
[23f99e1]	569	maybe_accept( node, &ObjectDecl::type );
[f47f887]	570	}
[23f99e1]	571	maybe_accept( node, &ObjectDecl::init );
	572	maybe_accept( node, &ObjectDecl::bitfieldWidth );
	573	maybe_accept( node, &ObjectDecl::attributes );
[e21f253]	574	}
[f47f887]	575
[7ff3e522]	576	__pass::symtab::addId( core, 0, node );
[f47f887]	577
[04124c4]	578	VISIT_END( DeclWithType, node );
[f47f887]	579	}
	580
[23f99e1]	581	//--------------------------------------------------------------------------
	582	// FunctionDecl
[7ff3e522]	583	template< typename core_t >
	584	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
[23f99e1]	585	VISIT_START( node );
	586
[7ff3e522]	587	__pass::symtab::addId( core, 0, node );
[23f99e1]	588
[e21f253]	589	if ( __visit_children() ) {
	590	maybe_accept( node, &FunctionDecl::withExprs );
	591	}
[23f99e1]	592	{
	593	// with clause introduces a level of scope (for the with expression members).
[0e42794]	594	// with clause exprs are added to the symbol table before parameters so that parameters
[23f99e1]	595	// shadow with exprs and not the other way around.
[0e42794]	596	guard_symtab guard { *this };
[7ff3e522]	597	__pass::symtab::addWith( core, 0, node->withExprs, node );
[23f99e1]	598	{
[0e42794]	599	guard_symtab guard { *this };
[23f99e1]	600	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
[e8616b6]	601	// This is a C name and so has C linkage.
[798a8b3]	602	static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
[9ea38de]	603	CodeLocation{}, "__func__",
	604	new ast::ArrayType{
	605	new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
[8a5530c]	606	nullptr, VariableLen, DynamicDim
[e8616b6]	607	},
	608	nullptr,
	609	ast::Storage::Classes(),
	610	ast::Linkage::C,
[9ea38de]	611	} };
[7ff3e522]	612	__pass::symtab::addId( core, 0, func );
[e21f253]	613	if ( __visit_children() ) {
[3e5dd913]	614	maybe_accept( node, &FunctionDecl::type_params );
	615	maybe_accept( node, &FunctionDecl::assertions );
[4ec9513]	616	maybe_accept( node, &FunctionDecl::params );
	617	maybe_accept( node, &FunctionDecl::returns );
	618	maybe_accept( node, &FunctionDecl::type );
[f2ff0a6]	619	maybe_accept( node, &FunctionDecl::attributes );
[c6c682cf]	620	// First remember that we are now within a function.
[23f99e1]	621	ValueGuard< bool > oldInFunction( inFunction );
	622	inFunction = true;
[c6c682cf]	623	// The function body needs to have the same scope as parameters.
	624	// A CompoundStmt will not enter a new scope if atFunctionTop is true.
	625	ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
	626	atFunctionTop = true;
[8a5530c]	627	maybe_accept( node, &FunctionDecl::stmts );
[e21f253]	628	}
[23f99e1]	629	}
	630	}
	631
	632	VISIT_END( DeclWithType, node );
	633	}
	634
	635	//--------------------------------------------------------------------------
	636	// StructDecl
[7ff3e522]	637	template< typename core_t >
	638	const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
[23f99e1]	639	VISIT_START( node );
	640
	641	// make up a forward declaration and add it before processing the members
	642	// needs to be on the heap because addStruct saves the pointer
[7ff3e522]	643	__pass::symtab::addStructFwd( core, 0, node );
[23f99e1]	644
[e21f253]	645	if ( __visit_children() ) {
[0e42794]	646	guard_symtab guard { * this };
[798a8b3]	647	maybe_accept( node, &StructDecl::params );
	648	maybe_accept( node, &StructDecl::members );
	649	maybe_accept( node, &StructDecl::attributes );
[e21f253]	650	}
[23f99e1]	651
	652	// this addition replaces the forward declaration
[7ff3e522]	653	__pass::symtab::addStruct( core, 0, node );
[23f99e1]	654
	655	VISIT_END( Decl, node );
	656	}
	657
	658	//--------------------------------------------------------------------------
	659	// UnionDecl
[7ff3e522]	660	template< typename core_t >
	661	const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
[23f99e1]	662	VISIT_START( node );
	663
	664	// make up a forward declaration and add it before processing the members
[7ff3e522]	665	__pass::symtab::addUnionFwd( core, 0, node );
[23f99e1]	666
[e21f253]	667	if ( __visit_children() ) {
[0e42794]	668	guard_symtab guard { * this };
[798a8b3]	669	maybe_accept( node, &UnionDecl::params );
	670	maybe_accept( node, &UnionDecl::members );
	671	maybe_accept( node, &UnionDecl::attributes );
[e21f253]	672	}
[23f99e1]	673
[7ff3e522]	674	__pass::symtab::addUnion( core, 0, node );
[23f99e1]	675
	676	VISIT_END( Decl, node );
	677	}
	678
	679	//--------------------------------------------------------------------------
	680	// EnumDecl
[7ff3e522]	681	template< typename core_t >
	682	const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
[23f99e1]	683	VISIT_START( node );
	684
[7ff3e522]	685	__pass::symtab::addEnum( core, 0, node );
[23f99e1]	686
[e21f253]	687	if ( __visit_children() ) {
[e4d7c1c]	688	if ( node->hide == ast::EnumDecl::EnumHiding::Hide ) {
	689	guard_symtab guard { *this };
	690	maybe_accept( node, &EnumDecl::base );
	691	maybe_accept( node, &EnumDecl::params );
	692	maybe_accept( node, &EnumDecl::members );
	693	maybe_accept( node, &EnumDecl::attributes );
	694	} else {
	695	maybe_accept( node, &EnumDecl::base );
	696	maybe_accept( node, &EnumDecl::params );
	697	maybe_accept( node, &EnumDecl::members );
	698	maybe_accept( node, &EnumDecl::attributes );
	699	}
[e21f253]	700	}
[23f99e1]	701
	702	VISIT_END( Decl, node );
	703	}
	704
	705	//--------------------------------------------------------------------------
	706	// TraitDecl
[7ff3e522]	707	template< typename core_t >
	708	const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
[23f99e1]	709	VISIT_START( node );
	710
[e21f253]	711	if ( __visit_children() ) {
[0e42794]	712	guard_symtab guard { *this };
[798a8b3]	713	maybe_accept( node, &TraitDecl::params );
	714	maybe_accept( node, &TraitDecl::members );
	715	maybe_accept( node, &TraitDecl::attributes );
[e21f253]	716	}
[23f99e1]	717
[7ff3e522]	718	__pass::symtab::addTrait( core, 0, node );
[23f99e1]	719
	720	VISIT_END( Decl, node );
	721	}
	722
	723	//--------------------------------------------------------------------------
	724	// TypeDecl
[7ff3e522]	725	template< typename core_t >
	726	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
[23f99e1]	727	VISIT_START( node );
	728
[e21f253]	729	if ( __visit_children() ) {
[0e42794]	730	guard_symtab guard { *this };
[87701b6]	731	maybe_accept( node, &TypeDecl::base );
[e21f253]	732	}
[23f99e1]	733
	734	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	735	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	736	// and may depend on the type itself
[7ff3e522]	737	__pass::symtab::addType( core, 0, node );
[23f99e1]	738
[e21f253]	739	if ( __visit_children() ) {
[8a5530c]	740	maybe_accept( node, &TypeDecl::assertions );
[23f99e1]	741
	742	{
[0e42794]	743	guard_symtab guard { *this };
[23f99e1]	744	maybe_accept( node, &TypeDecl::init );
	745	}
[e21f253]	746	}
[23f99e1]	747
	748	VISIT_END( Decl, node );
	749	}
	750
	751	//--------------------------------------------------------------------------
	752	// TypedefDecl
[7ff3e522]	753	template< typename core_t >
	754	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
[23f99e1]	755	VISIT_START( node );
	756
[e21f253]	757	if ( __visit_children() ) {
[0e42794]	758	guard_symtab guard { *this };
[87701b6]	759	maybe_accept( node, &TypedefDecl::base );
[e21f253]	760	}
[23f99e1]	761
[7ff3e522]	762	__pass::symtab::addType( core, 0, node );
[23f99e1]	763
[e21f253]	764	if ( __visit_children() ) {
	765	maybe_accept( node, &TypedefDecl::assertions );
	766	}
[23f99e1]	767
	768	VISIT_END( Decl, node );
	769	}
	770
	771	//--------------------------------------------------------------------------
	772	// AsmDecl
[7ff3e522]	773	template< typename core_t >
	774	const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
[23f99e1]	775	VISIT_START( node );
	776
[e21f253]	777	if ( __visit_children() ) {
[23f99e1]	778	maybe_accept( node, &AsmDecl::stmt );
[e21f253]	779	}
[23f99e1]	780
	781	VISIT_END( AsmDecl, node );
	782	}
	783
[2d019af]	784	//--------------------------------------------------------------------------
	785	// DirectiveDecl
	786	template< typename core_t >
	787	const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
	788	VISIT_START( node );
	789
[e21f253]	790	if ( __visit_children() ) {
[2d019af]	791	maybe_accept( node, &DirectiveDecl::stmt );
[e21f253]	792	}
[2d019af]	793
	794	VISIT_END( DirectiveDecl, node );
	795	}
	796
[23f99e1]	797	//--------------------------------------------------------------------------
	798	// StaticAssertDecl
[7ff3e522]	799	template< typename core_t >
	800	const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
[23f99e1]	801	VISIT_START( node );
	802
[e21f253]	803	if ( __visit_children() ) {
[9e23b446]	804	maybe_accept_top( node, &StaticAssertDecl::cond );
[112fe04]	805	maybe_accept( node, &StaticAssertDecl::msg );
[e21f253]	806	}
[23f99e1]	807
	808	VISIT_END( StaticAssertDecl, node );
	809	}
	810
[e874605]	811	//--------------------------------------------------------------------------
[19a8c40]	812	// InlineMemberDecl
[e874605]	813	template< typename core_t >
[71806e0]	814	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
[e874605]	815	VISIT_START( node );
	816
	817	if ( __visit_children() ) {
	818	{
	819	guard_symtab guard { *this };
[71806e0]	820	maybe_accept( node, &InlineMemberDecl::type );
[e874605]	821	}
	822	}
	823
	824	VISIT_END( DeclWithType, node );
	825	}
	826
[23f99e1]	827	//--------------------------------------------------------------------------
	828	// CompoundStmt
[7ff3e522]	829	template< typename core_t >
	830	const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
[23f99e1]	831	VISIT_START( node );
[e21f253]	832
	833	if ( __visit_children() ) {
[c6c682cf]	834	// Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
	835	auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
[16ba4a6f]	836	if ( enterScope ) {
	837	__pass::symtab::enter(core, 0);
	838	__pass::scope::enter(core, 0);
	839	}
[c6c682cf]	840	}, [this, leaveScope = !this->atFunctionTop]() {
[16ba4a6f]	841	if ( leaveScope ) {
	842	__pass::symtab::leave(core, 0);
	843	__pass::scope::leave(core, 0);
	844	}
[23f99e1]	845	});
[82f791f]	846	ValueGuard< bool > guard2( atFunctionTop );
	847	atFunctionTop = false;
[23f99e1]	848	guard_scope guard3 { *this };
	849	maybe_accept( node, &CompoundStmt::kids );
[e21f253]	850	}
	851
[23f99e1]	852	VISIT_END( CompoundStmt, node );
	853	}
	854
[8a5530c]	855	//--------------------------------------------------------------------------
	856	// ExprStmt
[7ff3e522]	857	template< typename core_t >
	858	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
[8a5530c]	859	VISIT_START( node );
	860
[e21f253]	861	if ( __visit_children() ) {
[9e23b446]	862	maybe_accept_top( node, &ExprStmt::expr );
[e21f253]	863	}
[8a5530c]	864
	865	VISIT_END( Stmt, node );
	866	}
	867
	868	//--------------------------------------------------------------------------
	869	// AsmStmt
[7ff3e522]	870	template< typename core_t >
	871	const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
[8a5530c]	872	VISIT_START( node )
	873
[e21f253]	874	if ( __visit_children() ) {
[8a5530c]	875	maybe_accept( node, &AsmStmt::instruction );
	876	maybe_accept( node, &AsmStmt::output );
	877	maybe_accept( node, &AsmStmt::input );
	878	maybe_accept( node, &AsmStmt::clobber );
[e21f253]	879	}
[8a5530c]	880
	881	VISIT_END( Stmt, node );
	882	}
	883
	884	//--------------------------------------------------------------------------
	885	// DirectiveStmt
[7ff3e522]	886	template< typename core_t >
	887	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
[8a5530c]	888	VISIT_START( node )
	889
	890	VISIT_END( Stmt, node );
	891	}
	892
	893	//--------------------------------------------------------------------------
	894	// IfStmt
[7ff3e522]	895	template< typename core_t >
	896	const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
[8a5530c]	897	VISIT_START( node );
[17a0228a]	898
[e21f253]	899	if ( __visit_children() ) {
[8a5530c]	900	// if statements introduce a level of scope (for the initialization)
[0e42794]	901	guard_symtab guard { *this };
[8a5530c]	902	maybe_accept( node, &IfStmt::inits );
[9e23b446]	903	maybe_accept_top( node, &IfStmt::cond );
[3b0bc16]	904	maybe_accept_as_compound( node, &IfStmt::then );
	905	maybe_accept_as_compound( node, &IfStmt::else_ );
[e21f253]	906	}
[17a0228a]	907
[8a5530c]	908	VISIT_END( Stmt, node );
	909	}
	910
	911	//--------------------------------------------------------------------------
[3b0bc16]	912	// WhileDoStmt
[7ff3e522]	913	template< typename core_t >
[3b0bc16]	914	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
[8a5530c]	915	VISIT_START( node );
	916
[e21f253]	917	if ( __visit_children() ) {
[8a5530c]	918	// while statements introduce a level of scope (for the initialization)
[0e42794]	919	guard_symtab guard { *this };
[3b0bc16]	920	maybe_accept( node, &WhileDoStmt::inits );
[9e23b446]	921	maybe_accept_top( node, &WhileDoStmt::cond );
[3b0bc16]	922	maybe_accept_as_compound( node, &WhileDoStmt::body );
[e21f253]	923	}
[8a5530c]	924
	925	VISIT_END( Stmt, node );
	926	}
[23f99e1]	927
[87701b6]	928	//--------------------------------------------------------------------------
	929	// ForStmt
[7ff3e522]	930	template< typename core_t >
	931	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
[87701b6]	932	VISIT_START( node );
	933
[e21f253]	934	if ( __visit_children() ) {
[87701b6]	935	// for statements introduce a level of scope (for the initialization)
[0e42794]	936	guard_symtab guard { *this };
[490fb92e]	937	// xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
[87701b6]	938	maybe_accept( node, &ForStmt::inits );
[9e23b446]	939	maybe_accept_top( node, &ForStmt::cond );
	940	maybe_accept_top( node, &ForStmt::inc );
[490fb92e]	941	maybe_accept_as_compound( node, &ForStmt::body );
[e21f253]	942	}
[87701b6]	943
	944	VISIT_END( Stmt, node );
	945	}
	946
	947	//--------------------------------------------------------------------------
	948	// SwitchStmt
[7ff3e522]	949	template< typename core_t >
	950	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
[87701b6]	951	VISIT_START( node );
	952
[e21f253]	953	if ( __visit_children() ) {
[9e23b446]	954	maybe_accept_top( node, &SwitchStmt::cond );
[400b8be]	955	maybe_accept( node, &SwitchStmt::cases );
[e21f253]	956	}
[87701b6]	957
	958	VISIT_END( Stmt, node );
	959	}
	960
	961	//--------------------------------------------------------------------------
[400b8be]	962	// CaseClause
[7ff3e522]	963	template< typename core_t >
[400b8be]	964	const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
[87701b6]	965	VISIT_START( node );
	966
[e21f253]	967	if ( __visit_children() ) {
[9e23b446]	968	maybe_accept_top( node, &CaseClause::cond );
[400b8be]	969	maybe_accept( node, &CaseClause::stmts );
[e21f253]	970	}
[87701b6]	971
[400b8be]	972	VISIT_END( CaseClause, node );
[87701b6]	973	}
	974
	975	//--------------------------------------------------------------------------
	976	// BranchStmt
[7ff3e522]	977	template< typename core_t >
	978	const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
[87701b6]	979	VISIT_START( node );
	980	VISIT_END( Stmt, node );
	981	}
	982
	983	//--------------------------------------------------------------------------
	984	// ReturnStmt
[7ff3e522]	985	template< typename core_t >
	986	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
[87701b6]	987	VISIT_START( node );
	988
[e21f253]	989	if ( __visit_children() ) {
[9e23b446]	990	maybe_accept_top( node, &ReturnStmt::expr );
[e21f253]	991	}
[87701b6]	992
	993	VISIT_END( Stmt, node );
	994	}
	995
	996	//--------------------------------------------------------------------------
	997	// ThrowStmt
[7ff3e522]	998	template< typename core_t >
	999	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
[e61207e7]	1000	VISIT_START( node );
[87701b6]	1001
[e21f253]	1002	if ( __visit_children() ) {
[e61207e7]	1003	maybe_accept( node, &ThrowStmt::expr );
	1004	maybe_accept( node, &ThrowStmt::target );
[e21f253]	1005	}
[e61207e7]	1006
	1007	VISIT_END( Stmt, node );
	1008	}
	1009
	1010	//--------------------------------------------------------------------------
	1011	// TryStmt
[7ff3e522]	1012	template< typename core_t >
	1013	const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
[87701b6]	1014	VISIT_START( node );
	1015
[e21f253]	1016	if ( __visit_children() ) {
[acd80b4]	1017	maybe_accept( node, &TryStmt::body );
	1018	maybe_accept( node, &TryStmt::handlers );
	1019	maybe_accept( node, &TryStmt::finally );
[e21f253]	1020	}
[87701b6]	1021
[e61207e7]	1022	VISIT_END( Stmt, node );
[87701b6]	1023	}
	1024
[10a1225]	1025	//--------------------------------------------------------------------------
[400b8be]	1026	// CatchClause
[7ff3e522]	1027	template< typename core_t >
[400b8be]	1028	const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
[10a1225]	1029	VISIT_START( node );
	1030
[e21f253]	1031	if ( __visit_children() ) {
[10a1225]	1032	// catch statements introduce a level of scope (for the caught exception)
[0e42794]	1033	guard_symtab guard { *this };
[400b8be]	1034	maybe_accept( node, &CatchClause::decl );
[9e23b446]	1035	maybe_accept_top( node, &CatchClause::cond );
[400b8be]	1036	maybe_accept_as_compound( node, &CatchClause::body );
[e21f253]	1037	}
[10a1225]	1038
[400b8be]	1039	VISIT_END( CatchClause, node );
[10a1225]	1040	}
	1041
	1042	//--------------------------------------------------------------------------
[400b8be]	1043	// FinallyClause
[7ff3e522]	1044	template< typename core_t >
[400b8be]	1045	const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
[10a1225]	1046	VISIT_START( node );
	1047
[e21f253]	1048	if ( __visit_children() ) {
[400b8be]	1049	maybe_accept( node, &FinallyClause::body );
[e21f253]	1050	}
[10a1225]	1051
[400b8be]	1052	VISIT_END( FinallyClause, node );
[10a1225]	1053	}
	1054
[37cdd97]	1055	//--------------------------------------------------------------------------
	1056	// FinallyStmt
[7ff3e522]	1057	template< typename core_t >
	1058	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
[37cdd97]	1059	VISIT_START( node );
	1060
[e21f253]	1061	if ( __visit_children() ) {
[37cdd97]	1062	maybe_accept( node, &SuspendStmt::then );
[e21f253]	1063	}
[37cdd97]	1064
	1065	VISIT_END( Stmt, node );
	1066	}
	1067
[10a1225]	1068	//--------------------------------------------------------------------------
	1069	// WaitForStmt
[7ff3e522]	1070	template< typename core_t >
	1071	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
[10a1225]	1072	VISIT_START( node );
	1073
[e21f253]	1074	if ( __visit_children() ) {
[f6e6a55]	1075	maybe_accept( node, &WaitForStmt::clauses );
	1076	maybe_accept( node, &WaitForStmt::timeout_time );
	1077	maybe_accept( node, &WaitForStmt::timeout_stmt );
	1078	maybe_accept( node, &WaitForStmt::timeout_cond );
	1079	maybe_accept( node, &WaitForStmt::else_stmt );
	1080	maybe_accept( node, &WaitForStmt::else_cond );
[e21f253]	1081	}
[e0016a5]	1082
[f6e6a55]	1083	VISIT_END( Stmt, node );
	1084	}
	1085
	1086	//--------------------------------------------------------------------------
	1087	// WaitForClause
	1088	template< typename core_t >
	1089	const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
	1090	VISIT_START( node );
[10a1225]	1091
[e21f253]	1092	if ( __visit_children() ) {
[f6e6a55]	1093	maybe_accept( node, &WaitForClause::target_func );
	1094	maybe_accept( node, &WaitForClause::target_args );
	1095	maybe_accept( node, &WaitForClause::stmt );
	1096	maybe_accept( node, &WaitForClause::cond );
[e21f253]	1097	}
[10a1225]	1098
[f6e6a55]	1099	VISIT_END( WaitForClause, node );
[10a1225]	1100	}
	1101
	1102	//--------------------------------------------------------------------------
	1103	// WithStmt
[7ff3e522]	1104	template< typename core_t >
	1105	const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
[10a1225]	1106	VISIT_START( node );
	1107
[e21f253]	1108	if ( __visit_children() ) {
[10a1225]	1109	maybe_accept( node, &WithStmt::exprs );
	1110	{
	1111	// catch statements introduce a level of scope (for the caught exception)
[0e42794]	1112	guard_symtab guard { *this };
[7ff3e522]	1113	__pass::symtab::addWith( core, 0, node->exprs, node );
[10a1225]	1114	maybe_accept( node, &WithStmt::stmt );
	1115	}
[e21f253]	1116	}
	1117
[10a1225]	1118	VISIT_END( Stmt, node );
	1119	}
	1120
	1121	//--------------------------------------------------------------------------
	1122	// NullStmt
[7ff3e522]	1123	template< typename core_t >
	1124	const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
[10a1225]	1125	VISIT_START( node );
	1126	VISIT_END( NullStmt, node );
	1127	}
	1128
	1129	//--------------------------------------------------------------------------
	1130	// DeclStmt
[7ff3e522]	1131	template< typename core_t >
	1132	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
[10a1225]	1133	VISIT_START( node );
	1134
[e21f253]	1135	if ( __visit_children() ) {
[10a1225]	1136	maybe_accept( node, &DeclStmt::decl );
[e21f253]	1137	}
[10a1225]	1138
	1139	VISIT_END( Stmt, node );
	1140	}
	1141
	1142	//--------------------------------------------------------------------------
	1143	// ImplicitCtorDtorStmt
[7ff3e522]	1144	template< typename core_t >
	1145	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
[10a1225]	1146	VISIT_START( node );
	1147
	1148	// For now this isn't visited, it is unclear if this causes problem
	1149	// if all tests are known to pass, remove this code
[e21f253]	1150	if ( __visit_children() ) {
[c570806]	1151	maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
[e21f253]	1152	}
[10a1225]	1153
	1154	VISIT_END( Stmt, node );
	1155	}
	1156
[6cebfef]	1157	//--------------------------------------------------------------------------
	1158	// MutexStmt
	1159	template< typename core_t >
	1160	const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
	1161	VISIT_START( node );
	1162
[e21f253]	1163	if ( __visit_children() ) {
[6cebfef]	1164	// mutex statements introduce a level of scope (for the initialization)
	1165	guard_symtab guard { *this };
	1166	maybe_accept( node, &MutexStmt::stmt );
	1167	maybe_accept( node, &MutexStmt::mutexObjs );
[e21f253]	1168	}
[6cebfef]	1169
	1170	VISIT_END( Stmt, node );
	1171	}
	1172
[17a0228a]	1173	//--------------------------------------------------------------------------
	1174	// ApplicationExpr
[7ff3e522]	1175	template< typename core_t >
	1176	const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
[17a0228a]	1177	VISIT_START( node );
	1178
[e21f253]	1179	if ( __visit_children() ) {
[17a0228a]	1180	{
[0e42794]	1181	guard_symtab guard { *this };
[17a0228a]	1182	maybe_accept( node, &ApplicationExpr::result );
	1183	}
	1184	maybe_accept( node, &ApplicationExpr::func );
	1185	maybe_accept( node, &ApplicationExpr::args );
[e21f253]	1186	}
[17a0228a]	1187
	1188	VISIT_END( Expr, node );
	1189	}
	1190
	1191	//--------------------------------------------------------------------------
	1192	// UntypedExpr
[7ff3e522]	1193	template< typename core_t >
	1194	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
[17a0228a]	1195	VISIT_START( node );
	1196
[e21f253]	1197	if ( __visit_children() ) {
[17a0228a]	1198	{
[0e42794]	1199	guard_symtab guard { *this };
[17a0228a]	1200	maybe_accept( node, &UntypedExpr::result );
	1201	}
	1202
	1203	maybe_accept( node, &UntypedExpr::args );
[e21f253]	1204	}
[17a0228a]	1205
	1206	VISIT_END( Expr, node );
	1207	}
	1208
	1209	//--------------------------------------------------------------------------
	1210	// NameExpr
[7ff3e522]	1211	template< typename core_t >
	1212	const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
[17a0228a]	1213	VISIT_START( node );
	1214
[e21f253]	1215	if ( __visit_children() ) {
[0e42794]	1216	guard_symtab guard { *this };
[17a0228a]	1217	maybe_accept( node, &NameExpr::result );
[e21f253]	1218	}
[17a0228a]	1219
	1220	VISIT_END( Expr, node );
	1221	}
	1222
[b0d9ff7]	1223	//--------------------------------------------------------------------------
	1224	// QualifiedNameExpr
	1225	template< typename core_t >
	1226	const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
	1227	VISIT_START( node );
	1228	if ( __visit_children() ) {
	1229	guard_symtab guard { *this };
	1230	maybe_accept( node, &QualifiedNameExpr::type_decl );
	1231	}
	1232	VISIT_END( Expr, node );
	1233	}
	1234
[17a0228a]	1235	//--------------------------------------------------------------------------
	1236	// CastExpr
[7ff3e522]	1237	template< typename core_t >
	1238	const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
[17a0228a]	1239	VISIT_START( node );
	1240
[e21f253]	1241	if ( __visit_children() ) {
	1242	{
[0e42794]	1243	guard_symtab guard { *this };
[17a0228a]	1244	maybe_accept( node, &CastExpr::result );
	1245	}
	1246	maybe_accept( node, &CastExpr::arg );
[e21f253]	1247	}
[17a0228a]	1248
	1249	VISIT_END( Expr, node );
	1250	}
	1251
	1252	//--------------------------------------------------------------------------
	1253	// KeywordCastExpr
[7ff3e522]	1254	template< typename core_t >
	1255	const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
[17a0228a]	1256	VISIT_START( node );
	1257
[e21f253]	1258	if ( __visit_children() ) {
	1259	{
[0e42794]	1260	guard_symtab guard { *this };
[17a0228a]	1261	maybe_accept( node, &KeywordCastExpr::result );
	1262	}
	1263	maybe_accept( node, &KeywordCastExpr::arg );
[e21f253]	1264	}
[17a0228a]	1265
	1266	VISIT_END( Expr, node );
	1267	}
	1268
	1269	//--------------------------------------------------------------------------
	1270	// VirtualCastExpr
[7ff3e522]	1271	template< typename core_t >
	1272	const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
[17a0228a]	1273	VISIT_START( node );
	1274
[e21f253]	1275	if ( __visit_children() ) {
	1276	{
[0e42794]	1277	guard_symtab guard { *this };
[17a0228a]	1278	maybe_accept( node, &VirtualCastExpr::result );
	1279	}
	1280	maybe_accept( node, &VirtualCastExpr::arg );
[e21f253]	1281	}
[17a0228a]	1282
	1283	VISIT_END( Expr, node );
	1284	}
	1285
	1286	//--------------------------------------------------------------------------
	1287	// AddressExpr
[7ff3e522]	1288	template< typename core_t >
	1289	const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
[17a0228a]	1290	VISIT_START( node );
	1291
[e21f253]	1292	if ( __visit_children() ) {
	1293	{
[0e42794]	1294	guard_symtab guard { *this };
[17a0228a]	1295	maybe_accept( node, &AddressExpr::result );
	1296	}
	1297	maybe_accept( node, &AddressExpr::arg );
[e21f253]	1298	}
[17a0228a]	1299
	1300	VISIT_END( Expr, node );
	1301	}
	1302
	1303	//--------------------------------------------------------------------------
	1304	// LabelAddressExpr
[7ff3e522]	1305	template< typename core_t >
	1306	const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
[17a0228a]	1307	VISIT_START( node );
	1308
[e21f253]	1309	if ( __visit_children() ) {
[0e42794]	1310	guard_symtab guard { *this };
[17a0228a]	1311	maybe_accept( node, &LabelAddressExpr::result );
[e21f253]	1312	}
[17a0228a]	1313
	1314	VISIT_END( Expr, node );
	1315	}
	1316
	1317	//--------------------------------------------------------------------------
	1318	// UntypedMemberExpr
[7ff3e522]	1319	template< typename core_t >
	1320	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
[17a0228a]	1321	VISIT_START( node );
	1322
[e21f253]	1323	if ( __visit_children() ) {
	1324	{
[0e42794]	1325	guard_symtab guard { *this };
[17a0228a]	1326	maybe_accept( node, &UntypedMemberExpr::result );
	1327	}
	1328	maybe_accept( node, &UntypedMemberExpr::aggregate );
	1329	maybe_accept( node, &UntypedMemberExpr::member );
[e21f253]	1330	}
[17a0228a]	1331
	1332	VISIT_END( Expr, node );
	1333	}
	1334
	1335	//--------------------------------------------------------------------------
	1336	// MemberExpr
[7ff3e522]	1337	template< typename core_t >
	1338	const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
[17a0228a]	1339	VISIT_START( node );
	1340
[e21f253]	1341	if ( __visit_children() ) {
	1342	{
[0e42794]	1343	guard_symtab guard { *this };
[17a0228a]	1344	maybe_accept( node, &MemberExpr::result );
	1345	}
	1346	maybe_accept( node, &MemberExpr::aggregate );
[e21f253]	1347	}
[17a0228a]	1348
	1349	VISIT_END( Expr, node );
	1350	}
	1351
	1352	//--------------------------------------------------------------------------
	1353	// VariableExpr
[7ff3e522]	1354	template< typename core_t >
	1355	const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
[17a0228a]	1356	VISIT_START( node );
	1357
[e21f253]	1358	if ( __visit_children() ) {
[0e42794]	1359	guard_symtab guard { *this };
[17a0228a]	1360	maybe_accept( node, &VariableExpr::result );
[e21f253]	1361	}
[17a0228a]	1362
	1363	VISIT_END( Expr, node );
	1364	}
	1365
	1366	//--------------------------------------------------------------------------
	1367	// ConstantExpr
[7ff3e522]	1368	template< typename core_t >
	1369	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
[17a0228a]	1370	VISIT_START( node );
	1371
[e21f253]	1372	if ( __visit_children() ) {
[0e42794]	1373	guard_symtab guard { *this };
[17a0228a]	1374	maybe_accept( node, &ConstantExpr::result );
[e21f253]	1375	}
[17a0228a]	1376
	1377	VISIT_END( Expr, node );
	1378	}
	1379
	1380	//--------------------------------------------------------------------------
	1381	// SizeofExpr
[7ff3e522]	1382	template< typename core_t >
	1383	const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
[17a0228a]	1384	VISIT_START( node );
	1385
[e21f253]	1386	if ( __visit_children() ) {
	1387	{
[0e42794]	1388	guard_symtab guard { *this };
[17a0228a]	1389	maybe_accept( node, &SizeofExpr::result );
	1390	}
	1391	if ( node->type ) {
	1392	maybe_accept( node, &SizeofExpr::type );
	1393	} else {
	1394	maybe_accept( node, &SizeofExpr::expr );
	1395	}
[e21f253]	1396	}
[17a0228a]	1397
	1398	VISIT_END( Expr, node );
	1399	}
	1400
	1401	//--------------------------------------------------------------------------
	1402	// AlignofExpr
[7ff3e522]	1403	template< typename core_t >
	1404	const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
[17a0228a]	1405	VISIT_START( node );
	1406
[e21f253]	1407	if ( __visit_children() ) {
	1408	{
[0e42794]	1409	guard_symtab guard { *this };
[17a0228a]	1410	maybe_accept( node, &AlignofExpr::result );
	1411	}
	1412	if ( node->type ) {
	1413	maybe_accept( node, &AlignofExpr::type );
	1414	} else {
	1415	maybe_accept( node, &AlignofExpr::expr );
	1416	}
[e21f253]	1417	}
[17a0228a]	1418
	1419	VISIT_END( Expr, node );
	1420	}
	1421
	1422	//--------------------------------------------------------------------------
	1423	// UntypedOffsetofExpr
[7ff3e522]	1424	template< typename core_t >
	1425	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
[17a0228a]	1426	VISIT_START( node );
	1427
[e21f253]	1428	if ( __visit_children() ) {
	1429	{
[0e42794]	1430	guard_symtab guard { *this };
[17a0228a]	1431	maybe_accept( node, &UntypedOffsetofExpr::result );
	1432	}
	1433	maybe_accept( node, &UntypedOffsetofExpr::type );
[e21f253]	1434	}
[17a0228a]	1435
	1436	VISIT_END( Expr, node );
	1437	}
	1438
	1439	//--------------------------------------------------------------------------
	1440	// OffsetofExpr
[7ff3e522]	1441	template< typename core_t >
	1442	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
[17a0228a]	1443	VISIT_START( node );
	1444
[e21f253]	1445	if ( __visit_children() ) {
	1446	{
[0e42794]	1447	guard_symtab guard { *this };
[17a0228a]	1448	maybe_accept( node, &OffsetofExpr::result );
	1449	}
	1450	maybe_accept( node, &OffsetofExpr::type );
[e21f253]	1451	}
[17a0228a]	1452
	1453	VISIT_END( Expr, node );
	1454	}
	1455
	1456	//--------------------------------------------------------------------------
	1457	// OffsetPackExpr
[7ff3e522]	1458	template< typename core_t >
	1459	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
[17a0228a]	1460	VISIT_START( node );
	1461
[e21f253]	1462	if ( __visit_children() ) {
	1463	{
[0e42794]	1464	guard_symtab guard { *this };
[17a0228a]	1465	maybe_accept( node, &OffsetPackExpr::result );
	1466	}
	1467	maybe_accept( node, &OffsetPackExpr::type );
[e21f253]	1468	}
[17a0228a]	1469
	1470	VISIT_END( Expr, node );
	1471	}
	1472
	1473	//--------------------------------------------------------------------------
	1474	// LogicalExpr
[7ff3e522]	1475	template< typename core_t >
	1476	const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
[17a0228a]	1477	VISIT_START( node );
	1478
[e21f253]	1479	if ( __visit_children() ) {
	1480	{
[0e42794]	1481	guard_symtab guard { *this };
[17a0228a]	1482	maybe_accept( node, &LogicalExpr::result );
	1483	}
	1484	maybe_accept( node, &LogicalExpr::arg1 );
	1485	maybe_accept( node, &LogicalExpr::arg2 );
[e21f253]	1486	}
[17a0228a]	1487
	1488	VISIT_END( Expr, node );
	1489	}
	1490
	1491	//--------------------------------------------------------------------------
	1492	// ConditionalExpr
[7ff3e522]	1493	template< typename core_t >
	1494	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
[17a0228a]	1495	VISIT_START( node );
	1496
[e21f253]	1497	if ( __visit_children() ) {
	1498	{
[0e42794]	1499	guard_symtab guard { *this };
[17a0228a]	1500	maybe_accept( node, &ConditionalExpr::result );
	1501	}
	1502	maybe_accept( node, &ConditionalExpr::arg1 );
	1503	maybe_accept( node, &ConditionalExpr::arg2 );
	1504	maybe_accept( node, &ConditionalExpr::arg3 );
[e21f253]	1505	}
[17a0228a]	1506
	1507	VISIT_END( Expr, node );
	1508	}
[10a1225]	1509
[17a0228a]	1510	//--------------------------------------------------------------------------
	1511	// CommaExpr
[7ff3e522]	1512	template< typename core_t >
	1513	const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
[17a0228a]	1514	VISIT_START( node );
	1515
[e21f253]	1516	if ( __visit_children() ) {
	1517	{
[0e42794]	1518	guard_symtab guard { *this };
[17a0228a]	1519	maybe_accept( node, &CommaExpr::result );
	1520	}
	1521	maybe_accept( node, &CommaExpr::arg1 );
	1522	maybe_accept( node, &CommaExpr::arg2 );
[e21f253]	1523	}
[17a0228a]	1524
	1525	VISIT_END( Expr, node );
	1526	}
	1527
	1528	//--------------------------------------------------------------------------
	1529	// TypeExpr
[7ff3e522]	1530	template< typename core_t >
	1531	const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
[17a0228a]	1532	VISIT_START( node );
	1533
[e21f253]	1534	if ( __visit_children() ) {
	1535	{
[0e42794]	1536	guard_symtab guard { *this };
[17a0228a]	1537	maybe_accept( node, &TypeExpr::result );
	1538	}
	1539	maybe_accept( node, &TypeExpr::type );
[e21f253]	1540	}
[17a0228a]	1541
	1542	VISIT_END( Expr, node );
	1543	}
	1544
[4ec9513]	1545	//--------------------------------------------------------------------------
	1546	// DimensionExpr
	1547	template< typename core_t >
	1548	const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
	1549	VISIT_START( node );
	1550
	1551	if ( __visit_children() ) {
	1552	guard_symtab guard { *this };
	1553	maybe_accept( node, &DimensionExpr::result );
	1554	}
	1555
	1556	VISIT_END( Expr, node );
	1557	}
	1558
[17a0228a]	1559	//--------------------------------------------------------------------------
	1560	// AsmExpr
[7ff3e522]	1561	template< typename core_t >
	1562	const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
[17a0228a]	1563	VISIT_START( node );
[10a1225]	1564
[e21f253]	1565	if ( __visit_children() ) {
	1566	{
[0e42794]	1567	guard_symtab guard { *this };
[17a0228a]	1568	maybe_accept( node, &AsmExpr::result );
	1569	}
	1570	maybe_accept( node, &AsmExpr::constraint );
	1571	maybe_accept( node, &AsmExpr::operand );
[e21f253]	1572	}
[10a1225]	1573
[17a0228a]	1574	VISIT_END( Expr, node );
	1575	}
[10a1225]	1576
[17a0228a]	1577	//--------------------------------------------------------------------------
	1578	// ImplicitCopyCtorExpr
[7ff3e522]	1579	template< typename core_t >
	1580	const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
[17a0228a]	1581	VISIT_START( node );
	1582
[e21f253]	1583	if ( __visit_children() ) {
	1584	{
[0e42794]	1585	guard_symtab guard { *this };
[17a0228a]	1586	maybe_accept( node, &ImplicitCopyCtorExpr::result );
	1587	}
	1588	maybe_accept( node, &ImplicitCopyCtorExpr::callExpr );
[e21f253]	1589	}
[17a0228a]	1590
	1591	VISIT_END( Expr, node );
	1592	}
	1593
	1594	//--------------------------------------------------------------------------
	1595	// ConstructorExpr
[7ff3e522]	1596	template< typename core_t >
	1597	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
[17a0228a]	1598	VISIT_START( node );
	1599
[e21f253]	1600	if ( __visit_children() ) {
	1601	{
[0e42794]	1602	guard_symtab guard { *this };
[17a0228a]	1603	maybe_accept( node, &ConstructorExpr::result );
	1604	}
	1605	maybe_accept( node, &ConstructorExpr::callExpr );
[e21f253]	1606	}
[10a1225]	1607
[17a0228a]	1608	VISIT_END( Expr, node );
	1609	}
	1610
	1611	//--------------------------------------------------------------------------
	1612	// CompoundLiteralExpr
[7ff3e522]	1613	template< typename core_t >
	1614	const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
[17a0228a]	1615	VISIT_START( node );
	1616
[e21f253]	1617	if ( __visit_children() ) {
	1618	{
[0e42794]	1619	guard_symtab guard { *this };
[17a0228a]	1620	maybe_accept( node, &CompoundLiteralExpr::result );
	1621	}
	1622	maybe_accept( node, &CompoundLiteralExpr::init );
[e21f253]	1623	}
[17a0228a]	1624
	1625	VISIT_END( Expr, node );
	1626	}
	1627
	1628	//--------------------------------------------------------------------------
	1629	// RangeExpr
[7ff3e522]	1630	template< typename core_t >
	1631	const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
[17a0228a]	1632	VISIT_START( node );
	1633
[e21f253]	1634	if ( __visit_children() ) {
	1635	{
[0e42794]	1636	guard_symtab guard { *this };
[17a0228a]	1637	maybe_accept( node, &RangeExpr::result );
	1638	}
	1639	maybe_accept( node, &RangeExpr::low );
	1640	maybe_accept( node, &RangeExpr::high );
[e21f253]	1641	}
[17a0228a]	1642
	1643	VISIT_END( Expr, node );
	1644	}
	1645
	1646	//--------------------------------------------------------------------------
	1647	// UntypedTupleExpr
[7ff3e522]	1648	template< typename core_t >
	1649	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
[17a0228a]	1650	VISIT_START( node );
	1651
[e21f253]	1652	if ( __visit_children() ) {
	1653	{
[0e42794]	1654	guard_symtab guard { *this };
[17a0228a]	1655	maybe_accept( node, &UntypedTupleExpr::result );
	1656	}
	1657	maybe_accept( node, &UntypedTupleExpr::exprs );
[e21f253]	1658	}
[17a0228a]	1659
	1660	VISIT_END( Expr, node );
	1661	}
	1662
	1663	//--------------------------------------------------------------------------
	1664	// TupleExpr
[7ff3e522]	1665	template< typename core_t >
	1666	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
[17a0228a]	1667	VISIT_START( node );
	1668
[e21f253]	1669	if ( __visit_children() ) {
	1670	{
[0e42794]	1671	guard_symtab guard { *this };
[17a0228a]	1672	maybe_accept( node, &TupleExpr::result );
	1673	}
	1674	maybe_accept( node, &TupleExpr::exprs );
[e21f253]	1675	}
[17a0228a]	1676
	1677	VISIT_END( Expr, node );
	1678	}
	1679
	1680	//--------------------------------------------------------------------------
	1681	// TupleIndexExpr
[7ff3e522]	1682	template< typename core_t >
	1683	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
[17a0228a]	1684	VISIT_START( node );
	1685
[e21f253]	1686	if ( __visit_children() ) {
	1687	{
[0e42794]	1688	guard_symtab guard { *this };
[17a0228a]	1689	maybe_accept( node, &TupleIndexExpr::result );
	1690	}
	1691	maybe_accept( node, &TupleIndexExpr::tuple );
[e21f253]	1692	}
[17a0228a]	1693
	1694	VISIT_END( Expr, node );
	1695	}
	1696
	1697	//--------------------------------------------------------------------------
	1698	// TupleAssignExpr
[7ff3e522]	1699	template< typename core_t >
	1700	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
[17a0228a]	1701	VISIT_START( node );
	1702
[e21f253]	1703	if ( __visit_children() ) {
	1704	{
[0e42794]	1705	guard_symtab guard { *this };
[17a0228a]	1706	maybe_accept( node, &TupleAssignExpr::result );
	1707	}
	1708	maybe_accept( node, &TupleAssignExpr::stmtExpr );
[e21f253]	1709	}
[17a0228a]	1710
	1711	VISIT_END( Expr, node );
	1712	}
	1713
	1714	//--------------------------------------------------------------------------
	1715	// StmtExpr
[7ff3e522]	1716	template< typename core_t >
	1717	const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
[17a0228a]	1718	VISIT_START( node );
	1719
[e21f253]	1720	if ( __visit_children() ) {
	1721	// don't want statements from outer CompoundStmts to be added to this StmtExpr
[17a0228a]	1722	// get the stmts that will need to be spliced in
[7ff3e522]	1723	auto stmts_before = __pass::stmtsToAddBefore( core, 0);
	1724	auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
[17a0228a]	1725
	1726	// These may be modified by subnode but most be restored once we exit this statemnet.
[b2a11ba]	1727	ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
[17a0228a]	1728	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
	1729	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
	1730
	1731	{
[0e42794]	1732	guard_symtab guard { *this };
[17a0228a]	1733	maybe_accept( node, &StmtExpr::result );
	1734	}
	1735	maybe_accept( node, &StmtExpr::stmts );
	1736	maybe_accept( node, &StmtExpr::returnDecls );
	1737	maybe_accept( node, &StmtExpr::dtors );
[e21f253]	1738	}
[17a0228a]	1739
	1740	VISIT_END( Expr, node );
	1741	}
	1742
	1743	//--------------------------------------------------------------------------
	1744	// UniqueExpr
[7ff3e522]	1745	template< typename core_t >
	1746	const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
[17a0228a]	1747	VISIT_START( node );
	1748
[e21f253]	1749	if ( __visit_children() ) {
	1750	{
[0e42794]	1751	guard_symtab guard { *this };
[17a0228a]	1752	maybe_accept( node, &UniqueExpr::result );
	1753	}
	1754	maybe_accept( node, &UniqueExpr::expr );
[e21f253]	1755	}
[17a0228a]	1756
	1757	VISIT_END( Expr, node );
	1758	}
	1759
	1760	//--------------------------------------------------------------------------
	1761	// UntypedInitExpr
[7ff3e522]	1762	template< typename core_t >
	1763	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
[17a0228a]	1764	VISIT_START( node );
	1765
[e21f253]	1766	if ( __visit_children() ) {
	1767	{
[0e42794]	1768	guard_symtab guard { *this };
[17a0228a]	1769	maybe_accept( node, &UntypedInitExpr::result );
	1770	}
	1771	maybe_accept( node, &UntypedInitExpr::expr );
	1772	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
[e21f253]	1773	}
[17a0228a]	1774
	1775	VISIT_END( Expr, node );
	1776	}
	1777
	1778	//--------------------------------------------------------------------------
	1779	// InitExpr
[7ff3e522]	1780	template< typename core_t >
	1781	const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
[17a0228a]	1782	VISIT_START( node );
	1783
[e21f253]	1784	if ( __visit_children() ) {
	1785	{
[0e42794]	1786	guard_symtab guard { *this };
[17a0228a]	1787	maybe_accept( node, &InitExpr::result );
	1788	}
	1789	maybe_accept( node, &InitExpr::expr );
	1790	maybe_accept( node, &InitExpr::designation );
[e21f253]	1791	}
[17a0228a]	1792
	1793	VISIT_END( Expr, node );
	1794	}
	1795
	1796	//--------------------------------------------------------------------------
	1797	// DeletedExpr
[7ff3e522]	1798	template< typename core_t >
	1799	const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
[17a0228a]	1800	VISIT_START( node );
	1801
[e21f253]	1802	if ( __visit_children() ) {
	1803	{
[0e42794]	1804	guard_symtab guard { *this };
[17a0228a]	1805	maybe_accept( node, &DeletedExpr::result );
	1806	}
	1807	maybe_accept( node, &DeletedExpr::expr );
	1808	// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
[e21f253]	1809	}
[17a0228a]	1810
	1811	VISIT_END( Expr, node );
	1812	}
	1813
	1814	//--------------------------------------------------------------------------
	1815	// DefaultArgExpr
[7ff3e522]	1816	template< typename core_t >
	1817	const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
[17a0228a]	1818	VISIT_START( node );
	1819
[e21f253]	1820	if ( __visit_children() ) {
	1821	{
[0e42794]	1822	guard_symtab guard { *this };
[17a0228a]	1823	maybe_accept( node, &DefaultArgExpr::result );
	1824	}
	1825	maybe_accept( node, &DefaultArgExpr::expr );
[e21f253]	1826	}
[17a0228a]	1827
	1828	VISIT_END( Expr, node );
	1829	}
	1830
	1831	//--------------------------------------------------------------------------
	1832	// GenericExpr
[7ff3e522]	1833	template< typename core_t >
	1834	const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
[17a0228a]	1835	VISIT_START( node );
	1836
[e21f253]	1837	if ( __visit_children() ) {
	1838	{
[0e42794]	1839	guard_symtab guard { *this };
[17a0228a]	1840	maybe_accept( node, &GenericExpr::result );
	1841	}
	1842	maybe_accept( node, &GenericExpr::control );
	1843
	1844	std::vector<GenericExpr::Association> new_kids;
	1845	new_kids.reserve(node->associations.size());
	1846	bool mutated = false;
	1847	for( const auto & assoc : node->associations ) {
[b0abc8a0]	1848	const Type * type = nullptr;
[17a0228a]	1849	if( assoc.type ) {
[0e42794]	1850	guard_symtab guard { *this };
[17a0228a]	1851	type = assoc.type->accept( *this );
	1852	if( type != assoc.type ) mutated = true;
	1853	}
[b0abc8a0]	1854	const Expr * expr = nullptr;
[17a0228a]	1855	if( assoc.expr ) {
	1856	expr = assoc.expr->accept( *this );
	1857	if( expr != assoc.expr ) mutated = true;
	1858	}
	1859	new_kids.emplace_back( type, expr );
	1860	}
	1861
	1862	if(mutated) {
[d3aa64f1]	1863	auto n = __pass::mutate<core_t>(node);
[17a0228a]	1864	n->associations = std::move( new_kids );
	1865	node = n;
	1866	}
[e21f253]	1867	}
[17a0228a]	1868
	1869	VISIT_END( Expr, node );
	1870	}
[10a1225]	1871
[e0016a5]	1872	//--------------------------------------------------------------------------
	1873	// VoidType
[7ff3e522]	1874	template< typename core_t >
	1875	const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
[e0016a5]	1876	VISIT_START( node );
[10a1225]	1877
[e0016a5]	1878	VISIT_END( Type, node );
	1879	}
[10a1225]	1880
[e0016a5]	1881	//--------------------------------------------------------------------------
	1882	// BasicType
[7ff3e522]	1883	template< typename core_t >
	1884	const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
[e0016a5]	1885	VISIT_START( node );
	1886
	1887	VISIT_END( Type, node );
	1888	}
	1889
	1890	//--------------------------------------------------------------------------
	1891	// PointerType
[7ff3e522]	1892	template< typename core_t >
	1893	const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
[e0016a5]	1894	VISIT_START( node );
	1895
[e21f253]	1896	if ( __visit_children() ) {
[4ec9513]	1897	maybe_accept( node, &PointerType::dimension );
[e0016a5]	1898	maybe_accept( node, &PointerType::base );
[e21f253]	1899	}
[e0016a5]	1900
	1901	VISIT_END( Type, node );
	1902	}
	1903
	1904	//--------------------------------------------------------------------------
	1905	// ArrayType
[7ff3e522]	1906	template< typename core_t >
	1907	const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
[e0016a5]	1908	VISIT_START( node );
	1909
[e21f253]	1910	if ( __visit_children() ) {
[e0016a5]	1911	maybe_accept( node, &ArrayType::dimension );
	1912	maybe_accept( node, &ArrayType::base );
[e21f253]	1913	}
[e0016a5]	1914
	1915	VISIT_END( Type, node );
	1916	}
	1917
	1918	//--------------------------------------------------------------------------
	1919	// ReferenceType
[7ff3e522]	1920	template< typename core_t >
	1921	const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
[e0016a5]	1922	VISIT_START( node );
	1923
[e21f253]	1924	if ( __visit_children() ) {
[e0016a5]	1925	maybe_accept( node, &ReferenceType::base );
[e21f253]	1926	}
[e0016a5]	1927
	1928	VISIT_END( Type, node );
	1929	}
	1930
	1931	//--------------------------------------------------------------------------
	1932	// QualifiedType
[7ff3e522]	1933	template< typename core_t >
	1934	const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
[e0016a5]	1935	VISIT_START( node );
	1936
[e21f253]	1937	if ( __visit_children() ) {
[e0016a5]	1938	maybe_accept( node, &QualifiedType::parent );
	1939	maybe_accept( node, &QualifiedType::child );
[e21f253]	1940	}
[e0016a5]	1941
	1942	VISIT_END( Type, node );
	1943	}
	1944
	1945	//--------------------------------------------------------------------------
	1946	// FunctionType
[7ff3e522]	1947	template< typename core_t >
	1948	const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
[e0016a5]	1949	VISIT_START( node );
	1950
[e21f253]	1951	if ( __visit_children() ) {
[3e5dd913]	1952	// guard_forall_subs forall_guard { *this, node };
	1953	// mutate_forall( node );
	1954	maybe_accept( node, &FunctionType::assertions );
[e0016a5]	1955	maybe_accept( node, &FunctionType::returns );
	1956	maybe_accept( node, &FunctionType::params );
[e21f253]	1957	}
[e0016a5]	1958
	1959	VISIT_END( Type, node );
	1960	}
	1961
	1962	//--------------------------------------------------------------------------
	1963	// StructInstType
[7ff3e522]	1964	template< typename core_t >
	1965	const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
[e0016a5]	1966	VISIT_START( node );
	1967
[7ff3e522]	1968	__pass::symtab::addStruct( core, 0, node->name );
[e0016a5]	1969
[e21f253]	1970	if ( __visit_children() ) {
[0e42794]	1971	guard_symtab guard { *this };
[e0016a5]	1972	maybe_accept( node, &StructInstType::params );
[e21f253]	1973	}
[e0016a5]	1974
	1975	VISIT_END( Type, node );
	1976	}
	1977
	1978	//--------------------------------------------------------------------------
	1979	// UnionInstType
[7ff3e522]	1980	template< typename core_t >
	1981	const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
[e0016a5]	1982	VISIT_START( node );
	1983
[7ff3e522]	1984	__pass::symtab::addUnion( core, 0, node->name );
[e0016a5]	1985
[e21f253]	1986	if ( __visit_children() ) {
[0e42794]	1987	guard_symtab guard { *this };
[e0016a5]	1988	maybe_accept( node, &UnionInstType::params );
[e21f253]	1989	}
[e0016a5]	1990
	1991	VISIT_END( Type, node );
	1992	}
	1993
	1994	//--------------------------------------------------------------------------
	1995	// EnumInstType
[7ff3e522]	1996	template< typename core_t >
	1997	const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
[e0016a5]	1998	VISIT_START( node );
	1999
[e21f253]	2000	if ( __visit_children() ) {
[e0016a5]	2001	maybe_accept( node, &EnumInstType::params );
[e21f253]	2002	}
[e0016a5]	2003
	2004	VISIT_END( Type, node );
	2005	}
	2006
	2007	//--------------------------------------------------------------------------
	2008	// TraitInstType
[7ff3e522]	2009	template< typename core_t >
	2010	const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
[e0016a5]	2011	VISIT_START( node );
	2012
[e21f253]	2013	if ( __visit_children() ) {
[e0016a5]	2014	maybe_accept( node, &TraitInstType::params );
[e21f253]	2015	}
[e0016a5]	2016
	2017	VISIT_END( Type, node );
	2018	}
	2019
	2020	//--------------------------------------------------------------------------
	2021	// TypeInstType
[7ff3e522]	2022	template< typename core_t >
	2023	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
[e0016a5]	2024	VISIT_START( node );
	2025
[e21f253]	2026	if ( __visit_children() ) {
[e0e9a0b]	2027	{
	2028	maybe_accept( node, &TypeInstType::params );
	2029	}
	2030	// ensure that base re-bound if doing substitution
[7ff3e522]	2031	__pass::forall::replace( core, 0, node );
[e21f253]	2032	}
[e0016a5]	2033
	2034	VISIT_END( Type, node );
	2035	}
	2036
	2037	//--------------------------------------------------------------------------
	2038	// TupleType
[7ff3e522]	2039	template< typename core_t >
	2040	const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
[e0016a5]	2041	VISIT_START( node );
	2042
[e21f253]	2043	if ( __visit_children() ) {
[e0016a5]	2044	maybe_accept( node, &TupleType::types );
	2045	maybe_accept( node, &TupleType::members );
[e21f253]	2046	}
[e0016a5]	2047
	2048	VISIT_END( Type, node );
	2049	}
	2050
	2051	//--------------------------------------------------------------------------
	2052	// TypeofType
[7ff3e522]	2053	template< typename core_t >
	2054	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
[e0016a5]	2055	VISIT_START( node );
	2056
[e21f253]	2057	if ( __visit_children() ) {
[e0016a5]	2058	maybe_accept( node, &TypeofType::expr );
[e21f253]	2059	}
[e0016a5]	2060
	2061	VISIT_END( Type, node );
	2062	}
	2063
[3945abe]	2064	//--------------------------------------------------------------------------
	2065	// VTableType
	2066	template< typename core_t >
	2067	const ast::Type * ast::Pass< core_t >::visit( const ast::VTableType * node ) {
	2068	VISIT_START( node );
	2069
[e21f253]	2070	if ( __visit_children() ) {
[3945abe]	2071	maybe_accept( node, &VTableType::base );
[e21f253]	2072	}
[3945abe]	2073
	2074	VISIT_END( Type, node );
	2075	}
	2076
[e0016a5]	2077	//--------------------------------------------------------------------------
	2078	// VarArgsType
[7ff3e522]	2079	template< typename core_t >
	2080	const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
[e0016a5]	2081	VISIT_START( node );
	2082
	2083	VISIT_END( Type, node );
	2084	}
	2085
	2086	//--------------------------------------------------------------------------
	2087	// ZeroType
[7ff3e522]	2088	template< typename core_t >
	2089	const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
[e0016a5]	2090	VISIT_START( node );
	2091
	2092	VISIT_END( Type, node );
	2093	}
	2094
	2095	//--------------------------------------------------------------------------
	2096	// OneType
[7ff3e522]	2097	template< typename core_t >
	2098	const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
[e0016a5]	2099	VISIT_START( node );
	2100
	2101	VISIT_END( Type, node );
	2102	}
	2103
	2104	//--------------------------------------------------------------------------
	2105	// GlobalScopeType
[7ff3e522]	2106	template< typename core_t >
	2107	const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
[e0016a5]	2108	VISIT_START( node );
	2109
	2110	VISIT_END( Type, node );
	2111	}
	2112
	2113
	2114	//--------------------------------------------------------------------------
	2115	// Designation
[7ff3e522]	2116	template< typename core_t >
	2117	const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
[e0016a5]	2118	VISIT_START( node );
	2119
[e21f253]	2120	if ( __visit_children() ) {
	2121	maybe_accept( node, &Designation::designators );
	2122	}
[e0016a5]	2123
	2124	VISIT_END( Designation, node );
	2125	}
[10a1225]	2126
[6d51bd7]	2127	//--------------------------------------------------------------------------
	2128	// SingleInit
[7ff3e522]	2129	template< typename core_t >
	2130	const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
[6d51bd7]	2131	VISIT_START( node );
	2132
[e21f253]	2133	if ( __visit_children() ) {
[9e23b446]	2134	maybe_accept_top( node, &SingleInit::value );
[e21f253]	2135	}
[6d51bd7]	2136
	2137	VISIT_END( Init, node );
	2138	}
	2139
	2140	//--------------------------------------------------------------------------
	2141	// ListInit
[7ff3e522]	2142	template< typename core_t >
	2143	const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
[6d51bd7]	2144	VISIT_START( node );
	2145
[e21f253]	2146	if ( __visit_children() ) {
[6d51bd7]	2147	maybe_accept( node, &ListInit::designations );
	2148	maybe_accept( node, &ListInit::initializers );
[e21f253]	2149	}
[6d51bd7]	2150
	2151	VISIT_END( Init, node );
	2152	}
	2153
	2154	//--------------------------------------------------------------------------
	2155	// ConstructorInit
[7ff3e522]	2156	template< typename core_t >
	2157	const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
[6d51bd7]	2158	VISIT_START( node );
	2159
[e21f253]	2160	if ( __visit_children() ) {
[6d51bd7]	2161	maybe_accept( node, &ConstructorInit::ctor );
	2162	maybe_accept( node, &ConstructorInit::dtor );
	2163	maybe_accept( node, &ConstructorInit::init );
[e21f253]	2164	}
[6d51bd7]	2165
	2166	VISIT_END( Init, node );
	2167	}
	2168
[f47f887]	2169	//--------------------------------------------------------------------------
	2170	// Attribute
[7ff3e522]	2171	template< typename core_t >
	2172	const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) {
[6d51bd7]	2173	VISIT_START( node );
[f47f887]	2174
[e21f253]	2175	if ( __visit_children() ) {
[489bacf]	2176	maybe_accept( node, &Attribute::params );
[e21f253]	2177	}
[f47f887]	2178
[8a5530c]	2179	VISIT_END( Attribute, node );
[f47f887]	2180	}
	2181
	2182	//--------------------------------------------------------------------------
	2183	// TypeSubstitution
[7ff3e522]	2184	template< typename core_t >
	2185	const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
[6d51bd7]	2186	VISIT_START( node );
[f47f887]	2187
[e21f253]	2188	if ( __visit_children() ) {
[8631c84]	2189	bool mutated = false;
[a8b87d3]	2190	ast::TypeSubstitution::TypeMap new_map;
	2191	for ( const auto & p : node->typeMap ) {
[8631c84]	2192	guard_symtab guard { *this };
	2193	auto new_node = p.second->accept( *this );
	2194	if (new_node != p.second) mutated = true;
	2195	new_map.insert({ p.first, new_node });
	2196	}
	2197	if (mutated) {
	2198	auto new_node = __pass::mutate<core_t>( node );
[a8b87d3]	2199	new_node->typeMap.swap( new_map );
[8631c84]	2200	node = new_node;
[6d51bd7]	2201	}
[e21f253]	2202	}
[f47f887]	2203
[6d51bd7]	2204	VISIT_END( TypeSubstitution, node );
[f47f887]	2205	}
	2206
	2207	#undef VISIT_START
[112fe04]	2208	#undef VISIT_END

Note: See TracBrowser for help on using the repository browser.

Download in other formats: