Context Navigation

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

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

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

Download in other formats: