source: src/AST/Pass.impl.hpp@ 8fd1b7c

ADT ast-experimental
Last change on this file since 8fd1b7c was 2d0f918, checked in by Andrew Beach <ajbeach@…>, 2 years ago

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