source: src/AST/Pass.impl.hpp@ 1b0184b

Last change on this file since 1b0184b was eb779d5, checked in by caparsons <caparson@…>, 2 years ago

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