Context Navigation

source: src/AST/Pass.impl.hpp @ d41735a

ADTast-experimental

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

Line
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	//
7	// ast::Pass.impl.hpp --
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
16	#pragma once
17	// IWYU pragma: private, include "AST/Pass.hpp"
18
19	#include <type_traits>
20	#include <unordered_map>
21
22	#include "AST/TranslationUnit.hpp"
23	#include "AST/TypeSubstitution.hpp"
24
25	#define VISIT_START( node ) \
26	using namespace ast; \
27	/* back-up the last known code location */ \
28	__attribute__((unused)) auto loc_guard = ast::__pass::make_location_guard( core, node, 0 ); \
29	/* back-up the visit children */ \
30	__attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
31	/* setup the scope for passes that want to run code at exit */ \
32	__attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \
33	/* begin tracing memory allocation if requested by this pass */ \
34	__pass::beginTrace( core, 0 ); \
35	/* call the implementation of the previsit of this pass */ \
36	__pass::previsit( core, node, 0 );
37
38	#define VISIT_END( type, node ) \
39	/* call the implementation of the postvisit of this pass */ \
40	auto __return = __pass::postvisit( core, node, 0 ); \
41	assertf(__return, "post visit should never return null"); \
42	/* end tracing memory allocation if requested by this pass */ \
43	__pass::endTrace( core, 0 ); \
44	return __return;
45
46	#ifdef PEDANTIC_PASS_ASSERT
47	#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
48	#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
49	#else
50	#define __pedantic_pass_assert(...)
51	#define __pedantic_pass_assertf(...)
52	#endif
53
54	namespace ast {
55	template<typename node_t>
56	node_t * shallowCopy( const node_t * node );
57
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
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
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 ) {
73	if(empty(decls)) return;
74
75	std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
76	return new DeclStmt( decl->location, decl );
77	});
78	decls->clear();
79	if(mutated) *mutated = true;
80	}
81
82	template<typename it_t, template <class...> class container_t>
83	static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
84	if(empty(stmts)) return;
85
86	std::move(stmts->begin(), stmts->end(), it);
87	stmts->clear();
88	if(mutated) *mutated = true;
89	}
90
91	//------------------------------
92	/// Check if should be skipped, different for pointers and containers
93	template<typename node_t>
94	bool skip( const ast::ptr<node_t> & val) {
95	return !val;
96	}
97
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();
101	}
102
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	}
109
110	template<typename node_t>
111	const node_t & get( const node_t & val, long) {
112	return val;
113	}
114
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();
125	}
126	}
127
128	template< typename node_t >
129	template< typename object_t, typename super_t, typename field_t >
130	void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
131	object->*field = value;
132	}
133
134	template< typename core_t >
135	template< typename node_t >
136	auto ast::Pass< core_t >::call_accept( const node_t * node )
137	-> typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
138	{
139	__pedantic_pass_assert( __visit_children() );
140	__pedantic_pass_assert( node );
141
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
145	auto nval = node->accept( *this );
146	__pass::result1<
147	typename std::remove_pointer< decltype( node->accept(*this) ) >::type
148	> res;
149	res.differs = nval != node;
150	res.value = nval;
151	return res;
152	}
153
154	template< typename core_t >
155	__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
156	__pedantic_pass_assert( __visit_children() );
157	__pedantic_pass_assert( expr );
158
159	auto nval = expr->accept( *this );
160	return { nval != expr, nval };
161	}
162
163	template< typename core_t >
164	__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
165	__pedantic_pass_assert( __visit_children() );
166	__pedantic_pass_assert( stmt );
167
168	const ast::Stmt * nval = stmt->accept( *this );
169	return { nval != stmt, nval };
170	}
171
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
186	template< typename core_t >
187	__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
188	__pedantic_pass_assert( __visit_children() );
189	__pedantic_pass_assert( stmt );
190
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
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 );
199
200	// These may be modified by subnode but most be restored once we exit this statemnet.
201	ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::typeSubs( core, 0 ) );
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 );
206
207	// Now is the time to actually visit the node
208	const ast::Stmt * nstmt = stmt->accept( *this );
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) ) {
212	return { nstmt != stmt, nstmt };
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
221	ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
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
228	compound->kids.emplace_back( nstmt );
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
234	return {true, compound};
235	}
236
237	template< template <class...> class container_t >
238	template< typename object_t, typename super_t, typename field_t >
239	void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
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;
246	for (delta & d : values) {
247	if ( d.is_old ) {
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 {
252	nvals.push_back( std::move(d.new_val) );
253	}
254	}
255
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;
285	}
286
287	template< typename core_t >
288	template< template <class...> class container_t >
289	__pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
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
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 );
304
305	// These may be modified by subnode but most be restored once we exit this statemnet.
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 );
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
316	__pass::resultNstmt<container_t> new_kids;
317	for( auto value : enumerate( statements ) ) {
318	try {
319	size_t i = value.idx;
320	const Stmt * stmt = value.val;
321	__pedantic_pass_assert( stmt );
322	const ast::Stmt * new_stmt = stmt->accept( *this );
323	assert( new_stmt );
324	if(new_stmt != stmt ) { new_kids.differs = true; }
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
332	new_kids.take_all( decls_before );
333	new_kids.take_all( stmts_before );
334
335	// Now add the statement if there is one
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	}
341
342	// Take all the declarations that go before
343	new_kids.take_all( decls_after );
344	new_kids.take_all( stmts_after );
345	}
346	catch ( SemanticErrorException &e ) {
347	errors.append( e );
348	}
349	}
350	pass_visitor_stats.depth--;
351	if ( !errors.isEmpty() ) { throw errors; }
352
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 >
358	void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
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'
365	if( values[i] != nullptr ) swap(container[i], values[i]);
366	}
367
368	// Now the original containers should still have the unchanged values
369	// but also contain the new values
370	}
371
372	template< typename core_t >
373	template< template <class...> class container_t, typename node_t >
374	__pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
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;
384	container_t<ptr<node_t>> new_kids;
385	for ( const node_t * node : container ) {
386	try {
387	__pedantic_pass_assert( node );
388	const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
389	if(new_stmt != node ) {
390	mutated = true;
391	new_kids.emplace_back( new_stmt );
392	} else {
393	new_kids.emplace_back( nullptr );
394	}
395
396	}
397	catch( SemanticErrorException &e ) {
398	errors.append( e );
399	}
400	}
401
402	__pedantic_pass_assert( new_kids.size() == container.size() );
403	pass_visitor_stats.depth--;
404	if ( ! errors.isEmpty() ) { throw errors; }
405
406	return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
407	}
408
409	template< typename core_t >
410	template<typename node_t, typename super_t, typename field_t>
411	void ast::Pass< core_t >::maybe_accept(
412	const node_t * & parent,
413	field_t super_t::*field
414	) {
415	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
416
417	if(__pass::skip(parent->*field)) return;
418	const auto & old_val = __pass::get(parent->*field, 0);
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
424	static_assert( !std::is_same<const ast::Node , decltype(new_val)>::value / \|\| std::is_same<int, decltype(old_val)>::value */, "ERROR");
425
426	if( new_val.differs ) {
427	auto new_parent = __pass::mutate<core_t>(parent);
428	new_val.apply(new_parent, field);
429	parent = new_parent;
430	}
431	}
432
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
457	template< typename core_t >
458	template<typename node_t, typename super_t, typename field_t>
459	void ast::Pass< core_t >::maybe_accept_as_compound(
460	const node_t * & parent,
461	field_t super_t::*child
462	) {
463	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
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
474	if( new_val.differs ) {
475	auto new_parent = __pass::mutate<core_t>(parent);
476	new_val.apply( new_parent, child );
477	parent = new_parent;
478	}
479	}
480
481	}
482
483	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
484	//========================================================================================================================================================================
485	//========================================================================================================================================================================
486	//========================================================================================================================================================================
487	//========================================================================================================================================================================
488	//========================================================================================================================================================================
489	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
490
491	template< typename core_t >
492	inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
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
500	auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
501	auto decls_after = __pass::declsToAddAfter ( visitor.core, 0);
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 ) {
521	if (__pass::on_error (visitor.core, *i, 0))
522	errors.append( e );
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
532	template< typename core_t >
533	inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
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	}
541	}
542
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
562	template< typename core_t >
563	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
564	VISIT_START( node );
565
566	if ( __visit_children() ) {
567	{
568	guard_symtab guard { *this };
569	maybe_accept( node, &ObjectDecl::type );
570	}
571	maybe_accept( node, &ObjectDecl::init );
572	maybe_accept( node, &ObjectDecl::bitfieldWidth );
573	maybe_accept( node, &ObjectDecl::attributes );
574	}
575
576	__pass::symtab::addId( core, 0, node );
577
578	VISIT_END( DeclWithType, node );
579	}
580
581	//--------------------------------------------------------------------------
582	// FunctionDecl
583	template< typename core_t >
584	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
585	VISIT_START( node );
586
587	__pass::symtab::addId( core, 0, node );
588
589	if ( __visit_children() ) {
590	maybe_accept( node, &FunctionDecl::withExprs );
591	}
592	{
593	// with clause introduces a level of scope (for the with expression members).
594	// with clause exprs are added to the symbol table before parameters so that parameters
595	// shadow with exprs and not the other way around.
596	guard_symtab guard { *this };
597	__pass::symtab::addWith( core, 0, node->withExprs, node );
598	{
599	guard_symtab guard { *this };
600	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
601	// This is a C name and so has C linkage.
602	static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
603	CodeLocation{}, "__func__",
604	new ast::ArrayType{
605	new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
606	nullptr, VariableLen, DynamicDim
607	},
608	nullptr,
609	ast::Storage::Classes(),
610	ast::Linkage::C,
611	} };
612	__pass::symtab::addId( core, 0, func );
613	if ( __visit_children() ) {
614	maybe_accept( node, &FunctionDecl::type_params );
615	maybe_accept( node, &FunctionDecl::assertions );
616	maybe_accept( node, &FunctionDecl::params );
617	maybe_accept( node, &FunctionDecl::returns );
618	maybe_accept( node, &FunctionDecl::type );
619	maybe_accept( node, &FunctionDecl::attributes );
620	// First remember that we are now within a function.
621	ValueGuard< bool > oldInFunction( inFunction );
622	inFunction = true;
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;
627	maybe_accept( node, &FunctionDecl::stmts );
628	}
629	}
630	}
631
632	VISIT_END( DeclWithType, node );
633	}
634
635	//--------------------------------------------------------------------------
636	// StructDecl
637	template< typename core_t >
638	const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
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
643	__pass::symtab::addStructFwd( core, 0, node );
644
645	if ( __visit_children() ) {
646	guard_symtab guard { * this };
647	maybe_accept( node, &StructDecl::params );
648	maybe_accept( node, &StructDecl::members );
649	maybe_accept( node, &StructDecl::attributes );
650	}
651
652	// this addition replaces the forward declaration
653	__pass::symtab::addStruct( core, 0, node );
654
655	VISIT_END( Decl, node );
656	}
657
658	//--------------------------------------------------------------------------
659	// UnionDecl
660	template< typename core_t >
661	const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
662	VISIT_START( node );
663
664	// make up a forward declaration and add it before processing the members
665	__pass::symtab::addUnionFwd( core, 0, node );
666
667	if ( __visit_children() ) {
668	guard_symtab guard { * this };
669	maybe_accept( node, &UnionDecl::params );
670	maybe_accept( node, &UnionDecl::members );
671	maybe_accept( node, &UnionDecl::attributes );
672	}
673
674	__pass::symtab::addUnion( core, 0, node );
675
676	VISIT_END( Decl, node );
677	}
678
679	//--------------------------------------------------------------------------
680	// EnumDecl
681	template< typename core_t >
682	const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
683	VISIT_START( node );
684
685	__pass::symtab::addEnum( core, 0, node );
686
687	if ( __visit_children() ) {
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	}
700	}
701
702	VISIT_END( Decl, node );
703	}
704
705	//--------------------------------------------------------------------------
706	// TraitDecl
707	template< typename core_t >
708	const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
709	VISIT_START( node );
710
711	if ( __visit_children() ) {
712	guard_symtab guard { *this };
713	maybe_accept( node, &TraitDecl::params );
714	maybe_accept( node, &TraitDecl::members );
715	maybe_accept( node, &TraitDecl::attributes );
716	}
717
718	__pass::symtab::addTrait( core, 0, node );
719
720	VISIT_END( Decl, node );
721	}
722
723	//--------------------------------------------------------------------------
724	// TypeDecl
725	template< typename core_t >
726	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
727	VISIT_START( node );
728
729	if ( __visit_children() ) {
730	guard_symtab guard { *this };
731	maybe_accept( node, &TypeDecl::base );
732	}
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
737	__pass::symtab::addType( core, 0, node );
738
739	if ( __visit_children() ) {
740	maybe_accept( node, &TypeDecl::assertions );
741
742	{
743	guard_symtab guard { *this };
744	maybe_accept( node, &TypeDecl::init );
745	}
746	}
747
748	VISIT_END( Decl, node );
749	}
750
751	//--------------------------------------------------------------------------
752	// TypedefDecl
753	template< typename core_t >
754	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
755	VISIT_START( node );
756
757	if ( __visit_children() ) {
758	guard_symtab guard { *this };
759	maybe_accept( node, &TypedefDecl::base );
760	}
761
762	__pass::symtab::addType( core, 0, node );
763
764	if ( __visit_children() ) {
765	maybe_accept( node, &TypedefDecl::assertions );
766	}
767
768	VISIT_END( Decl, node );
769	}
770
771	//--------------------------------------------------------------------------
772	// AsmDecl
773	template< typename core_t >
774	const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
775	VISIT_START( node );
776
777	if ( __visit_children() ) {
778	maybe_accept( node, &AsmDecl::stmt );
779	}
780
781	VISIT_END( AsmDecl, node );
782	}
783
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
790	if ( __visit_children() ) {
791	maybe_accept( node, &DirectiveDecl::stmt );
792	}
793
794	VISIT_END( DirectiveDecl, node );
795	}
796
797	//--------------------------------------------------------------------------
798	// StaticAssertDecl
799	template< typename core_t >
800	const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
801	VISIT_START( node );
802
803	if ( __visit_children() ) {
804	maybe_accept_top( node, &StaticAssertDecl::cond );
805	maybe_accept( node, &StaticAssertDecl::msg );
806	}
807
808	VISIT_END( StaticAssertDecl, node );
809	}
810
811	//--------------------------------------------------------------------------
812	// InlineMemberDecl
813	template< typename core_t >
814	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
815	VISIT_START( node );
816
817	if ( __visit_children() ) {
818	{
819	guard_symtab guard { *this };
820	maybe_accept( node, &InlineMemberDecl::type );
821	}
822	}
823
824	VISIT_END( DeclWithType, node );
825	}
826
827	//--------------------------------------------------------------------------
828	// CompoundStmt
829	template< typename core_t >
830	const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
831	VISIT_START( node );
832
833	if ( __visit_children() ) {
834	// Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
835	auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
836	if ( enterScope ) {
837	__pass::symtab::enter(core, 0);
838	__pass::scope::enter(core, 0);
839	}
840	}, [this, leaveScope = !this->atFunctionTop]() {
841	if ( leaveScope ) {
842	__pass::symtab::leave(core, 0);
843	__pass::scope::leave(core, 0);
844	}
845	});
846	ValueGuard< bool > guard2( atFunctionTop );
847	atFunctionTop = false;
848	guard_scope guard3 { *this };
849	maybe_accept( node, &CompoundStmt::kids );
850	}
851
852	VISIT_END( CompoundStmt, node );
853	}
854
855	//--------------------------------------------------------------------------
856	// ExprStmt
857	template< typename core_t >
858	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
859	VISIT_START( node );
860
861	if ( __visit_children() ) {
862	maybe_accept_top( node, &ExprStmt::expr );
863	}
864
865	VISIT_END( Stmt, node );
866	}
867
868	//--------------------------------------------------------------------------
869	// AsmStmt
870	template< typename core_t >
871	const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
872	VISIT_START( node )
873
874	if ( __visit_children() ) {
875	maybe_accept( node, &AsmStmt::instruction );
876	maybe_accept( node, &AsmStmt::output );
877	maybe_accept( node, &AsmStmt::input );
878	maybe_accept( node, &AsmStmt::clobber );
879	}
880
881	VISIT_END( Stmt, node );
882	}
883
884	//--------------------------------------------------------------------------
885	// DirectiveStmt
886	template< typename core_t >
887	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
888	VISIT_START( node )
889
890	VISIT_END( Stmt, node );
891	}
892
893	//--------------------------------------------------------------------------
894	// IfStmt
895	template< typename core_t >
896	const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
897	VISIT_START( node );
898
899	if ( __visit_children() ) {
900	// if statements introduce a level of scope (for the initialization)
901	guard_symtab guard { *this };
902	maybe_accept( node, &IfStmt::inits );
903	maybe_accept_top( node, &IfStmt::cond );
904	maybe_accept_as_compound( node, &IfStmt::then );
905	maybe_accept_as_compound( node, &IfStmt::else_ );
906	}
907
908	VISIT_END( Stmt, node );
909	}
910
911	//--------------------------------------------------------------------------
912	// WhileDoStmt
913	template< typename core_t >
914	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
915	VISIT_START( node );
916
917	if ( __visit_children() ) {
918	// while statements introduce a level of scope (for the initialization)
919	guard_symtab guard { *this };
920	maybe_accept( node, &WhileDoStmt::inits );
921	maybe_accept_top( node, &WhileDoStmt::cond );
922	maybe_accept_as_compound( node, &WhileDoStmt::body );
923	}
924
925	VISIT_END( Stmt, node );
926	}
927
928	//--------------------------------------------------------------------------
929	// ForStmt
930	template< typename core_t >
931	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
932	VISIT_START( node );
933
934	if ( __visit_children() ) {
935	// for statements introduce a level of scope (for the initialization)
936	guard_symtab guard { *this };
937	// xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
938	maybe_accept( node, &ForStmt::inits );
939	maybe_accept_top( node, &ForStmt::cond );
940	maybe_accept_top( node, &ForStmt::inc );
941	maybe_accept_as_compound( node, &ForStmt::body );
942	}
943
944	VISIT_END( Stmt, node );
945	}
946
947	//--------------------------------------------------------------------------
948	// SwitchStmt
949	template< typename core_t >
950	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
951	VISIT_START( node );
952
953	if ( __visit_children() ) {
954	maybe_accept_top( node, &SwitchStmt::cond );
955	maybe_accept( node, &SwitchStmt::cases );
956	}
957
958	VISIT_END( Stmt, node );
959	}
960
961	//--------------------------------------------------------------------------
962	// CaseClause
963	template< typename core_t >
964	const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
965	VISIT_START( node );
966
967	if ( __visit_children() ) {
968	maybe_accept_top( node, &CaseClause::cond );
969	maybe_accept( node, &CaseClause::stmts );
970	}
971
972	VISIT_END( CaseClause, node );
973	}
974
975	//--------------------------------------------------------------------------
976	// BranchStmt
977	template< typename core_t >
978	const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
979	VISIT_START( node );
980	VISIT_END( Stmt, node );
981	}
982
983	//--------------------------------------------------------------------------
984	// ReturnStmt
985	template< typename core_t >
986	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
987	VISIT_START( node );
988
989	if ( __visit_children() ) {
990	maybe_accept_top( node, &ReturnStmt::expr );
991	}
992
993	VISIT_END( Stmt, node );
994	}
995
996	//--------------------------------------------------------------------------
997	// ThrowStmt
998	template< typename core_t >
999	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
1000	VISIT_START( node );
1001
1002	if ( __visit_children() ) {
1003	maybe_accept( node, &ThrowStmt::expr );
1004	maybe_accept( node, &ThrowStmt::target );
1005	}
1006
1007	VISIT_END( Stmt, node );
1008	}
1009
1010	//--------------------------------------------------------------------------
1011	// TryStmt
1012	template< typename core_t >
1013	const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
1014	VISIT_START( node );
1015
1016	if ( __visit_children() ) {
1017	maybe_accept( node, &TryStmt::body );
1018	maybe_accept( node, &TryStmt::handlers );
1019	maybe_accept( node, &TryStmt::finally );
1020	}
1021
1022	VISIT_END( Stmt, node );
1023	}
1024
1025	//--------------------------------------------------------------------------
1026	// CatchClause
1027	template< typename core_t >
1028	const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
1029	VISIT_START( node );
1030
1031	if ( __visit_children() ) {
1032	// catch statements introduce a level of scope (for the caught exception)
1033	guard_symtab guard { *this };
1034	maybe_accept( node, &CatchClause::decl );
1035	maybe_accept_top( node, &CatchClause::cond );
1036	maybe_accept_as_compound( node, &CatchClause::body );
1037	}
1038
1039	VISIT_END( CatchClause, node );
1040	}
1041
1042	//--------------------------------------------------------------------------
1043	// FinallyClause
1044	template< typename core_t >
1045	const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
1046	VISIT_START( node );
1047
1048	if ( __visit_children() ) {
1049	maybe_accept( node, &FinallyClause::body );
1050	}
1051
1052	VISIT_END( FinallyClause, node );
1053	}
1054
1055	//--------------------------------------------------------------------------
1056	// FinallyStmt
1057	template< typename core_t >
1058	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
1059	VISIT_START( node );
1060
1061	if ( __visit_children() ) {
1062	maybe_accept( node, &SuspendStmt::then );
1063	}
1064
1065	VISIT_END( Stmt, node );
1066	}
1067
1068	//--------------------------------------------------------------------------
1069	// WaitForStmt
1070	template< typename core_t >
1071	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
1072	VISIT_START( node );
1073
1074	if ( __visit_children() ) {
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 );
1081	}
1082
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 );
1091
1092	if ( __visit_children() ) {
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 );
1097	}
1098
1099	VISIT_END( WaitForClause, node );
1100	}
1101
1102	//--------------------------------------------------------------------------
1103	// WithStmt
1104	template< typename core_t >
1105	const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
1106	VISIT_START( node );
1107
1108	if ( __visit_children() ) {
1109	maybe_accept( node, &WithStmt::exprs );
1110	{
1111	// catch statements introduce a level of scope (for the caught exception)
1112	guard_symtab guard { *this };
1113	__pass::symtab::addWith( core, 0, node->exprs, node );
1114	maybe_accept( node, &WithStmt::stmt );
1115	}
1116	}
1117
1118	VISIT_END( Stmt, node );
1119	}
1120
1121	//--------------------------------------------------------------------------
1122	// NullStmt
1123	template< typename core_t >
1124	const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
1125	VISIT_START( node );
1126	VISIT_END( NullStmt, node );
1127	}
1128
1129	//--------------------------------------------------------------------------
1130	// DeclStmt
1131	template< typename core_t >
1132	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
1133	VISIT_START( node );
1134
1135	if ( __visit_children() ) {
1136	maybe_accept( node, &DeclStmt::decl );
1137	}
1138
1139	VISIT_END( Stmt, node );
1140	}
1141
1142	//--------------------------------------------------------------------------
1143	// ImplicitCtorDtorStmt
1144	template< typename core_t >
1145	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
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
1150	if ( __visit_children() ) {
1151	maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
1152	}
1153
1154	VISIT_END( Stmt, node );
1155	}
1156
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
1163	if ( __visit_children() ) {
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 );
1168	}
1169
1170	VISIT_END( Stmt, node );
1171	}
1172
1173	//--------------------------------------------------------------------------
1174	// ApplicationExpr
1175	template< typename core_t >
1176	const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
1177	VISIT_START( node );
1178
1179	if ( __visit_children() ) {
1180	{
1181	guard_symtab guard { *this };
1182	maybe_accept( node, &ApplicationExpr::result );
1183	}
1184	maybe_accept( node, &ApplicationExpr::func );
1185	maybe_accept( node, &ApplicationExpr::args );
1186	}
1187
1188	VISIT_END( Expr, node );
1189	}
1190
1191	//--------------------------------------------------------------------------
1192	// UntypedExpr
1193	template< typename core_t >
1194	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
1195	VISIT_START( node );
1196
1197	if ( __visit_children() ) {
1198	{
1199	guard_symtab guard { *this };
1200	maybe_accept( node, &UntypedExpr::result );
1201	}
1202
1203	maybe_accept( node, &UntypedExpr::args );
1204	}
1205
1206	VISIT_END( Expr, node );
1207	}
1208
1209	//--------------------------------------------------------------------------
1210	// NameExpr
1211	template< typename core_t >
1212	const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
1213	VISIT_START( node );
1214
1215	if ( __visit_children() ) {
1216	guard_symtab guard { *this };
1217	maybe_accept( node, &NameExpr::result );
1218	}
1219
1220	VISIT_END( Expr, node );
1221	}
1222
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
1235	//--------------------------------------------------------------------------
1236	// CastExpr
1237	template< typename core_t >
1238	const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
1239	VISIT_START( node );
1240
1241	if ( __visit_children() ) {
1242	{
1243	guard_symtab guard { *this };
1244	maybe_accept( node, &CastExpr::result );
1245	}
1246	maybe_accept( node, &CastExpr::arg );
1247	}
1248
1249	VISIT_END( Expr, node );
1250	}
1251
1252	//--------------------------------------------------------------------------
1253	// KeywordCastExpr
1254	template< typename core_t >
1255	const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
1256	VISIT_START( node );
1257
1258	if ( __visit_children() ) {
1259	{
1260	guard_symtab guard { *this };
1261	maybe_accept( node, &KeywordCastExpr::result );
1262	}
1263	maybe_accept( node, &KeywordCastExpr::arg );
1264	}
1265
1266	VISIT_END( Expr, node );
1267	}
1268
1269	//--------------------------------------------------------------------------
1270	// VirtualCastExpr
1271	template< typename core_t >
1272	const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
1273	VISIT_START( node );
1274
1275	if ( __visit_children() ) {
1276	{
1277	guard_symtab guard { *this };
1278	maybe_accept( node, &VirtualCastExpr::result );
1279	}
1280	maybe_accept( node, &VirtualCastExpr::arg );
1281	}
1282
1283	VISIT_END( Expr, node );
1284	}
1285
1286	//--------------------------------------------------------------------------
1287	// AddressExpr
1288	template< typename core_t >
1289	const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
1290	VISIT_START( node );
1291
1292	if ( __visit_children() ) {
1293	{
1294	guard_symtab guard { *this };
1295	maybe_accept( node, &AddressExpr::result );
1296	}
1297	maybe_accept( node, &AddressExpr::arg );
1298	}
1299
1300	VISIT_END( Expr, node );
1301	}
1302
1303	//--------------------------------------------------------------------------
1304	// LabelAddressExpr
1305	template< typename core_t >
1306	const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
1307	VISIT_START( node );
1308
1309	if ( __visit_children() ) {
1310	guard_symtab guard { *this };
1311	maybe_accept( node, &LabelAddressExpr::result );
1312	}
1313
1314	VISIT_END( Expr, node );
1315	}
1316
1317	//--------------------------------------------------------------------------
1318	// UntypedMemberExpr
1319	template< typename core_t >
1320	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
1321	VISIT_START( node );
1322
1323	if ( __visit_children() ) {
1324	{
1325	guard_symtab guard { *this };
1326	maybe_accept( node, &UntypedMemberExpr::result );
1327	}
1328	maybe_accept( node, &UntypedMemberExpr::aggregate );
1329	maybe_accept( node, &UntypedMemberExpr::member );
1330	}
1331
1332	VISIT_END( Expr, node );
1333	}
1334
1335	//--------------------------------------------------------------------------
1336	// MemberExpr
1337	template< typename core_t >
1338	const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
1339	VISIT_START( node );
1340
1341	if ( __visit_children() ) {
1342	{
1343	guard_symtab guard { *this };
1344	maybe_accept( node, &MemberExpr::result );
1345	}
1346	maybe_accept( node, &MemberExpr::aggregate );
1347	}
1348
1349	VISIT_END( Expr, node );
1350	}
1351
1352	//--------------------------------------------------------------------------
1353	// VariableExpr
1354	template< typename core_t >
1355	const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
1356	VISIT_START( node );
1357
1358	if ( __visit_children() ) {
1359	guard_symtab guard { *this };
1360	maybe_accept( node, &VariableExpr::result );
1361	}
1362
1363	VISIT_END( Expr, node );
1364	}
1365
1366	//--------------------------------------------------------------------------
1367	// ConstantExpr
1368	template< typename core_t >
1369	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
1370	VISIT_START( node );
1371
1372	if ( __visit_children() ) {
1373	guard_symtab guard { *this };
1374	maybe_accept( node, &ConstantExpr::result );
1375	}
1376
1377	VISIT_END( Expr, node );
1378	}
1379
1380	//--------------------------------------------------------------------------
1381	// SizeofExpr
1382	template< typename core_t >
1383	const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
1384	VISIT_START( node );
1385
1386	if ( __visit_children() ) {
1387	{
1388	guard_symtab guard { *this };
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	}
1396	}
1397
1398	VISIT_END( Expr, node );
1399	}
1400
1401	//--------------------------------------------------------------------------
1402	// AlignofExpr
1403	template< typename core_t >
1404	const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
1405	VISIT_START( node );
1406
1407	if ( __visit_children() ) {
1408	{
1409	guard_symtab guard { *this };
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	}
1417	}
1418
1419	VISIT_END( Expr, node );
1420	}
1421
1422	//--------------------------------------------------------------------------
1423	// UntypedOffsetofExpr
1424	template< typename core_t >
1425	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
1426	VISIT_START( node );
1427
1428	if ( __visit_children() ) {
1429	{
1430	guard_symtab guard { *this };
1431	maybe_accept( node, &UntypedOffsetofExpr::result );
1432	}
1433	maybe_accept( node, &UntypedOffsetofExpr::type );
1434	}
1435
1436	VISIT_END( Expr, node );
1437	}
1438
1439	//--------------------------------------------------------------------------
1440	// OffsetofExpr
1441	template< typename core_t >
1442	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
1443	VISIT_START( node );
1444
1445	if ( __visit_children() ) {
1446	{
1447	guard_symtab guard { *this };
1448	maybe_accept( node, &OffsetofExpr::result );
1449	}
1450	maybe_accept( node, &OffsetofExpr::type );
1451	}
1452
1453	VISIT_END( Expr, node );
1454	}
1455
1456	//--------------------------------------------------------------------------
1457	// OffsetPackExpr
1458	template< typename core_t >
1459	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
1460	VISIT_START( node );
1461
1462	if ( __visit_children() ) {
1463	{
1464	guard_symtab guard { *this };
1465	maybe_accept( node, &OffsetPackExpr::result );
1466	}
1467	maybe_accept( node, &OffsetPackExpr::type );
1468	}
1469
1470	VISIT_END( Expr, node );
1471	}
1472
1473	//--------------------------------------------------------------------------
1474	// LogicalExpr
1475	template< typename core_t >
1476	const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
1477	VISIT_START( node );
1478
1479	if ( __visit_children() ) {
1480	{
1481	guard_symtab guard { *this };
1482	maybe_accept( node, &LogicalExpr::result );
1483	}
1484	maybe_accept( node, &LogicalExpr::arg1 );
1485	maybe_accept( node, &LogicalExpr::arg2 );
1486	}
1487
1488	VISIT_END( Expr, node );
1489	}
1490
1491	//--------------------------------------------------------------------------
1492	// ConditionalExpr
1493	template< typename core_t >
1494	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
1495	VISIT_START( node );
1496
1497	if ( __visit_children() ) {
1498	{
1499	guard_symtab guard { *this };
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 );
1505	}
1506
1507	VISIT_END( Expr, node );
1508	}
1509
1510	//--------------------------------------------------------------------------
1511	// CommaExpr
1512	template< typename core_t >
1513	const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
1514	VISIT_START( node );
1515
1516	if ( __visit_children() ) {
1517	{
1518	guard_symtab guard { *this };
1519	maybe_accept( node, &CommaExpr::result );
1520	}
1521	maybe_accept( node, &CommaExpr::arg1 );
1522	maybe_accept( node, &CommaExpr::arg2 );
1523	}
1524
1525	VISIT_END( Expr, node );
1526	}
1527
1528	//--------------------------------------------------------------------------
1529	// TypeExpr
1530	template< typename core_t >
1531	const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
1532	VISIT_START( node );
1533
1534	if ( __visit_children() ) {
1535	{
1536	guard_symtab guard { *this };
1537	maybe_accept( node, &TypeExpr::result );
1538	}
1539	maybe_accept( node, &TypeExpr::type );
1540	}
1541
1542	VISIT_END( Expr, node );
1543	}
1544
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
1559	//--------------------------------------------------------------------------
1560	// AsmExpr
1561	template< typename core_t >
1562	const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
1563	VISIT_START( node );
1564
1565	if ( __visit_children() ) {
1566	{
1567	guard_symtab guard { *this };
1568	maybe_accept( node, &AsmExpr::result );
1569	}
1570	maybe_accept( node, &AsmExpr::constraint );
1571	maybe_accept( node, &AsmExpr::operand );
1572	}
1573
1574	VISIT_END( Expr, node );
1575	}
1576
1577	//--------------------------------------------------------------------------
1578	// ImplicitCopyCtorExpr
1579	template< typename core_t >
1580	const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
1581	VISIT_START( node );
1582
1583	if ( __visit_children() ) {
1584	{
1585	guard_symtab guard { *this };
1586	maybe_accept( node, &ImplicitCopyCtorExpr::result );
1587	}
1588	maybe_accept( node, &ImplicitCopyCtorExpr::callExpr );
1589	}
1590
1591	VISIT_END( Expr, node );
1592	}
1593
1594	//--------------------------------------------------------------------------
1595	// ConstructorExpr
1596	template< typename core_t >
1597	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
1598	VISIT_START( node );
1599
1600	if ( __visit_children() ) {
1601	{
1602	guard_symtab guard { *this };
1603	maybe_accept( node, &ConstructorExpr::result );
1604	}
1605	maybe_accept( node, &ConstructorExpr::callExpr );
1606	}
1607
1608	VISIT_END( Expr, node );
1609	}
1610
1611	//--------------------------------------------------------------------------
1612	// CompoundLiteralExpr
1613	template< typename core_t >
1614	const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
1615	VISIT_START( node );
1616
1617	if ( __visit_children() ) {
1618	{
1619	guard_symtab guard { *this };
1620	maybe_accept( node, &CompoundLiteralExpr::result );
1621	}
1622	maybe_accept( node, &CompoundLiteralExpr::init );
1623	}
1624
1625	VISIT_END( Expr, node );
1626	}
1627
1628	//--------------------------------------------------------------------------
1629	// RangeExpr
1630	template< typename core_t >
1631	const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
1632	VISIT_START( node );
1633
1634	if ( __visit_children() ) {
1635	{
1636	guard_symtab guard { *this };
1637	maybe_accept( node, &RangeExpr::result );
1638	}
1639	maybe_accept( node, &RangeExpr::low );
1640	maybe_accept( node, &RangeExpr::high );
1641	}
1642
1643	VISIT_END( Expr, node );
1644	}
1645
1646	//--------------------------------------------------------------------------
1647	// UntypedTupleExpr
1648	template< typename core_t >
1649	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
1650	VISIT_START( node );
1651
1652	if ( __visit_children() ) {
1653	{
1654	guard_symtab guard { *this };
1655	maybe_accept( node, &UntypedTupleExpr::result );
1656	}
1657	maybe_accept( node, &UntypedTupleExpr::exprs );
1658	}
1659
1660	VISIT_END( Expr, node );
1661	}
1662
1663	//--------------------------------------------------------------------------
1664	// TupleExpr
1665	template< typename core_t >
1666	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
1667	VISIT_START( node );
1668
1669	if ( __visit_children() ) {
1670	{
1671	guard_symtab guard { *this };
1672	maybe_accept( node, &TupleExpr::result );
1673	}
1674	maybe_accept( node, &TupleExpr::exprs );
1675	}
1676
1677	VISIT_END( Expr, node );
1678	}
1679
1680	//--------------------------------------------------------------------------
1681	// TupleIndexExpr
1682	template< typename core_t >
1683	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
1684	VISIT_START( node );
1685
1686	if ( __visit_children() ) {
1687	{
1688	guard_symtab guard { *this };
1689	maybe_accept( node, &TupleIndexExpr::result );
1690	}
1691	maybe_accept( node, &TupleIndexExpr::tuple );
1692	}
1693
1694	VISIT_END( Expr, node );
1695	}
1696
1697	//--------------------------------------------------------------------------
1698	// TupleAssignExpr
1699	template< typename core_t >
1700	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
1701	VISIT_START( node );
1702
1703	if ( __visit_children() ) {
1704	{
1705	guard_symtab guard { *this };
1706	maybe_accept( node, &TupleAssignExpr::result );
1707	}
1708	maybe_accept( node, &TupleAssignExpr::stmtExpr );
1709	}
1710
1711	VISIT_END( Expr, node );
1712	}
1713
1714	//--------------------------------------------------------------------------
1715	// StmtExpr
1716	template< typename core_t >
1717	const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
1718	VISIT_START( node );
1719
1720	if ( __visit_children() ) {
1721	// don't want statements from outer CompoundStmts to be added to this StmtExpr
1722	// get the stmts that will need to be spliced in
1723	auto stmts_before = __pass::stmtsToAddBefore( core, 0);
1724	auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
1725
1726	// These may be modified by subnode but most be restored once we exit this statemnet.
1727	ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
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	{
1732	guard_symtab guard { *this };
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 );
1738	}
1739
1740	VISIT_END( Expr, node );
1741	}
1742
1743	//--------------------------------------------------------------------------
1744	// UniqueExpr
1745	template< typename core_t >
1746	const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
1747	VISIT_START( node );
1748
1749	if ( __visit_children() ) {
1750	{
1751	guard_symtab guard { *this };
1752	maybe_accept( node, &UniqueExpr::result );
1753	}
1754	maybe_accept( node, &UniqueExpr::expr );
1755	}
1756
1757	VISIT_END( Expr, node );
1758	}
1759
1760	//--------------------------------------------------------------------------
1761	// UntypedInitExpr
1762	template< typename core_t >
1763	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
1764	VISIT_START( node );
1765
1766	if ( __visit_children() ) {
1767	{
1768	guard_symtab guard { *this };
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.
1773	}
1774
1775	VISIT_END( Expr, node );
1776	}
1777
1778	//--------------------------------------------------------------------------
1779	// InitExpr
1780	template< typename core_t >
1781	const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
1782	VISIT_START( node );
1783
1784	if ( __visit_children() ) {
1785	{
1786	guard_symtab guard { *this };
1787	maybe_accept( node, &InitExpr::result );
1788	}
1789	maybe_accept( node, &InitExpr::expr );
1790	maybe_accept( node, &InitExpr::designation );
1791	}
1792
1793	VISIT_END( Expr, node );
1794	}
1795
1796	//--------------------------------------------------------------------------
1797	// DeletedExpr
1798	template< typename core_t >
1799	const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
1800	VISIT_START( node );
1801
1802	if ( __visit_children() ) {
1803	{
1804	guard_symtab guard { *this };
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.
1809	}
1810
1811	VISIT_END( Expr, node );
1812	}
1813
1814	//--------------------------------------------------------------------------
1815	// DefaultArgExpr
1816	template< typename core_t >
1817	const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
1818	VISIT_START( node );
1819
1820	if ( __visit_children() ) {
1821	{
1822	guard_symtab guard { *this };
1823	maybe_accept( node, &DefaultArgExpr::result );
1824	}
1825	maybe_accept( node, &DefaultArgExpr::expr );
1826	}
1827
1828	VISIT_END( Expr, node );
1829	}
1830
1831	//--------------------------------------------------------------------------
1832	// GenericExpr
1833	template< typename core_t >
1834	const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
1835	VISIT_START( node );
1836
1837	if ( __visit_children() ) {
1838	{
1839	guard_symtab guard { *this };
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 ) {
1848	const Type * type = nullptr;
1849	if( assoc.type ) {
1850	guard_symtab guard { *this };
1851	type = assoc.type->accept( *this );
1852	if( type != assoc.type ) mutated = true;
1853	}
1854	const Expr * expr = nullptr;
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) {
1863	auto n = __pass::mutate<core_t>(node);
1864	n->associations = std::move( new_kids );
1865	node = n;
1866	}
1867	}
1868
1869	VISIT_END( Expr, node );
1870	}
1871
1872	//--------------------------------------------------------------------------
1873	// VoidType
1874	template< typename core_t >
1875	const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
1876	VISIT_START( node );
1877
1878	VISIT_END( Type, node );
1879	}
1880
1881	//--------------------------------------------------------------------------
1882	// BasicType
1883	template< typename core_t >
1884	const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
1885	VISIT_START( node );
1886
1887	VISIT_END( Type, node );
1888	}
1889
1890	//--------------------------------------------------------------------------
1891	// PointerType
1892	template< typename core_t >
1893	const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
1894	VISIT_START( node );
1895
1896	if ( __visit_children() ) {
1897	maybe_accept( node, &PointerType::dimension );
1898	maybe_accept( node, &PointerType::base );
1899	}
1900
1901	VISIT_END( Type, node );
1902	}
1903
1904	//--------------------------------------------------------------------------
1905	// ArrayType
1906	template< typename core_t >
1907	const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
1908	VISIT_START( node );
1909
1910	if ( __visit_children() ) {
1911	maybe_accept( node, &ArrayType::dimension );
1912	maybe_accept( node, &ArrayType::base );
1913	}
1914
1915	VISIT_END( Type, node );
1916	}
1917
1918	//--------------------------------------------------------------------------
1919	// ReferenceType
1920	template< typename core_t >
1921	const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
1922	VISIT_START( node );
1923
1924	if ( __visit_children() ) {
1925	maybe_accept( node, &ReferenceType::base );
1926	}
1927
1928	VISIT_END( Type, node );
1929	}
1930
1931	//--------------------------------------------------------------------------
1932	// QualifiedType
1933	template< typename core_t >
1934	const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
1935	VISIT_START( node );
1936
1937	if ( __visit_children() ) {
1938	maybe_accept( node, &QualifiedType::parent );
1939	maybe_accept( node, &QualifiedType::child );
1940	}
1941
1942	VISIT_END( Type, node );
1943	}
1944
1945	//--------------------------------------------------------------------------
1946	// FunctionType
1947	template< typename core_t >
1948	const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
1949	VISIT_START( node );
1950
1951	if ( __visit_children() ) {
1952	// guard_forall_subs forall_guard { *this, node };
1953	// mutate_forall( node );
1954	maybe_accept( node, &FunctionType::assertions );
1955	maybe_accept( node, &FunctionType::returns );
1956	maybe_accept( node, &FunctionType::params );
1957	}
1958
1959	VISIT_END( Type, node );
1960	}
1961
1962	//--------------------------------------------------------------------------
1963	// StructInstType
1964	template< typename core_t >
1965	const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
1966	VISIT_START( node );
1967
1968	__pass::symtab::addStruct( core, 0, node->name );
1969
1970	if ( __visit_children() ) {
1971	guard_symtab guard { *this };
1972	maybe_accept( node, &StructInstType::params );
1973	}
1974
1975	VISIT_END( Type, node );
1976	}
1977
1978	//--------------------------------------------------------------------------
1979	// UnionInstType
1980	template< typename core_t >
1981	const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
1982	VISIT_START( node );
1983
1984	__pass::symtab::addUnion( core, 0, node->name );
1985
1986	if ( __visit_children() ) {
1987	guard_symtab guard { *this };
1988	maybe_accept( node, &UnionInstType::params );
1989	}
1990
1991	VISIT_END( Type, node );
1992	}
1993
1994	//--------------------------------------------------------------------------
1995	// EnumInstType
1996	template< typename core_t >
1997	const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
1998	VISIT_START( node );
1999
2000	if ( __visit_children() ) {
2001	maybe_accept( node, &EnumInstType::params );
2002	}
2003
2004	VISIT_END( Type, node );
2005	}
2006
2007	//--------------------------------------------------------------------------
2008	// TraitInstType
2009	template< typename core_t >
2010	const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
2011	VISIT_START( node );
2012
2013	if ( __visit_children() ) {
2014	maybe_accept( node, &TraitInstType::params );
2015	}
2016
2017	VISIT_END( Type, node );
2018	}
2019
2020	//--------------------------------------------------------------------------
2021	// TypeInstType
2022	template< typename core_t >
2023	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
2024	VISIT_START( node );
2025
2026	if ( __visit_children() ) {
2027	{
2028	maybe_accept( node, &TypeInstType::params );
2029	}
2030	// ensure that base re-bound if doing substitution
2031	__pass::forall::replace( core, 0, node );
2032	}
2033
2034	VISIT_END( Type, node );
2035	}
2036
2037	//--------------------------------------------------------------------------
2038	// TupleType
2039	template< typename core_t >
2040	const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
2041	VISIT_START( node );
2042
2043	if ( __visit_children() ) {
2044	maybe_accept( node, &TupleType::types );
2045	maybe_accept( node, &TupleType::members );
2046	}
2047
2048	VISIT_END( Type, node );
2049	}
2050
2051	//--------------------------------------------------------------------------
2052	// TypeofType
2053	template< typename core_t >
2054	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
2055	VISIT_START( node );
2056
2057	if ( __visit_children() ) {
2058	maybe_accept( node, &TypeofType::expr );
2059	}
2060
2061	VISIT_END( Type, node );
2062	}
2063
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
2070	if ( __visit_children() ) {
2071	maybe_accept( node, &VTableType::base );
2072	}
2073
2074	VISIT_END( Type, node );
2075	}
2076
2077	//--------------------------------------------------------------------------
2078	// VarArgsType
2079	template< typename core_t >
2080	const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
2081	VISIT_START( node );
2082
2083	VISIT_END( Type, node );
2084	}
2085
2086	//--------------------------------------------------------------------------
2087	// ZeroType
2088	template< typename core_t >
2089	const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
2090	VISIT_START( node );
2091
2092	VISIT_END( Type, node );
2093	}
2094
2095	//--------------------------------------------------------------------------
2096	// OneType
2097	template< typename core_t >
2098	const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
2099	VISIT_START( node );
2100
2101	VISIT_END( Type, node );
2102	}
2103
2104	//--------------------------------------------------------------------------
2105	// GlobalScopeType
2106	template< typename core_t >
2107	const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
2108	VISIT_START( node );
2109
2110	VISIT_END( Type, node );
2111	}
2112
2113
2114	//--------------------------------------------------------------------------
2115	// Designation
2116	template< typename core_t >
2117	const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
2118	VISIT_START( node );
2119
2120	if ( __visit_children() ) {
2121	maybe_accept( node, &Designation::designators );
2122	}
2123
2124	VISIT_END( Designation, node );
2125	}
2126
2127	//--------------------------------------------------------------------------
2128	// SingleInit
2129	template< typename core_t >
2130	const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
2131	VISIT_START( node );
2132
2133	if ( __visit_children() ) {
2134	maybe_accept_top( node, &SingleInit::value );
2135	}
2136
2137	VISIT_END( Init, node );
2138	}
2139
2140	//--------------------------------------------------------------------------
2141	// ListInit
2142	template< typename core_t >
2143	const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
2144	VISIT_START( node );
2145
2146	if ( __visit_children() ) {
2147	maybe_accept( node, &ListInit::designations );
2148	maybe_accept( node, &ListInit::initializers );
2149	}
2150
2151	VISIT_END( Init, node );
2152	}
2153
2154	//--------------------------------------------------------------------------
2155	// ConstructorInit
2156	template< typename core_t >
2157	const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
2158	VISIT_START( node );
2159
2160	if ( __visit_children() ) {
2161	maybe_accept( node, &ConstructorInit::ctor );
2162	maybe_accept( node, &ConstructorInit::dtor );
2163	maybe_accept( node, &ConstructorInit::init );
2164	}
2165
2166	VISIT_END( Init, node );
2167	}
2168
2169	//--------------------------------------------------------------------------
2170	// Attribute
2171	template< typename core_t >
2172	const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) {
2173	VISIT_START( node );
2174
2175	if ( __visit_children() ) {
2176	maybe_accept( node, &Attribute::params );
2177	}
2178
2179	VISIT_END( Attribute, node );
2180	}
2181
2182	//--------------------------------------------------------------------------
2183	// TypeSubstitution
2184	template< typename core_t >
2185	const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
2186	VISIT_START( node );
2187
2188	if ( __visit_children() ) {
2189	bool mutated = false;
2190	ast::TypeSubstitution::TypeMap new_map;
2191	for ( const auto & p : node->typeMap ) {
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 );
2199	new_node->typeMap.swap( new_map );
2200	node = new_node;
2201	}
2202	}
2203
2204	VISIT_END( TypeSubstitution, node );
2205	}
2206
2207	#undef VISIT_START
2208	#undef VISIT_END

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

Download in other formats: