Context Navigation

source: src/AST/Pass.impl.hpp @ 03c56f6

ADTast-experimental

Last change on this file since 03c56f6 was f2ff0a6, checked in by Andrew Beach <ajbeach@…>, 20 months ago
Function attributes are now visited earlier, so they are not considered to be within the function/function's body.
Property mode set to `100644`
File size: 64.9 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	// unlike structs, traits, and unions, enums inject their members into the global scope
689	maybe_accept( node, &EnumDecl::base );
690	maybe_accept( node, &EnumDecl::params );
691	maybe_accept( node, &EnumDecl::members );
692	maybe_accept( node, &EnumDecl::attributes );
693	}
694
695	VISIT_END( Decl, node );
696	}
697
698	//--------------------------------------------------------------------------
699	// TraitDecl
700	template< typename core_t >
701	const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
702	VISIT_START( node );
703
704	if ( __visit_children() ) {
705	guard_symtab guard { *this };
706	maybe_accept( node, &TraitDecl::params );
707	maybe_accept( node, &TraitDecl::members );
708	maybe_accept( node, &TraitDecl::attributes );
709	}
710
711	__pass::symtab::addTrait( core, 0, node );
712
713	VISIT_END( Decl, node );
714	}
715
716	//--------------------------------------------------------------------------
717	// TypeDecl
718	template< typename core_t >
719	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
720	VISIT_START( node );
721
722	if ( __visit_children() ) {
723	guard_symtab guard { *this };
724	maybe_accept( node, &TypeDecl::base );
725	}
726
727	// see A NOTE ON THE ORDER OF TRAVERSAL, above
728	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
729	// and may depend on the type itself
730	__pass::symtab::addType( core, 0, node );
731
732	if ( __visit_children() ) {
733	maybe_accept( node, &TypeDecl::assertions );
734
735	{
736	guard_symtab guard { *this };
737	maybe_accept( node, &TypeDecl::init );
738	}
739	}
740
741	VISIT_END( Decl, node );
742	}
743
744	//--------------------------------------------------------------------------
745	// TypedefDecl
746	template< typename core_t >
747	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
748	VISIT_START( node );
749
750	if ( __visit_children() ) {
751	guard_symtab guard { *this };
752	maybe_accept( node, &TypedefDecl::base );
753	}
754
755	__pass::symtab::addType( core, 0, node );
756
757	if ( __visit_children() ) {
758	maybe_accept( node, &TypedefDecl::assertions );
759	}
760
761	VISIT_END( Decl, node );
762	}
763
764	//--------------------------------------------------------------------------
765	// AsmDecl
766	template< typename core_t >
767	const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
768	VISIT_START( node );
769
770	if ( __visit_children() ) {
771	maybe_accept( node, &AsmDecl::stmt );
772	}
773
774	VISIT_END( AsmDecl, node );
775	}
776
777	//--------------------------------------------------------------------------
778	// DirectiveDecl
779	template< typename core_t >
780	const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
781	VISIT_START( node );
782
783	if ( __visit_children() ) {
784	maybe_accept( node, &DirectiveDecl::stmt );
785	}
786
787	VISIT_END( DirectiveDecl, node );
788	}
789
790	//--------------------------------------------------------------------------
791	// StaticAssertDecl
792	template< typename core_t >
793	const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
794	VISIT_START( node );
795
796	if ( __visit_children() ) {
797	maybe_accept_top( node, &StaticAssertDecl::cond );
798	maybe_accept( node, &StaticAssertDecl::msg );
799	}
800
801	VISIT_END( StaticAssertDecl, node );
802	}
803
804	//--------------------------------------------------------------------------
805	// DeclWithType
806	template< typename core_t >
807	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineValueDecl * node ) {
808	VISIT_START( node );
809
810	if ( __visit_children() ) {
811	{
812	guard_symtab guard { *this };
813	maybe_accept( node, &InlineValueDecl::type );
814	}
815	}
816
817	VISIT_END( DeclWithType, node );
818	}
819
820	//--------------------------------------------------------------------------
821	// CompoundStmt
822	template< typename core_t >
823	const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
824	VISIT_START( node );
825
826	if ( __visit_children() ) {
827	// Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
828	auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
829	if ( enterScope ) {
830	__pass::symtab::enter(core, 0);
831	__pass::scope::enter(core, 0);
832	}
833	}, [this, leaveScope = !this->atFunctionTop]() {
834	if ( leaveScope ) {
835	__pass::symtab::leave(core, 0);
836	__pass::scope::leave(core, 0);
837	}
838	});
839	ValueGuard< bool > guard2( atFunctionTop );
840	atFunctionTop = false;
841	guard_scope guard3 { *this };
842	maybe_accept( node, &CompoundStmt::kids );
843	}
844
845	VISIT_END( CompoundStmt, node );
846	}
847
848	//--------------------------------------------------------------------------
849	// ExprStmt
850	template< typename core_t >
851	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
852	VISIT_START( node );
853
854	if ( __visit_children() ) {
855	maybe_accept_top( node, &ExprStmt::expr );
856	}
857
858	VISIT_END( Stmt, node );
859	}
860
861	//--------------------------------------------------------------------------
862	// AsmStmt
863	template< typename core_t >
864	const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
865	VISIT_START( node )
866
867	if ( __visit_children() ) {
868	maybe_accept( node, &AsmStmt::instruction );
869	maybe_accept( node, &AsmStmt::output );
870	maybe_accept( node, &AsmStmt::input );
871	maybe_accept( node, &AsmStmt::clobber );
872	}
873
874	VISIT_END( Stmt, node );
875	}
876
877	//--------------------------------------------------------------------------
878	// DirectiveStmt
879	template< typename core_t >
880	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
881	VISIT_START( node )
882
883	VISIT_END( Stmt, node );
884	}
885
886	//--------------------------------------------------------------------------
887	// IfStmt
888	template< typename core_t >
889	const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
890	VISIT_START( node );
891
892	if ( __visit_children() ) {
893	// if statements introduce a level of scope (for the initialization)
894	guard_symtab guard { *this };
895	maybe_accept( node, &IfStmt::inits );
896	maybe_accept_top( node, &IfStmt::cond );
897	maybe_accept_as_compound( node, &IfStmt::then );
898	maybe_accept_as_compound( node, &IfStmt::else_ );
899	}
900
901	VISIT_END( Stmt, node );
902	}
903
904	//--------------------------------------------------------------------------
905	// WhileDoStmt
906	template< typename core_t >
907	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
908	VISIT_START( node );
909
910	if ( __visit_children() ) {
911	// while statements introduce a level of scope (for the initialization)
912	guard_symtab guard { *this };
913	maybe_accept( node, &WhileDoStmt::inits );
914	maybe_accept_top( node, &WhileDoStmt::cond );
915	maybe_accept_as_compound( node, &WhileDoStmt::body );
916	}
917
918	VISIT_END( Stmt, node );
919	}
920
921	//--------------------------------------------------------------------------
922	// ForStmt
923	template< typename core_t >
924	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
925	VISIT_START( node );
926
927	if ( __visit_children() ) {
928	// for statements introduce a level of scope (for the initialization)
929	guard_symtab guard { *this };
930	// xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
931	maybe_accept( node, &ForStmt::inits );
932	maybe_accept_top( node, &ForStmt::cond );
933	maybe_accept_top( node, &ForStmt::inc );
934	maybe_accept_as_compound( node, &ForStmt::body );
935	}
936
937	VISIT_END( Stmt, node );
938	}
939
940	//--------------------------------------------------------------------------
941	// SwitchStmt
942	template< typename core_t >
943	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
944	VISIT_START( node );
945
946	if ( __visit_children() ) {
947	maybe_accept_top( node, &SwitchStmt::cond );
948	maybe_accept( node, &SwitchStmt::cases );
949	}
950
951	VISIT_END( Stmt, node );
952	}
953
954	//--------------------------------------------------------------------------
955	// CaseClause
956	template< typename core_t >
957	const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
958	VISIT_START( node );
959
960	if ( __visit_children() ) {
961	maybe_accept_top( node, &CaseClause::cond );
962	maybe_accept( node, &CaseClause::stmts );
963	}
964
965	VISIT_END( CaseClause, node );
966	}
967
968	//--------------------------------------------------------------------------
969	// BranchStmt
970	template< typename core_t >
971	const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
972	VISIT_START( node );
973	VISIT_END( Stmt, node );
974	}
975
976	//--------------------------------------------------------------------------
977	// ReturnStmt
978	template< typename core_t >
979	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
980	VISIT_START( node );
981
982	if ( __visit_children() ) {
983	maybe_accept_top( node, &ReturnStmt::expr );
984	}
985
986	VISIT_END( Stmt, node );
987	}
988
989	//--------------------------------------------------------------------------
990	// ThrowStmt
991	template< typename core_t >
992	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
993	VISIT_START( node );
994
995	if ( __visit_children() ) {
996	maybe_accept( node, &ThrowStmt::expr );
997	maybe_accept( node, &ThrowStmt::target );
998	}
999
1000	VISIT_END( Stmt, node );
1001	}
1002
1003	//--------------------------------------------------------------------------
1004	// TryStmt
1005	template< typename core_t >
1006	const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
1007	VISIT_START( node );
1008
1009	if ( __visit_children() ) {
1010	maybe_accept( node, &TryStmt::body );
1011	maybe_accept( node, &TryStmt::handlers );
1012	maybe_accept( node, &TryStmt::finally );
1013	}
1014
1015	VISIT_END( Stmt, node );
1016	}
1017
1018	//--------------------------------------------------------------------------
1019	// CatchClause
1020	template< typename core_t >
1021	const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
1022	VISIT_START( node );
1023
1024	if ( __visit_children() ) {
1025	// catch statements introduce a level of scope (for the caught exception)
1026	guard_symtab guard { *this };
1027	maybe_accept( node, &CatchClause::decl );
1028	maybe_accept_top( node, &CatchClause::cond );
1029	maybe_accept_as_compound( node, &CatchClause::body );
1030	}
1031
1032	VISIT_END( CatchClause, node );
1033	}
1034
1035	//--------------------------------------------------------------------------
1036	// FinallyClause
1037	template< typename core_t >
1038	const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
1039	VISIT_START( node );
1040
1041	if ( __visit_children() ) {
1042	maybe_accept( node, &FinallyClause::body );
1043	}
1044
1045	VISIT_END( FinallyClause, node );
1046	}
1047
1048	//--------------------------------------------------------------------------
1049	// FinallyStmt
1050	template< typename core_t >
1051	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
1052	VISIT_START( node );
1053
1054	if ( __visit_children() ) {
1055	maybe_accept( node, &SuspendStmt::then );
1056	}
1057
1058	VISIT_END( Stmt, node );
1059	}
1060
1061	//--------------------------------------------------------------------------
1062	// WaitForStmt
1063	template< typename core_t >
1064	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
1065	VISIT_START( node );
1066
1067	if ( __visit_children() ) {
1068	maybe_accept( node, &WaitForStmt::clauses );
1069	maybe_accept( node, &WaitForStmt::timeout_time );
1070	maybe_accept( node, &WaitForStmt::timeout_stmt );
1071	maybe_accept( node, &WaitForStmt::timeout_cond );
1072	maybe_accept( node, &WaitForStmt::else_stmt );
1073	maybe_accept( node, &WaitForStmt::else_cond );
1074	}
1075
1076	VISIT_END( Stmt, node );
1077	}
1078
1079	//--------------------------------------------------------------------------
1080	// WaitForClause
1081	template< typename core_t >
1082	const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
1083	VISIT_START( node );
1084
1085	if ( __visit_children() ) {
1086	maybe_accept( node, &WaitForClause::target_func );
1087	maybe_accept( node, &WaitForClause::target_args );
1088	maybe_accept( node, &WaitForClause::stmt );
1089	maybe_accept( node, &WaitForClause::cond );
1090	}
1091
1092	VISIT_END( WaitForClause, node );
1093	}
1094
1095	//--------------------------------------------------------------------------
1096	// WithStmt
1097	template< typename core_t >
1098	const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
1099	VISIT_START( node );
1100
1101	if ( __visit_children() ) {
1102	maybe_accept( node, &WithStmt::exprs );
1103	{
1104	// catch statements introduce a level of scope (for the caught exception)
1105	guard_symtab guard { *this };
1106	__pass::symtab::addWith( core, 0, node->exprs, node );
1107	maybe_accept( node, &WithStmt::stmt );
1108	}
1109	}
1110
1111	VISIT_END( Stmt, node );
1112	}
1113
1114	//--------------------------------------------------------------------------
1115	// NullStmt
1116	template< typename core_t >
1117	const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
1118	VISIT_START( node );
1119	VISIT_END( NullStmt, node );
1120	}
1121
1122	//--------------------------------------------------------------------------
1123	// DeclStmt
1124	template< typename core_t >
1125	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
1126	VISIT_START( node );
1127
1128	if ( __visit_children() ) {
1129	maybe_accept( node, &DeclStmt::decl );
1130	}
1131
1132	VISIT_END( Stmt, node );
1133	}
1134
1135	//--------------------------------------------------------------------------
1136	// ImplicitCtorDtorStmt
1137	template< typename core_t >
1138	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
1139	VISIT_START( node );
1140
1141	// For now this isn't visited, it is unclear if this causes problem
1142	// if all tests are known to pass, remove this code
1143	if ( __visit_children() ) {
1144	maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
1145	}
1146
1147	VISIT_END( Stmt, node );
1148	}
1149
1150	//--------------------------------------------------------------------------
1151	// MutexStmt
1152	template< typename core_t >
1153	const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
1154	VISIT_START( node );
1155
1156	if ( __visit_children() ) {
1157	// mutex statements introduce a level of scope (for the initialization)
1158	guard_symtab guard { *this };
1159	maybe_accept( node, &MutexStmt::stmt );
1160	maybe_accept( node, &MutexStmt::mutexObjs );
1161	}
1162
1163	VISIT_END( Stmt, node );
1164	}
1165
1166	//--------------------------------------------------------------------------
1167	// ApplicationExpr
1168	template< typename core_t >
1169	const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
1170	VISIT_START( node );
1171
1172	if ( __visit_children() ) {
1173	{
1174	guard_symtab guard { *this };
1175	maybe_accept( node, &ApplicationExpr::result );
1176	}
1177	maybe_accept( node, &ApplicationExpr::func );
1178	maybe_accept( node, &ApplicationExpr::args );
1179	}
1180
1181	VISIT_END( Expr, node );
1182	}
1183
1184	//--------------------------------------------------------------------------
1185	// UntypedExpr
1186	template< typename core_t >
1187	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
1188	VISIT_START( node );
1189
1190	if ( __visit_children() ) {
1191	{
1192	guard_symtab guard { *this };
1193	maybe_accept( node, &UntypedExpr::result );
1194	}
1195
1196	maybe_accept( node, &UntypedExpr::args );
1197	}
1198
1199	VISIT_END( Expr, node );
1200	}
1201
1202	//--------------------------------------------------------------------------
1203	// NameExpr
1204	template< typename core_t >
1205	const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
1206	VISIT_START( node );
1207
1208	if ( __visit_children() ) {
1209	guard_symtab guard { *this };
1210	maybe_accept( node, &NameExpr::result );
1211	}
1212
1213	VISIT_END( Expr, node );
1214	}
1215
1216	//--------------------------------------------------------------------------
1217	// QualifiedNameExpr
1218	template< typename core_t >
1219	const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
1220	VISIT_START( node );
1221	if ( __visit_children() ) {
1222	guard_symtab guard { *this };
1223	maybe_accept( node, &QualifiedNameExpr::type_decl );
1224	}
1225	VISIT_END( Expr, node );
1226	}
1227
1228	//--------------------------------------------------------------------------
1229	// CastExpr
1230	template< typename core_t >
1231	const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
1232	VISIT_START( node );
1233
1234	if ( __visit_children() ) {
1235	{
1236	guard_symtab guard { *this };
1237	maybe_accept( node, &CastExpr::result );
1238	}
1239	maybe_accept( node, &CastExpr::arg );
1240	}
1241
1242	VISIT_END( Expr, node );
1243	}
1244
1245	//--------------------------------------------------------------------------
1246	// KeywordCastExpr
1247	template< typename core_t >
1248	const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
1249	VISIT_START( node );
1250
1251	if ( __visit_children() ) {
1252	{
1253	guard_symtab guard { *this };
1254	maybe_accept( node, &KeywordCastExpr::result );
1255	}
1256	maybe_accept( node, &KeywordCastExpr::arg );
1257	}
1258
1259	VISIT_END( Expr, node );
1260	}
1261
1262	//--------------------------------------------------------------------------
1263	// VirtualCastExpr
1264	template< typename core_t >
1265	const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
1266	VISIT_START( node );
1267
1268	if ( __visit_children() ) {
1269	{
1270	guard_symtab guard { *this };
1271	maybe_accept( node, &VirtualCastExpr::result );
1272	}
1273	maybe_accept( node, &VirtualCastExpr::arg );
1274	}
1275
1276	VISIT_END( Expr, node );
1277	}
1278
1279	//--------------------------------------------------------------------------
1280	// AddressExpr
1281	template< typename core_t >
1282	const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
1283	VISIT_START( node );
1284
1285	if ( __visit_children() ) {
1286	{
1287	guard_symtab guard { *this };
1288	maybe_accept( node, &AddressExpr::result );
1289	}
1290	maybe_accept( node, &AddressExpr::arg );
1291	}
1292
1293	VISIT_END( Expr, node );
1294	}
1295
1296	//--------------------------------------------------------------------------
1297	// LabelAddressExpr
1298	template< typename core_t >
1299	const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
1300	VISIT_START( node );
1301
1302	if ( __visit_children() ) {
1303	guard_symtab guard { *this };
1304	maybe_accept( node, &LabelAddressExpr::result );
1305	}
1306
1307	VISIT_END( Expr, node );
1308	}
1309
1310	//--------------------------------------------------------------------------
1311	// UntypedMemberExpr
1312	template< typename core_t >
1313	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
1314	VISIT_START( node );
1315
1316	if ( __visit_children() ) {
1317	{
1318	guard_symtab guard { *this };
1319	maybe_accept( node, &UntypedMemberExpr::result );
1320	}
1321	maybe_accept( node, &UntypedMemberExpr::aggregate );
1322	maybe_accept( node, &UntypedMemberExpr::member );
1323	}
1324
1325	VISIT_END( Expr, node );
1326	}
1327
1328	//--------------------------------------------------------------------------
1329	// MemberExpr
1330	template< typename core_t >
1331	const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
1332	VISIT_START( node );
1333
1334	if ( __visit_children() ) {
1335	{
1336	guard_symtab guard { *this };
1337	maybe_accept( node, &MemberExpr::result );
1338	}
1339	maybe_accept( node, &MemberExpr::aggregate );
1340	}
1341
1342	VISIT_END( Expr, node );
1343	}
1344
1345	//--------------------------------------------------------------------------
1346	// VariableExpr
1347	template< typename core_t >
1348	const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
1349	VISIT_START( node );
1350
1351	if ( __visit_children() ) {
1352	guard_symtab guard { *this };
1353	maybe_accept( node, &VariableExpr::result );
1354	}
1355
1356	VISIT_END( Expr, node );
1357	}
1358
1359	//--------------------------------------------------------------------------
1360	// ConstantExpr
1361	template< typename core_t >
1362	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
1363	VISIT_START( node );
1364
1365	if ( __visit_children() ) {
1366	guard_symtab guard { *this };
1367	maybe_accept( node, &ConstantExpr::result );
1368	}
1369
1370	VISIT_END( Expr, node );
1371	}
1372
1373	//--------------------------------------------------------------------------
1374	// SizeofExpr
1375	template< typename core_t >
1376	const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
1377	VISIT_START( node );
1378
1379	if ( __visit_children() ) {
1380	{
1381	guard_symtab guard { *this };
1382	maybe_accept( node, &SizeofExpr::result );
1383	}
1384	if ( node->type ) {
1385	maybe_accept( node, &SizeofExpr::type );
1386	} else {
1387	maybe_accept( node, &SizeofExpr::expr );
1388	}
1389	}
1390
1391	VISIT_END( Expr, node );
1392	}
1393
1394	//--------------------------------------------------------------------------
1395	// AlignofExpr
1396	template< typename core_t >
1397	const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
1398	VISIT_START( node );
1399
1400	if ( __visit_children() ) {
1401	{
1402	guard_symtab guard { *this };
1403	maybe_accept( node, &AlignofExpr::result );
1404	}
1405	if ( node->type ) {
1406	maybe_accept( node, &AlignofExpr::type );
1407	} else {
1408	maybe_accept( node, &AlignofExpr::expr );
1409	}
1410	}
1411
1412	VISIT_END( Expr, node );
1413	}
1414
1415	//--------------------------------------------------------------------------
1416	// UntypedOffsetofExpr
1417	template< typename core_t >
1418	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
1419	VISIT_START( node );
1420
1421	if ( __visit_children() ) {
1422	{
1423	guard_symtab guard { *this };
1424	maybe_accept( node, &UntypedOffsetofExpr::result );
1425	}
1426	maybe_accept( node, &UntypedOffsetofExpr::type );
1427	}
1428
1429	VISIT_END( Expr, node );
1430	}
1431
1432	//--------------------------------------------------------------------------
1433	// OffsetofExpr
1434	template< typename core_t >
1435	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
1436	VISIT_START( node );
1437
1438	if ( __visit_children() ) {
1439	{
1440	guard_symtab guard { *this };
1441	maybe_accept( node, &OffsetofExpr::result );
1442	}
1443	maybe_accept( node, &OffsetofExpr::type );
1444	}
1445
1446	VISIT_END( Expr, node );
1447	}
1448
1449	//--------------------------------------------------------------------------
1450	// OffsetPackExpr
1451	template< typename core_t >
1452	const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
1453	VISIT_START( node );
1454
1455	if ( __visit_children() ) {
1456	{
1457	guard_symtab guard { *this };
1458	maybe_accept( node, &OffsetPackExpr::result );
1459	}
1460	maybe_accept( node, &OffsetPackExpr::type );
1461	}
1462
1463	VISIT_END( Expr, node );
1464	}
1465
1466	//--------------------------------------------------------------------------
1467	// LogicalExpr
1468	template< typename core_t >
1469	const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
1470	VISIT_START( node );
1471
1472	if ( __visit_children() ) {
1473	{
1474	guard_symtab guard { *this };
1475	maybe_accept( node, &LogicalExpr::result );
1476	}
1477	maybe_accept( node, &LogicalExpr::arg1 );
1478	maybe_accept( node, &LogicalExpr::arg2 );
1479	}
1480
1481	VISIT_END( Expr, node );
1482	}
1483
1484	//--------------------------------------------------------------------------
1485	// ConditionalExpr
1486	template< typename core_t >
1487	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
1488	VISIT_START( node );
1489
1490	if ( __visit_children() ) {
1491	{
1492	guard_symtab guard { *this };
1493	maybe_accept( node, &ConditionalExpr::result );
1494	}
1495	maybe_accept( node, &ConditionalExpr::arg1 );
1496	maybe_accept( node, &ConditionalExpr::arg2 );
1497	maybe_accept( node, &ConditionalExpr::arg3 );
1498	}
1499
1500	VISIT_END( Expr, node );
1501	}
1502
1503	//--------------------------------------------------------------------------
1504	// CommaExpr
1505	template< typename core_t >
1506	const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
1507	VISIT_START( node );
1508
1509	if ( __visit_children() ) {
1510	{
1511	guard_symtab guard { *this };
1512	maybe_accept( node, &CommaExpr::result );
1513	}
1514	maybe_accept( node, &CommaExpr::arg1 );
1515	maybe_accept( node, &CommaExpr::arg2 );
1516	}
1517
1518	VISIT_END( Expr, node );
1519	}
1520
1521	//--------------------------------------------------------------------------
1522	// TypeExpr
1523	template< typename core_t >
1524	const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
1525	VISIT_START( node );
1526
1527	if ( __visit_children() ) {
1528	{
1529	guard_symtab guard { *this };
1530	maybe_accept( node, &TypeExpr::result );
1531	}
1532	maybe_accept( node, &TypeExpr::type );
1533	}
1534
1535	VISIT_END( Expr, node );
1536	}
1537
1538	//--------------------------------------------------------------------------
1539	// DimensionExpr
1540	template< typename core_t >
1541	const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
1542	VISIT_START( node );
1543
1544	if ( __visit_children() ) {
1545	guard_symtab guard { *this };
1546	maybe_accept( node, &DimensionExpr::result );
1547	}
1548
1549	VISIT_END( Expr, node );
1550	}
1551
1552	//--------------------------------------------------------------------------
1553	// AsmExpr
1554	template< typename core_t >
1555	const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
1556	VISIT_START( node );
1557
1558	if ( __visit_children() ) {
1559	{
1560	guard_symtab guard { *this };
1561	maybe_accept( node, &AsmExpr::result );
1562	}
1563	maybe_accept( node, &AsmExpr::constraint );
1564	maybe_accept( node, &AsmExpr::operand );
1565	}
1566
1567	VISIT_END( Expr, node );
1568	}
1569
1570	//--------------------------------------------------------------------------
1571	// ImplicitCopyCtorExpr
1572	template< typename core_t >
1573	const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
1574	VISIT_START( node );
1575
1576	if ( __visit_children() ) {
1577	{
1578	guard_symtab guard { *this };
1579	maybe_accept( node, &ImplicitCopyCtorExpr::result );
1580	}
1581	maybe_accept( node, &ImplicitCopyCtorExpr::callExpr );
1582	}
1583
1584	VISIT_END( Expr, node );
1585	}
1586
1587	//--------------------------------------------------------------------------
1588	// ConstructorExpr
1589	template< typename core_t >
1590	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
1591	VISIT_START( node );
1592
1593	if ( __visit_children() ) {
1594	{
1595	guard_symtab guard { *this };
1596	maybe_accept( node, &ConstructorExpr::result );
1597	}
1598	maybe_accept( node, &ConstructorExpr::callExpr );
1599	}
1600
1601	VISIT_END( Expr, node );
1602	}
1603
1604	//--------------------------------------------------------------------------
1605	// CompoundLiteralExpr
1606	template< typename core_t >
1607	const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
1608	VISIT_START( node );
1609
1610	if ( __visit_children() ) {
1611	{
1612	guard_symtab guard { *this };
1613	maybe_accept( node, &CompoundLiteralExpr::result );
1614	}
1615	maybe_accept( node, &CompoundLiteralExpr::init );
1616	}
1617
1618	VISIT_END( Expr, node );
1619	}
1620
1621	//--------------------------------------------------------------------------
1622	// RangeExpr
1623	template< typename core_t >
1624	const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
1625	VISIT_START( node );
1626
1627	if ( __visit_children() ) {
1628	{
1629	guard_symtab guard { *this };
1630	maybe_accept( node, &RangeExpr::result );
1631	}
1632	maybe_accept( node, &RangeExpr::low );
1633	maybe_accept( node, &RangeExpr::high );
1634	}
1635
1636	VISIT_END( Expr, node );
1637	}
1638
1639	//--------------------------------------------------------------------------
1640	// UntypedTupleExpr
1641	template< typename core_t >
1642	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
1643	VISIT_START( node );
1644
1645	if ( __visit_children() ) {
1646	{
1647	guard_symtab guard { *this };
1648	maybe_accept( node, &UntypedTupleExpr::result );
1649	}
1650	maybe_accept( node, &UntypedTupleExpr::exprs );
1651	}
1652
1653	VISIT_END( Expr, node );
1654	}
1655
1656	//--------------------------------------------------------------------------
1657	// TupleExpr
1658	template< typename core_t >
1659	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
1660	VISIT_START( node );
1661
1662	if ( __visit_children() ) {
1663	{
1664	guard_symtab guard { *this };
1665	maybe_accept( node, &TupleExpr::result );
1666	}
1667	maybe_accept( node, &TupleExpr::exprs );
1668	}
1669
1670	VISIT_END( Expr, node );
1671	}
1672
1673	//--------------------------------------------------------------------------
1674	// TupleIndexExpr
1675	template< typename core_t >
1676	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
1677	VISIT_START( node );
1678
1679	if ( __visit_children() ) {
1680	{
1681	guard_symtab guard { *this };
1682	maybe_accept( node, &TupleIndexExpr::result );
1683	}
1684	maybe_accept( node, &TupleIndexExpr::tuple );
1685	}
1686
1687	VISIT_END( Expr, node );
1688	}
1689
1690	//--------------------------------------------------------------------------
1691	// TupleAssignExpr
1692	template< typename core_t >
1693	const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
1694	VISIT_START( node );
1695
1696	if ( __visit_children() ) {
1697	{
1698	guard_symtab guard { *this };
1699	maybe_accept( node, &TupleAssignExpr::result );
1700	}
1701	maybe_accept( node, &TupleAssignExpr::stmtExpr );
1702	}
1703
1704	VISIT_END( Expr, node );
1705	}
1706
1707	//--------------------------------------------------------------------------
1708	// StmtExpr
1709	template< typename core_t >
1710	const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
1711	VISIT_START( node );
1712
1713	if ( __visit_children() ) {
1714	// don't want statements from outer CompoundStmts to be added to this StmtExpr
1715	// get the stmts that will need to be spliced in
1716	auto stmts_before = __pass::stmtsToAddBefore( core, 0);
1717	auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
1718
1719	// These may be modified by subnode but most be restored once we exit this statemnet.
1720	ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
1721	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
1722	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
1723
1724	{
1725	guard_symtab guard { *this };
1726	maybe_accept( node, &StmtExpr::result );
1727	}
1728	maybe_accept( node, &StmtExpr::stmts );
1729	maybe_accept( node, &StmtExpr::returnDecls );
1730	maybe_accept( node, &StmtExpr::dtors );
1731	}
1732
1733	VISIT_END( Expr, node );
1734	}
1735
1736	//--------------------------------------------------------------------------
1737	// UniqueExpr
1738	template< typename core_t >
1739	const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
1740	VISIT_START( node );
1741
1742	if ( __visit_children() ) {
1743	{
1744	guard_symtab guard { *this };
1745	maybe_accept( node, &UniqueExpr::result );
1746	}
1747	maybe_accept( node, &UniqueExpr::expr );
1748	}
1749
1750	VISIT_END( Expr, node );
1751	}
1752
1753	//--------------------------------------------------------------------------
1754	// UntypedInitExpr
1755	template< typename core_t >
1756	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
1757	VISIT_START( node );
1758
1759	if ( __visit_children() ) {
1760	{
1761	guard_symtab guard { *this };
1762	maybe_accept( node, &UntypedInitExpr::result );
1763	}
1764	maybe_accept( node, &UntypedInitExpr::expr );
1765	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
1766	}
1767
1768	VISIT_END( Expr, node );
1769	}
1770
1771	//--------------------------------------------------------------------------
1772	// InitExpr
1773	template< typename core_t >
1774	const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
1775	VISIT_START( node );
1776
1777	if ( __visit_children() ) {
1778	{
1779	guard_symtab guard { *this };
1780	maybe_accept( node, &InitExpr::result );
1781	}
1782	maybe_accept( node, &InitExpr::expr );
1783	maybe_accept( node, &InitExpr::designation );
1784	}
1785
1786	VISIT_END( Expr, node );
1787	}
1788
1789	//--------------------------------------------------------------------------
1790	// DeletedExpr
1791	template< typename core_t >
1792	const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
1793	VISIT_START( node );
1794
1795	if ( __visit_children() ) {
1796	{
1797	guard_symtab guard { *this };
1798	maybe_accept( node, &DeletedExpr::result );
1799	}
1800	maybe_accept( node, &DeletedExpr::expr );
1801	// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
1802	}
1803
1804	VISIT_END( Expr, node );
1805	}
1806
1807	//--------------------------------------------------------------------------
1808	// DefaultArgExpr
1809	template< typename core_t >
1810	const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
1811	VISIT_START( node );
1812
1813	if ( __visit_children() ) {
1814	{
1815	guard_symtab guard { *this };
1816	maybe_accept( node, &DefaultArgExpr::result );
1817	}
1818	maybe_accept( node, &DefaultArgExpr::expr );
1819	}
1820
1821	VISIT_END( Expr, node );
1822	}
1823
1824	//--------------------------------------------------------------------------
1825	// GenericExpr
1826	template< typename core_t >
1827	const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
1828	VISIT_START( node );
1829
1830	if ( __visit_children() ) {
1831	{
1832	guard_symtab guard { *this };
1833	maybe_accept( node, &GenericExpr::result );
1834	}
1835	maybe_accept( node, &GenericExpr::control );
1836
1837	std::vector<GenericExpr::Association> new_kids;
1838	new_kids.reserve(node->associations.size());
1839	bool mutated = false;
1840	for( const auto & assoc : node->associations ) {
1841	const Type * type = nullptr;
1842	if( assoc.type ) {
1843	guard_symtab guard { *this };
1844	type = assoc.type->accept( *this );
1845	if( type != assoc.type ) mutated = true;
1846	}
1847	const Expr * expr = nullptr;
1848	if( assoc.expr ) {
1849	expr = assoc.expr->accept( *this );
1850	if( expr != assoc.expr ) mutated = true;
1851	}
1852	new_kids.emplace_back( type, expr );
1853	}
1854
1855	if(mutated) {
1856	auto n = __pass::mutate<core_t>(node);
1857	n->associations = std::move( new_kids );
1858	node = n;
1859	}
1860	}
1861
1862	VISIT_END( Expr, node );
1863	}
1864
1865	//--------------------------------------------------------------------------
1866	// VoidType
1867	template< typename core_t >
1868	const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
1869	VISIT_START( node );
1870
1871	VISIT_END( Type, node );
1872	}
1873
1874	//--------------------------------------------------------------------------
1875	// BasicType
1876	template< typename core_t >
1877	const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
1878	VISIT_START( node );
1879
1880	VISIT_END( Type, node );
1881	}
1882
1883	//--------------------------------------------------------------------------
1884	// PointerType
1885	template< typename core_t >
1886	const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
1887	VISIT_START( node );
1888
1889	if ( __visit_children() ) {
1890	maybe_accept( node, &PointerType::dimension );
1891	maybe_accept( node, &PointerType::base );
1892	}
1893
1894	VISIT_END( Type, node );
1895	}
1896
1897	//--------------------------------------------------------------------------
1898	// ArrayType
1899	template< typename core_t >
1900	const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
1901	VISIT_START( node );
1902
1903	if ( __visit_children() ) {
1904	maybe_accept( node, &ArrayType::dimension );
1905	maybe_accept( node, &ArrayType::base );
1906	}
1907
1908	VISIT_END( Type, node );
1909	}
1910
1911	//--------------------------------------------------------------------------
1912	// ReferenceType
1913	template< typename core_t >
1914	const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
1915	VISIT_START( node );
1916
1917	if ( __visit_children() ) {
1918	maybe_accept( node, &ReferenceType::base );
1919	}
1920
1921	VISIT_END( Type, node );
1922	}
1923
1924	//--------------------------------------------------------------------------
1925	// QualifiedType
1926	template< typename core_t >
1927	const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
1928	VISIT_START( node );
1929
1930	if ( __visit_children() ) {
1931	maybe_accept( node, &QualifiedType::parent );
1932	maybe_accept( node, &QualifiedType::child );
1933	}
1934
1935	VISIT_END( Type, node );
1936	}
1937
1938	//--------------------------------------------------------------------------
1939	// FunctionType
1940	template< typename core_t >
1941	const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
1942	VISIT_START( node );
1943
1944	if ( __visit_children() ) {
1945	// guard_forall_subs forall_guard { *this, node };
1946	// mutate_forall( node );
1947	maybe_accept( node, &FunctionType::assertions );
1948	maybe_accept( node, &FunctionType::returns );
1949	maybe_accept( node, &FunctionType::params );
1950	}
1951
1952	VISIT_END( Type, node );
1953	}
1954
1955	//--------------------------------------------------------------------------
1956	// StructInstType
1957	template< typename core_t >
1958	const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
1959	VISIT_START( node );
1960
1961	__pass::symtab::addStruct( core, 0, node->name );
1962
1963	if ( __visit_children() ) {
1964	guard_symtab guard { *this };
1965	maybe_accept( node, &StructInstType::params );
1966	}
1967
1968	VISIT_END( Type, node );
1969	}
1970
1971	//--------------------------------------------------------------------------
1972	// UnionInstType
1973	template< typename core_t >
1974	const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
1975	VISIT_START( node );
1976
1977	__pass::symtab::addUnion( core, 0, node->name );
1978
1979	if ( __visit_children() ) {
1980	guard_symtab guard { *this };
1981	maybe_accept( node, &UnionInstType::params );
1982	}
1983
1984	VISIT_END( Type, node );
1985	}
1986
1987	//--------------------------------------------------------------------------
1988	// EnumInstType
1989	template< typename core_t >
1990	const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
1991	VISIT_START( node );
1992
1993	if ( __visit_children() ) {
1994	maybe_accept( node, &EnumInstType::params );
1995	}
1996
1997	VISIT_END( Type, node );
1998	}
1999
2000	//--------------------------------------------------------------------------
2001	// TraitInstType
2002	template< typename core_t >
2003	const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
2004	VISIT_START( node );
2005
2006	if ( __visit_children() ) {
2007	maybe_accept( node, &TraitInstType::params );
2008	}
2009
2010	VISIT_END( Type, node );
2011	}
2012
2013	//--------------------------------------------------------------------------
2014	// TypeInstType
2015	template< typename core_t >
2016	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
2017	VISIT_START( node );
2018
2019	if ( __visit_children() ) {
2020	{
2021	maybe_accept( node, &TypeInstType::params );
2022	}
2023	// ensure that base re-bound if doing substitution
2024	__pass::forall::replace( core, 0, node );
2025	}
2026
2027	VISIT_END( Type, node );
2028	}
2029
2030	//--------------------------------------------------------------------------
2031	// TupleType
2032	template< typename core_t >
2033	const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
2034	VISIT_START( node );
2035
2036	if ( __visit_children() ) {
2037	maybe_accept( node, &TupleType::types );
2038	maybe_accept( node, &TupleType::members );
2039	}
2040
2041	VISIT_END( Type, node );
2042	}
2043
2044	//--------------------------------------------------------------------------
2045	// TypeofType
2046	template< typename core_t >
2047	const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
2048	VISIT_START( node );
2049
2050	if ( __visit_children() ) {
2051	maybe_accept( node, &TypeofType::expr );
2052	}
2053
2054	VISIT_END( Type, node );
2055	}
2056
2057	//--------------------------------------------------------------------------
2058	// VTableType
2059	template< typename core_t >
2060	const ast::Type * ast::Pass< core_t >::visit( const ast::VTableType * node ) {
2061	VISIT_START( node );
2062
2063	if ( __visit_children() ) {
2064	maybe_accept( node, &VTableType::base );
2065	}
2066
2067	VISIT_END( Type, node );
2068	}
2069
2070	//--------------------------------------------------------------------------
2071	// VarArgsType
2072	template< typename core_t >
2073	const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
2074	VISIT_START( node );
2075
2076	VISIT_END( Type, node );
2077	}
2078
2079	//--------------------------------------------------------------------------
2080	// ZeroType
2081	template< typename core_t >
2082	const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
2083	VISIT_START( node );
2084
2085	VISIT_END( Type, node );
2086	}
2087
2088	//--------------------------------------------------------------------------
2089	// OneType
2090	template< typename core_t >
2091	const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
2092	VISIT_START( node );
2093
2094	VISIT_END( Type, node );
2095	}
2096
2097	//--------------------------------------------------------------------------
2098	// GlobalScopeType
2099	template< typename core_t >
2100	const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
2101	VISIT_START( node );
2102
2103	VISIT_END( Type, node );
2104	}
2105
2106
2107	//--------------------------------------------------------------------------
2108	// Designation
2109	template< typename core_t >
2110	const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
2111	VISIT_START( node );
2112
2113	if ( __visit_children() ) {
2114	maybe_accept( node, &Designation::designators );
2115	}
2116
2117	VISIT_END( Designation, node );
2118	}
2119
2120	//--------------------------------------------------------------------------
2121	// SingleInit
2122	template< typename core_t >
2123	const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
2124	VISIT_START( node );
2125
2126	if ( __visit_children() ) {
2127	maybe_accept_top( node, &SingleInit::value );
2128	}
2129
2130	VISIT_END( Init, node );
2131	}
2132
2133	//--------------------------------------------------------------------------
2134	// ListInit
2135	template< typename core_t >
2136	const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
2137	VISIT_START( node );
2138
2139	if ( __visit_children() ) {
2140	maybe_accept( node, &ListInit::designations );
2141	maybe_accept( node, &ListInit::initializers );
2142	}
2143
2144	VISIT_END( Init, node );
2145	}
2146
2147	//--------------------------------------------------------------------------
2148	// ConstructorInit
2149	template< typename core_t >
2150	const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
2151	VISIT_START( node );
2152
2153	if ( __visit_children() ) {
2154	maybe_accept( node, &ConstructorInit::ctor );
2155	maybe_accept( node, &ConstructorInit::dtor );
2156	maybe_accept( node, &ConstructorInit::init );
2157	}
2158
2159	VISIT_END( Init, node );
2160	}
2161
2162	//--------------------------------------------------------------------------
2163	// Attribute
2164	template< typename core_t >
2165	const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) {
2166	VISIT_START( node );
2167
2168	if ( __visit_children() ) {
2169	maybe_accept( node, &Attribute::params );
2170	}
2171
2172	VISIT_END( Attribute, node );
2173	}
2174
2175	//--------------------------------------------------------------------------
2176	// TypeSubstitution
2177	template< typename core_t >
2178	const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
2179	VISIT_START( node );
2180
2181	if ( __visit_children() ) {
2182	bool mutated = false;
2183	ast::TypeSubstitution::TypeMap new_map;
2184	for ( const auto & p : node->typeMap ) {
2185	guard_symtab guard { *this };
2186	auto new_node = p.second->accept( *this );
2187	if (new_node != p.second) mutated = true;
2188	new_map.insert({ p.first, new_node });
2189	}
2190	if (mutated) {
2191	auto new_node = __pass::mutate<core_t>( node );
2192	new_node->typeMap.swap( new_map );
2193	node = new_node;
2194	}
2195	}
2196
2197	VISIT_END( TypeSubstitution, node );
2198	}
2199
2200	#undef VISIT_START
2201	#undef VISIT_END

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

Download in other formats: