Context Navigation

source: src/AST/Pass.impl.hpp @ 5a1ae14

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

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

Download in other formats: