Context Navigation

source: src/AST/Pass.impl.hpp@ 8fd1b7c

Visit:

ADT ast-experimental

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

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

Download in other formats: