Context Navigation

source: src/AST/Pass.impl.hpp @ 3e5db5b4

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum

Last change on this file since 3e5db5b4 was cef7430, checked in by caparsons <caparson@…>, 3 years ago
Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
Property mode set to `100644`
File size: 60.8 KB

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

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

Download in other formats: