Context Navigation

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

ADTast-experimentalpthread-emulationqualifiedEnum

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

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

Download in other formats: