Context Navigation

source: src/AST/Pass.impl.hpp @ 1dd5fd1

Last change on this file since 1dd5fd1 was 0c327ce, checked in by JiadaL <j82liang@…>, 4 days ago
Add bound check to Serial function: now compiler generates the unchecked functions in ImplementEnumFunc?, and enum.hfa implements the bound check on top. Todo: Wrapped the checked version into a trait; 2. countof is now works on any type that implement Countof(). Because Countof() is implemented in enum.hfa for all CfaEnum?, we can call countof on { T \| CfaEnum?(T) }
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/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 guard0 = __pass::make_location_guard( core, node, 0 ); \
30	/* back-up the visit children */ \
31	__attribute__((unused)) auto guard1 = __pass::make_visit_children_guard( core, 0 ); \
32	/* setup the scope for passes that want to run code at exit */ \
33	__attribute__((unused)) auto guard2 = __pass::make_value_guard( 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	template< typename core_t >
114	template< typename node_t >
115	auto ast::Pass< core_t >::call_accept( const node_t * node ) ->
116	ast::Pass< core_t >::call_accept_result_t<node_t> {
117	__pedantic_pass_assert( __visit_children() );
118	__pedantic_pass_assert( node );
119
120	auto nval = node->accept( *this );
121	return { nval != node, nval };
122	}
123
124	template< typename core_t >
125	ast::__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
126	__pedantic_pass_assert( __visit_children() );
127	__pedantic_pass_assert( expr );
128
129	const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
130	if ( typeSubs_ptr && expr->env ) {
131	*typeSubs_ptr = expr->env;
132	}
133
134	auto nval = expr->accept( *this );
135	return { nval != expr, nval };
136	}
137
138	template< typename core_t >
139	ast::__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
140	__pedantic_pass_assert( __visit_children() );
141	__pedantic_pass_assert( stmt );
142
143	// add a few useful symbols to the scope
144	using __pass::empty;
145
146	// get the stmts/decls that will need to be spliced in
147	auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
148	auto stmts_after = __pass::stmtsToAddAfter ( core, 0 );
149	auto decls_before = __pass::declsToAddBefore( core, 0 );
150	auto decls_after = __pass::declsToAddAfter ( core, 0 );
151
152	// These may be modified by subnode but most be restored once we exit this statemnet.
153	ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::typeSubs( core, 0 ) );
154	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
155	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
156	ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
157	ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
158
159	// Now is the time to actually visit the node
160	const ast::Stmt * nstmt = stmt->accept( *this );
161
162	// If the pass doesn't want to add anything then we are done
163	if ( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
164	return { nstmt != stmt, nstmt };
165	}
166
167	// Make sure that it is either adding statements or declartions but not both
168	// this is because otherwise the order would be awkward to predict
169	assert(( empty( stmts_before ) && empty( stmts_after ))
170	\|\| ( empty( decls_before ) && empty( decls_after )) );
171
172	// Create a new Compound Statement to hold the new decls/stmts
173	ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
174
175	// Take all the declarations that go before
176	__pass::take_all( std::back_inserter( compound->kids ), decls_before );
177	__pass::take_all( std::back_inserter( compound->kids ), stmts_before );
178
179	// Insert the original declaration
180	compound->kids.emplace_back( nstmt );
181
182	// Insert all the declarations that go before
183	__pass::take_all( std::back_inserter( compound->kids ), decls_after );
184	__pass::take_all( std::back_inserter( compound->kids ), stmts_after );
185
186	return { true, compound };
187	}
188
189	template< typename core_t >
190	template< template <class...> class container_t >
191	ast::__pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
192	__pedantic_pass_assert( __visit_children() );
193	__pedantic_pass_assert( !statements.empty() );
194
195	// We are going to aggregate errors for all these statements
196	SemanticErrorException errors;
197
198	// add a few useful symbols to the scope
199	using __pass::empty;
200
201	// get the stmts/decls that will need to be spliced in
202	auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
203	auto stmts_after = __pass::stmtsToAddAfter ( core, 0 );
204	auto decls_before = __pass::declsToAddBefore( core, 0 );
205	auto decls_after = __pass::declsToAddAfter ( core, 0 );
206
207	// These may be modified by subnode but most be restored once we exit this statemnet.
208	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
209	ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
210	ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
211	ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
212
213	// update pass statitistics
214	pass_visitor_stats.depth++;
215	pass_visitor_stats.max->push(pass_visitor_stats.depth);
216	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
217
218	__pass::resultNstmt<container_t> new_kids;
219	for ( auto value : enumerate( statements ) ) {
220	try {
221	size_t i = value.idx;
222	const Stmt * stmt = value.val;
223	__pedantic_pass_assert( stmt );
224	const ast::Stmt * new_stmt = stmt->accept( *this );
225	assert( new_stmt );
226
227	// Make sure that it is either adding statements or declartions but not both
228	// this is because otherwise the order would be awkward to predict
229	assert(( empty( stmts_before ) && empty( stmts_after ))
230	\|\| ( empty( decls_before ) && empty( decls_after )) );
231
232	// Take all the statements which should have gone after, N/A for first iteration
233	new_kids.take_all( decls_before );
234	new_kids.take_all( stmts_before );
235
236	// Now add the statement if there is one
237	if ( new_stmt != stmt ) {
238	new_kids.differs = true;
239	new_kids.values.emplace_back( new_stmt );
240	} else {
241	new_kids.values.emplace_back( i );
242	}
243
244	// Take all the declarations that go before
245	new_kids.take_all( decls_after );
246	new_kids.take_all( stmts_after );
247	} catch ( SemanticErrorException &e ) {
248	errors.append( e );
249	}
250	}
251	pass_visitor_stats.depth--;
252	if ( !errors.isEmpty() ) { throw errors; }
253
254	return new_kids;
255	}
256
257	template< typename core_t >
258	template< template <class...> class container_t, typename node_t >
259	ast::__pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
260	__pedantic_pass_assert( __visit_children() );
261	__pedantic_pass_assert( !container.empty() );
262
263	// Collect errors from processing all these nodes.
264	SemanticErrorException errors;
265
266	pass_visitor_stats.depth++;
267	pass_visitor_stats.max->push(pass_visitor_stats.depth);
268	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
269
270	bool mutated = false;
271	container_t<ptr<node_t>> new_kids;
272	for ( const node_t * node : container ) {
273	try {
274	__pedantic_pass_assert( node );
275	const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
276	if ( new_stmt != node ) {
277	mutated = true;
278	new_kids.emplace_back( new_stmt );
279	} else {
280	new_kids.emplace_back( nullptr );
281	}
282	} catch ( SemanticErrorException &e ) {
283	errors.append( e );
284	}
285	}
286
287	__pedantic_pass_assert( new_kids.size() == container.size() );
288	pass_visitor_stats.depth--;
289	if ( !errors.isEmpty() ) { throw errors; }
290
291	return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
292	}
293
294	template< typename core_t >
295	template<typename node_t, typename super_t, typename field_t>
296	void ast::Pass< core_t >::maybe_accept(
297	const node_t * & parent,
298	field_t super_t::*field
299	) {
300	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
301
302	if ( __pass::skip( parent->*field ) ) return;
303	const auto & old_val = __pass::get(parent->*field, 0);
304
305	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
306
307	auto result = call_accept( old_val );
308	if ( result.differs ) {
309	auto new_parent = __pass::mutate<core_t>(parent);
310	result.apply( new_parent, field );
311	parent = new_parent;
312	}
313	}
314
315	template< typename core_t >
316	template<typename node_t, typename super_t, typename field_t>
317	void ast::Pass< core_t >::maybe_accept_top(
318	const node_t * & parent,
319	field_t super_t::*field
320	) {
321	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
322
323	if ( __pass::skip( parent->*field ) ) return;
324	const auto & old_val = __pass::get(parent->*field, 0);
325
326	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
327
328	auto result = call_accept_top( old_val );
329	if ( result.differs ) {
330	auto new_parent = __pass::mutate<core_t>(parent);
331	result.apply( new_parent, field );
332	parent = new_parent;
333	}
334	}
335
336	template< typename core_t >
337	template<typename node_t, typename super_t, typename field_t>
338	void ast::Pass< core_t >::maybe_accept_as_compound(
339	const node_t * & parent,
340	field_t super_t::*child
341	) {
342	static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
343
344	if ( __pass::skip( parent->*child ) ) return;
345	const auto & old_val = __pass::get(parent->*child, 0);
346
347	static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
348
349	auto result = call_accept_as_compound( old_val );
350	if ( result.differs ) {
351	auto new_parent = __pass::mutate<core_t>(parent);
352	result.apply( new_parent, child );
353	parent = new_parent;
354	}
355	}
356
357	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
358	//========================================================================================================================================================================
359	//========================================================================================================================================================================
360	//========================================================================================================================================================================
361	//========================================================================================================================================================================
362	//========================================================================================================================================================================
363	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
364
365	template< typename core_t >
366	inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
367	// We are going to aggregate errors for all these statements
368	SemanticErrorException errors;
369
370	// add a few useful symbols to the scope
371	using __pass::empty;
372
373	// get the stmts/decls that will need to be spliced in
374	auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
375	auto decls_after = __pass::declsToAddAfter ( visitor.core, 0);
376
377	// update pass statitistics
378	pass_visitor_stats.depth++;
379	pass_visitor_stats.max->push(pass_visitor_stats.depth);
380	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
381
382	for ( std::list< ast::ptr<ast::Decl> >::iterator i = decls.begin(); ; ++i ) {
383	// splice in new declarations after previous decl
384	if ( !empty( decls_after ) ) { decls.splice( i, *decls_after ); }
385
386	if ( i == decls.end() ) break;
387
388	try {
389	// run visitor on declaration
390	ast::ptr<ast::Decl> & node = *i;
391	assert( node );
392	node = node->accept( visitor );
393	}
394	catch( SemanticErrorException &e ) {
395	if (__pass::on_error (visitor.core, *i, 0))
396	errors.append( e );
397	}
398
399	// splice in new declarations before current decl
400	if ( !empty( decls_before ) ) { decls.splice( i, *decls_before ); }
401	}
402	pass_visitor_stats.depth--;
403	if ( !errors.isEmpty() ) { throw errors; }
404	}
405
406	template< typename core_t >
407	inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
408	if ( auto ptr = __pass::translationUnit( visitor.core, 0 ) ) {
409	ValueGuard<const TranslationUnit > guard( ptr );
410	*ptr = &unit;
411	return ast::accept_all( unit.decls, visitor );
412	} else {
413	return ast::accept_all( unit.decls, visitor );
414	}
415	}
416
417	// A NOTE ON THE ORDER OF TRAVERSAL
418	//
419	// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is
420	// no such thing as a recursive type or typedef.
421	//
422	// typedef struct { T *x; } T; // never allowed
423	//
424	// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
425	// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
426	// declaration).
427	//
428	// struct T { struct T *x; }; // allowed
429	//
430	// It is important to add the complete type to the symbol table after the members/base has been traversed, since that
431	// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
432	// queried later in this pass.
433
434	//--------------------------------------------------------------------------
435	// ObjectDecl
436	template< typename core_t >
437	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
438	VISIT_START( node );
439
440	if ( __visit_children() ) {
441	{
442	guard_symtab guard { *this };
443	maybe_accept( node, &ObjectDecl::type );
444	}
445	maybe_accept( node, &ObjectDecl::init );
446	maybe_accept( node, &ObjectDecl::bitfieldWidth );
447	maybe_accept( node, &ObjectDecl::attributes );
448	}
449
450	__pass::symtab::addId( core, 0, node );
451
452	VISIT_END( DeclWithType, node );
453	}
454
455	//--------------------------------------------------------------------------
456	// FunctionDecl
457	template< typename core_t >
458	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
459	VISIT_START( node );
460
461	__pass::symtab::addId( core, 0, node );
462
463	if ( __visit_children() ) {
464	maybe_accept( node, &FunctionDecl::withExprs );
465	}
466	{
467	// with clause introduces a level of scope (for the with expression members).
468	// with clause exprs are added to the symbol table before parameters so that parameters
469	// shadow with exprs and not the other way around.
470	guard_symtab guard { *this };
471	__pass::symtab::addWith( core, 0, node->withExprs, node );
472	{
473	guard_symtab guard { *this };
474	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
475	// This is a C name and so has C linkage.
476	static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
477	CodeLocation{}, "__func__",
478	new ast::ArrayType{
479	new ast::BasicType{ ast::BasicKind::Char, ast::CV::Const },
480	nullptr, VariableLen, DynamicDim
481	},
482	nullptr,
483	ast::Storage::Classes(),
484	ast::Linkage::C,
485	} };
486	__pass::symtab::addId( core, 0, func );
487	if ( __visit_children() ) {
488	maybe_accept( node, &FunctionDecl::type_params );
489	maybe_accept( node, &FunctionDecl::assertions );
490	maybe_accept( node, &FunctionDecl::params );
491	maybe_accept( node, &FunctionDecl::returns );
492	maybe_accept( node, &FunctionDecl::type );
493	maybe_accept( node, &FunctionDecl::attributes );
494	// First remember that we are now within a function.
495	ValueGuard< bool > oldInFunction( inFunction );
496	inFunction = true;
497	// The function body needs to have the same scope as parameters.
498	// A CompoundStmt will not enter a new scope if atFunctionTop is true.
499	ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
500	atFunctionTop = true;
501	maybe_accept( node, &FunctionDecl::stmts );
502	}
503	}
504	}
505
506	VISIT_END( DeclWithType, node );
507	}
508
509	//--------------------------------------------------------------------------
510	// StructDecl
511	template< typename core_t >
512	const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
513	VISIT_START( node );
514
515	// make up a forward declaration and add it before processing the members
516	// needs to be on the heap because addStruct saves the pointer
517	__pass::symtab::addStructFwd( core, 0, node );
518
519	if ( __visit_children() ) {
520	guard_symtab guard { * this };
521	maybe_accept( node, &StructDecl::params );
522	maybe_accept( node, &StructDecl::members );
523	maybe_accept( node, &StructDecl::attributes );
524	}
525
526	// this addition replaces the forward declaration
527	__pass::symtab::addStruct( core, 0, node );
528
529	VISIT_END( Decl, node );
530	}
531
532	//--------------------------------------------------------------------------
533	// UnionDecl
534	template< typename core_t >
535	const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
536	VISIT_START( node );
537
538	// make up a forward declaration and add it before processing the members
539	__pass::symtab::addUnionFwd( core, 0, node );
540
541	if ( __visit_children() ) {
542	guard_symtab guard { * this };
543	maybe_accept( node, &UnionDecl::params );
544	maybe_accept( node, &UnionDecl::members );
545	maybe_accept( node, &UnionDecl::attributes );
546	}
547
548	__pass::symtab::addUnion( core, 0, node );
549
550	VISIT_END( Decl, node );
551	}
552
553	//--------------------------------------------------------------------------
554	// EnumDecl
555	template< typename core_t >
556	const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
557	VISIT_START( node );
558
559	__pass::symtab::addEnum( core, 0, node );
560
561	if ( __visit_children() ) {
562	maybe_accept( node, &EnumDecl::base );
563	maybe_accept( node, &EnumDecl::params );
564	maybe_accept( node, &EnumDecl::members );
565	maybe_accept( node, &EnumDecl::attributes );
566	maybe_accept( node, &EnumDecl::inlinedDecl );
567	}
568
569	VISIT_END( Decl, node );
570	}
571
572	//--------------------------------------------------------------------------
573	// TraitDecl
574	template< typename core_t >
575	const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
576	VISIT_START( node );
577
578	if ( __visit_children() ) {
579	guard_symtab guard { *this };
580	maybe_accept( node, &TraitDecl::params );
581	maybe_accept( node, &TraitDecl::members );
582	maybe_accept( node, &TraitDecl::attributes );
583	}
584
585	__pass::symtab::addTrait( core, 0, node );
586
587	VISIT_END( Decl, node );
588	}
589
590	//--------------------------------------------------------------------------
591	// TypeDecl
592	template< typename core_t >
593	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
594	VISIT_START( node );
595
596	if ( __visit_children() ) {
597	guard_symtab guard { *this };
598	maybe_accept( node, &TypeDecl::base );
599	}
600
601	// see A NOTE ON THE ORDER OF TRAVERSAL, above
602	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
603	// and may depend on the type itself
604	__pass::symtab::addType( core, 0, node );
605
606	if ( __visit_children() ) {
607	maybe_accept( node, &TypeDecl::assertions );
608
609	{
610	guard_symtab guard { *this };
611	maybe_accept( node, &TypeDecl::init );
612	}
613	}
614
615	VISIT_END( Decl, node );
616	}
617
618	//--------------------------------------------------------------------------
619	// TypedefDecl
620	template< typename core_t >
621	const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
622	VISIT_START( node );
623
624	if ( __visit_children() ) {
625	guard_symtab guard { *this };
626	maybe_accept( node, &TypedefDecl::base );
627	}
628
629	__pass::symtab::addType( core, 0, node );
630
631	if ( __visit_children() ) {
632	maybe_accept( node, &TypedefDecl::assertions );
633	}
634
635	VISIT_END( Decl, node );
636	}
637
638	//--------------------------------------------------------------------------
639	// AsmDecl
640	template< typename core_t >
641	const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
642	VISIT_START( node );
643
644	if ( __visit_children() ) {
645	maybe_accept( node, &AsmDecl::stmt );
646	}
647
648	VISIT_END( AsmDecl, node );
649	}
650
651	//--------------------------------------------------------------------------
652	// DirectiveDecl
653	template< typename core_t >
654	const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
655	VISIT_START( node );
656
657	if ( __visit_children() ) {
658	maybe_accept( node, &DirectiveDecl::stmt );
659	}
660
661	VISIT_END( DirectiveDecl, node );
662	}
663
664	//--------------------------------------------------------------------------
665	// StaticAssertDecl
666	template< typename core_t >
667	const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
668	VISIT_START( node );
669
670	if ( __visit_children() ) {
671	maybe_accept_top( node, &StaticAssertDecl::cond );
672	maybe_accept( node, &StaticAssertDecl::msg );
673	}
674
675	VISIT_END( StaticAssertDecl, node );
676	}
677
678	//--------------------------------------------------------------------------
679	// InlineMemberDecl
680	template< typename core_t >
681	const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
682	VISIT_START( node );
683
684	if ( __visit_children() ) {
685	{
686	guard_symtab guard { *this };
687	maybe_accept( node, &InlineMemberDecl::type );
688	}
689	}
690
691	VISIT_END( DeclWithType, node );
692	}
693
694	//--------------------------------------------------------------------------
695	// CompoundStmt
696	template< typename core_t >
697	const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
698	VISIT_START( node );
699
700	if ( __visit_children() ) {
701	// Do not enter (or leave) a new symbol table scope if atFunctionTop.
702	// But always enter (and leave) a new general scope.
703	if ( atFunctionTop ) {
704	ValueGuard< bool > guard1( atFunctionTop );
705	atFunctionTop = false;
706	guard_scope guard2( *this );
707	maybe_accept( node, &CompoundStmt::kids );
708	} else {
709	guard_symtab guard1( *this );
710	guard_scope guard2( *this );
711	maybe_accept( node, &CompoundStmt::kids );
712	}
713	}
714
715	VISIT_END( CompoundStmt, node );
716	}
717
718	//--------------------------------------------------------------------------
719	// ExprStmt
720	template< typename core_t >
721	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
722	VISIT_START( node );
723
724	if ( __visit_children() ) {
725	maybe_accept_top( node, &ExprStmt::expr );
726	}
727
728	VISIT_END( Stmt, node );
729	}
730
731	//--------------------------------------------------------------------------
732	// AsmStmt
733	template< typename core_t >
734	const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
735	VISIT_START( node )
736
737	if ( __visit_children() ) {
738	maybe_accept( node, &AsmStmt::instruction );
739	maybe_accept( node, &AsmStmt::output );
740	maybe_accept( node, &AsmStmt::input );
741	maybe_accept( node, &AsmStmt::clobber );
742	}
743
744	VISIT_END( Stmt, node );
745	}
746
747	//--------------------------------------------------------------------------
748	// DirectiveStmt
749	template< typename core_t >
750	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
751	VISIT_START( node )
752
753	VISIT_END( Stmt, node );
754	}
755
756	//--------------------------------------------------------------------------
757	// IfStmt
758	template< typename core_t >
759	const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
760	VISIT_START( node );
761
762	if ( __visit_children() ) {
763	// if statements introduce a level of scope (for the initialization)
764	guard_symtab guard { *this };
765	maybe_accept( node, &IfStmt::inits );
766	maybe_accept_top( node, &IfStmt::cond );
767	maybe_accept_as_compound( node, &IfStmt::then );
768	maybe_accept_as_compound( node, &IfStmt::else_ );
769	}
770
771	VISIT_END( Stmt, node );
772	}
773
774	//--------------------------------------------------------------------------
775	// WhileDoStmt
776	template< typename core_t >
777	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
778	VISIT_START( node );
779
780	if ( __visit_children() ) {
781	// while statements introduce a level of scope (for the initialization)
782	guard_symtab guard { *this };
783	maybe_accept( node, &WhileDoStmt::inits );
784	maybe_accept_top( node, &WhileDoStmt::cond );
785	maybe_accept_as_compound( node, &WhileDoStmt::body );
786	maybe_accept_as_compound( node, &WhileDoStmt::else_ );
787	}
788
789	VISIT_END( Stmt, node );
790	}
791
792	//--------------------------------------------------------------------------
793	// ForStmt
794	template< typename core_t >
795	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
796	VISIT_START( node );
797
798	if ( __visit_children() ) {
799	// for statements introduce a level of scope (for the initialization)
800	guard_symtab guard { *this };
801	// xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
802	maybe_accept( node, &ForStmt::inits );
803	maybe_accept_top( node, &ForStmt::cond );
804	maybe_accept_top( node, &ForStmt::inc );
805	maybe_accept_top( node, &ForStmt::range_over );
806	maybe_accept_as_compound( node, &ForStmt::body );
807	maybe_accept_as_compound( node, &ForStmt::else_ );
808	}
809
810	VISIT_END( Stmt, node );
811	}
812
813	//--------------------------------------------------------------------------
814	// SwitchStmt
815	template< typename core_t >
816	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
817	VISIT_START( node );
818
819	if ( __visit_children() ) {
820	maybe_accept_top( node, &SwitchStmt::cond );
821	maybe_accept( node, &SwitchStmt::cases );
822	}
823
824	VISIT_END( Stmt, node );
825	}
826
827	//--------------------------------------------------------------------------
828	// CaseClause
829	template< typename core_t >
830	const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
831	VISIT_START( node );
832
833	if ( __visit_children() ) {
834	maybe_accept_top( node, &CaseClause::cond );
835	maybe_accept( node, &CaseClause::stmts );
836	}
837
838	VISIT_END( CaseClause, node );
839	}
840
841	//--------------------------------------------------------------------------
842	// BranchStmt
843	template< typename core_t >
844	const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
845	VISIT_START( node );
846	VISIT_END( Stmt, node );
847	}
848
849	//--------------------------------------------------------------------------
850	// ReturnStmt
851	template< typename core_t >
852	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
853	VISIT_START( node );
854
855	if ( __visit_children() ) {
856	maybe_accept_top( node, &ReturnStmt::expr );
857	}
858
859	VISIT_END( Stmt, node );
860	}
861
862	//--------------------------------------------------------------------------
863	// ThrowStmt
864	template< typename core_t >
865	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
866	VISIT_START( node );
867
868	if ( __visit_children() ) {
869	maybe_accept( node, &ThrowStmt::expr );
870	maybe_accept( node, &ThrowStmt::target );
871	}
872
873	VISIT_END( Stmt, node );
874	}
875
876	//--------------------------------------------------------------------------
877	// TryStmt
878	template< typename core_t >
879	const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
880	VISIT_START( node );
881
882	if ( __visit_children() ) {
883	maybe_accept( node, &TryStmt::body );
884	maybe_accept( node, &TryStmt::handlers );
885	maybe_accept( node, &TryStmt::finally );
886	}
887
888	VISIT_END( Stmt, node );
889	}
890
891	//--------------------------------------------------------------------------
892	// CatchClause
893	template< typename core_t >
894	const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
895	VISIT_START( node );
896
897	if ( __visit_children() ) {
898	// catch statements introduce a level of scope (for the caught exception)
899	guard_symtab guard { *this };
900	maybe_accept( node, &CatchClause::decl );
901	maybe_accept_top( node, &CatchClause::cond );
902	maybe_accept_as_compound( node, &CatchClause::body );
903	}
904
905	VISIT_END( CatchClause, node );
906	}
907
908	//--------------------------------------------------------------------------
909	// FinallyClause
910	template< typename core_t >
911	const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
912	VISIT_START( node );
913
914	if ( __visit_children() ) {
915	maybe_accept( node, &FinallyClause::body );
916	}
917
918	VISIT_END( FinallyClause, node );
919	}
920
921	//--------------------------------------------------------------------------
922	// FinallyStmt
923	template< typename core_t >
924	const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
925	VISIT_START( node );
926
927	if ( __visit_children() ) {
928	maybe_accept( node, &SuspendStmt::then );
929	}
930
931	VISIT_END( Stmt, node );
932	}
933
934	//--------------------------------------------------------------------------
935	// WhenClause
936	template< typename core_t >
937	const ast::WhenClause * ast::Pass< core_t >::visit( const ast::WhenClause * node ) {
938	VISIT_START( node );
939
940	if ( __visit_children() ) {
941	maybe_accept( node, &WhenClause::target );
942	maybe_accept( node, &WhenClause::stmt );
943	maybe_accept( node, &WhenClause::when_cond );
944	}
945
946	VISIT_END( WhenClause, node );
947	}
948
949	//--------------------------------------------------------------------------
950	// WaitForStmt
951	template< typename core_t >
952	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
953	VISIT_START( node );
954
955	if ( __visit_children() ) {
956	maybe_accept( node, &WaitForStmt::clauses );
957	maybe_accept( node, &WaitForStmt::timeout_time );
958	maybe_accept( node, &WaitForStmt::timeout_stmt );
959	maybe_accept( node, &WaitForStmt::timeout_cond );
960	maybe_accept( node, &WaitForStmt::else_stmt );
961	maybe_accept( node, &WaitForStmt::else_cond );
962	}
963
964	VISIT_END( Stmt, node );
965	}
966
967	//--------------------------------------------------------------------------
968	// WaitForClause
969	template< typename core_t >
970	const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
971	VISIT_START( node );
972
973	if ( __visit_children() ) {
974	maybe_accept( node, &WaitForClause::target );
975	maybe_accept( node, &WaitForClause::target_args );
976	maybe_accept( node, &WaitForClause::stmt );
977	maybe_accept( node, &WaitForClause::when_cond );
978	}
979
980	VISIT_END( WaitForClause, node );
981	}
982
983	//--------------------------------------------------------------------------
984	// WaitUntilStmt
985	template< typename core_t >
986	const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitUntilStmt * node ) {
987	VISIT_START( node );
988
989	if ( __visit_children() ) {
990	maybe_accept( node, &WaitUntilStmt::clauses );
991	maybe_accept( node, &WaitUntilStmt::timeout_time );
992	maybe_accept( node, &WaitUntilStmt::timeout_stmt );
993	maybe_accept( node, &WaitUntilStmt::timeout_cond );
994	maybe_accept( node, &WaitUntilStmt::else_stmt );
995	maybe_accept( node, &WaitUntilStmt::else_cond );
996	}
997
998	VISIT_END( Stmt, node );
999	}
1000
1001	//--------------------------------------------------------------------------
1002	// WithStmt
1003	template< typename core_t >
1004	const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
1005	VISIT_START( node );
1006
1007	if ( __visit_children() ) {
1008	maybe_accept( node, &WithStmt::exprs );
1009	{
1010	// catch statements introduce a level of scope (for the caught exception)
1011	guard_symtab guard { *this };
1012	__pass::symtab::addWith( core, 0, node->exprs, node );
1013	maybe_accept( node, &WithStmt::stmt );
1014	}
1015	}
1016
1017	VISIT_END( Stmt, node );
1018	}
1019
1020	//--------------------------------------------------------------------------
1021	// NullStmt
1022	template< typename core_t >
1023	const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
1024	VISIT_START( node );
1025	VISIT_END( NullStmt, node );
1026	}
1027
1028	//--------------------------------------------------------------------------
1029	// DeclStmt
1030	template< typename core_t >
1031	const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
1032	VISIT_START( node );
1033
1034	if ( __visit_children() ) {
1035	maybe_accept( node, &DeclStmt::decl );
1036	}
1037
1038	VISIT_END( Stmt, node );
1039	}
1040
1041	//--------------------------------------------------------------------------
1042	// ImplicitCtorDtorStmt
1043	template< typename core_t >
1044	const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
1045	VISIT_START( node );
1046
1047	// For now this isn't visited, it is unclear if this causes problem
1048	// if all tests are known to pass, remove this code
1049	if ( __visit_children() ) {
1050	maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
1051	}
1052
1053	VISIT_END( Stmt, node );
1054	}
1055
1056	//--------------------------------------------------------------------------
1057	// MutexStmt
1058	template< typename core_t >
1059	const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
1060	VISIT_START( node );
1061
1062	if ( __visit_children() ) {
1063	// mutex statements introduce a level of scope (for the initialization)
1064	guard_symtab guard { *this };
1065	maybe_accept( node, &MutexStmt::stmt );
1066	maybe_accept( node, &MutexStmt::mutexObjs );
1067	}
1068
1069	VISIT_END( Stmt, node );
1070	}
1071
1072	//--------------------------------------------------------------------------
1073	// CorunStmt
1074	template< typename core_t >
1075	const ast::Stmt * ast::Pass< core_t >::visit( const ast::CorunStmt * node ) {
1076	VISIT_START( node );
1077
1078	if ( __visit_children() ) {
1079	maybe_accept( node, &CorunStmt::stmt );
1080	}
1081
1082	VISIT_END( Stmt, node );
1083	}
1084
1085	//--------------------------------------------------------------------------
1086	// CoforStmt
1087	template< typename core_t >
1088	const ast::Stmt * ast::Pass< core_t >::visit( const ast::CoforStmt * node ) {
1089	VISIT_START( node );
1090
1091	if ( __visit_children() ) {
1092	// for statements introduce a level of scope (for the initialization)
1093	guard_symtab guard { *this };
1094	maybe_accept( node, &CoforStmt::inits );
1095	maybe_accept_top( node, &CoforStmt::cond );
1096	maybe_accept_top( node, &CoforStmt::inc );
1097	maybe_accept_as_compound( node, &CoforStmt::body );
1098	}
1099
1100	VISIT_END( Stmt, node );
1101	}
1102
1103	//--------------------------------------------------------------------------
1104	// ApplicationExpr
1105	template< typename core_t >
1106	const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
1107	VISIT_START( node );
1108
1109	if ( __visit_children() ) {
1110	{
1111	guard_symtab guard { *this };
1112	maybe_accept( node, &ApplicationExpr::result );
1113	}
1114	maybe_accept( node, &ApplicationExpr::func );
1115	maybe_accept( node, &ApplicationExpr::args );
1116	}
1117
1118	VISIT_END( Expr, node );
1119	}
1120
1121	//--------------------------------------------------------------------------
1122	// UntypedExpr
1123	template< typename core_t >
1124	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
1125	VISIT_START( node );
1126
1127	if ( __visit_children() ) {
1128	{
1129	guard_symtab guard { *this };
1130	maybe_accept( node, &UntypedExpr::result );
1131	}
1132
1133	maybe_accept( node, &UntypedExpr::args );
1134	}
1135
1136	VISIT_END( Expr, node );
1137	}
1138
1139	//--------------------------------------------------------------------------
1140	// NameExpr
1141	template< typename core_t >
1142	const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
1143	VISIT_START( node );
1144
1145	if ( __visit_children() ) {
1146	guard_symtab guard { *this };
1147	maybe_accept( node, &NameExpr::result );
1148	}
1149
1150	VISIT_END( Expr, node );
1151	}
1152
1153	//--------------------------------------------------------------------------
1154	// QualifiedNameExpr
1155	template< typename core_t >
1156	const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
1157	VISIT_START( node );
1158	if ( __visit_children() ) {
1159	guard_symtab guard { *this };
1160	maybe_accept( node, &QualifiedNameExpr::type_decl );
1161	}
1162	VISIT_END( Expr, node );
1163	}
1164
1165	//--------------------------------------------------------------------------
1166	// CastExpr
1167	template< typename core_t >
1168	const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
1169	VISIT_START( node );
1170
1171	if ( __visit_children() ) {
1172	{
1173	guard_symtab guard { *this };
1174	maybe_accept( node, &CastExpr::result );
1175	}
1176	maybe_accept( node, &CastExpr::arg );
1177	}
1178
1179	VISIT_END( Expr, node );
1180	}
1181
1182	//--------------------------------------------------------------------------
1183	// KeywordCastExpr
1184	template< typename core_t >
1185	const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
1186	VISIT_START( node );
1187
1188	if ( __visit_children() ) {
1189	{
1190	guard_symtab guard { *this };
1191	maybe_accept( node, &KeywordCastExpr::result );
1192	}
1193	maybe_accept( node, &KeywordCastExpr::arg );
1194	}
1195
1196	VISIT_END( Expr, node );
1197	}
1198
1199	//--------------------------------------------------------------------------
1200	// VirtualCastExpr
1201	template< typename core_t >
1202	const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
1203	VISIT_START( node );
1204
1205	if ( __visit_children() ) {
1206	{
1207	guard_symtab guard { *this };
1208	maybe_accept( node, &VirtualCastExpr::result );
1209	}
1210	maybe_accept( node, &VirtualCastExpr::arg );
1211	}
1212
1213	VISIT_END( Expr, node );
1214	}
1215
1216	//--------------------------------------------------------------------------
1217	// AddressExpr
1218	template< typename core_t >
1219	const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
1220	VISIT_START( node );
1221
1222	if ( __visit_children() ) {
1223	{
1224	guard_symtab guard { *this };
1225	maybe_accept( node, &AddressExpr::result );
1226	}
1227	maybe_accept( node, &AddressExpr::arg );
1228	}
1229
1230	VISIT_END( Expr, node );
1231	}
1232
1233	//--------------------------------------------------------------------------
1234	// LabelAddressExpr
1235	template< typename core_t >
1236	const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
1237	VISIT_START( node );
1238
1239	if ( __visit_children() ) {
1240	guard_symtab guard { *this };
1241	maybe_accept( node, &LabelAddressExpr::result );
1242	}
1243
1244	VISIT_END( Expr, node );
1245	}
1246
1247	//--------------------------------------------------------------------------
1248	// UntypedMemberExpr
1249	template< typename core_t >
1250	const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
1251	VISIT_START( node );
1252
1253	if ( __visit_children() ) {
1254	{
1255	guard_symtab guard { *this };
1256	maybe_accept( node, &UntypedMemberExpr::result );
1257	}
1258	maybe_accept( node, &UntypedMemberExpr::aggregate );
1259	maybe_accept( node, &UntypedMemberExpr::member );
1260	}
1261
1262	VISIT_END( Expr, node );
1263	}
1264
1265	//--------------------------------------------------------------------------
1266	// MemberExpr
1267	template< typename core_t >
1268	const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
1269	VISIT_START( node );
1270
1271	if ( __visit_children() ) {
1272	{
1273	guard_symtab guard { *this };
1274	maybe_accept( node, &MemberExpr::result );
1275	}
1276	maybe_accept( node, &MemberExpr::aggregate );
1277	}
1278
1279	VISIT_END( Expr, node );
1280	}
1281
1282	//--------------------------------------------------------------------------
1283	// VariableExpr
1284	template< typename core_t >
1285	const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
1286	VISIT_START( node );
1287
1288	if ( __visit_children() ) {
1289	guard_symtab guard { *this };
1290	maybe_accept( node, &VariableExpr::result );
1291	}
1292
1293	VISIT_END( Expr, node );
1294	}
1295
1296	//--------------------------------------------------------------------------
1297	// ConstantExpr
1298	template< typename core_t >
1299	const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
1300	VISIT_START( node );
1301
1302	if ( __visit_children() ) {
1303	guard_symtab guard { *this };
1304	maybe_accept( node, &ConstantExpr::result );
1305	}
1306
1307	VISIT_END( Expr, node );
1308	}
1309
1310	//--------------------------------------------------------------------------
1311	// SizeofExpr
1312	template< typename core_t >
1313	const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
1314	VISIT_START( node );
1315
1316	if ( __visit_children() ) {
1317	{
1318	guard_symtab guard { *this };
1319	maybe_accept( node, &SizeofExpr::result );
1320	}
1321	if ( node->type ) {
1322	maybe_accept( node, &SizeofExpr::type );
1323	} else {
1324	maybe_accept( node, &SizeofExpr::expr );
1325	}
1326	}
1327
1328	VISIT_END( Expr, node );
1329	}
1330
1331	//--------------------------------------------------------------------------
1332	// CountExpr
1333	template< typename core_t >
1334	const ast::Expr * ast::Pass< core_t >::visit( const ast::CountExpr * node ) {
1335	VISIT_START( node );
1336	if ( __visit_children() ) {
1337	{
1338	guard_symtab guard { *this };
1339	maybe_accept( node, &CountExpr::result );
1340	}
1341	if ( node->type ) {
1342	maybe_accept( node, &CountExpr::type );
1343	} else {
1344	maybe_accept( node, &CountExpr::expr );
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: