source: src/AST/Pass.impl.hpp@ 93c10de

ADT ast-experimental
Last change on this file since 93c10de was db6cdc0, checked in by JiadaL <j82liang@…>, 3 years ago

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