Context Navigation

source: src/AST/Pass.impl.hpp @ 07997cd

ADTast-experimentalpthread-emulationqualifiedEnum

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

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

Download in other formats: