Context Navigation

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

ADTast-experimentalpthread-emulation

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

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

Download in other formats: