Context Navigation

source: src/AST/Pass.impl.hpp @ 45d1ab9

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

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

Download in other formats: