source: src/AST/Pass.impl.hpp@ f5212ca

Last change on this file since f5212ca was 0522ebe, checked in by JiadaL <j82liang@…>, 19 months ago

Add EnumPosType to type system
  • Property mode set to 100644
File size: 64.4 KB
RevLine 
[04124c4]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//
[e0016a5]7// ast::Pass.impl.hpp --
[04124c4]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
[f47f887]16#pragma once
[04124c4]17// IWYU pragma: private, include "AST/Pass.hpp"
[f47f887]18
[6d51bd7]19#include <type_traits>
20#include <unordered_map>
21
[bccd70a]22#include "AST/Copy.hpp"
[293dc1c]23#include "AST/TranslationUnit.hpp"
[c671112]24#include "AST/TypeSubstitution.hpp"
25
[f47f887]26#define VISIT_START( node ) \
[04124c4]27 using namespace ast; \
[a9762dc]28 /* back-up the last known code location */ \
[95e5018]29 __attribute__((unused)) auto loc_guard = ast::__pass::make_location_guard( core, node, 0 ); \
[f47f887]30 /* back-up the visit children */ \
[7ff3e522]31 __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
[f47f887]32 /* setup the scope for passes that want to run code at exit */ \
[7ff3e522]33 __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \
[c15085d]34 /* begin tracing memory allocation if requested by this pass */ \
[7ff3e522]35 __pass::beginTrace( core, 0 ); \
[f47f887]36 /* call the implementation of the previsit of this pass */ \
[7ff3e522]37 __pass::previsit( core, node, 0 );
[f47f887]38
39#define VISIT_END( type, node ) \
40 /* call the implementation of the postvisit of this pass */ \
[7ff3e522]41 auto __return = __pass::postvisit( core, node, 0 ); \
[f47f887]42 assertf(__return, "post visit should never return null"); \
[c15085d]43 /* end tracing memory allocation if requested by this pass */ \
[7ff3e522]44 __pass::endTrace( core, 0 ); \
[f47f887]45 return __return;
46
47#ifdef PEDANTIC_PASS_ASSERT
[efe89894]48#define __pedantic_pass_assert(...) assert(__VA_ARGS__)
[6d51bd7]49#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
[f47f887]50#else
[6d51bd7]51#define __pedantic_pass_assert(...)
[f47f887]52#define __pedantic_pass_assertf(...)
53#endif
54
[e0069bd]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 }
[f47f887]61
[e0069bd]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 }
[d3aa64f1]66
[e0069bd]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;
[f47f887]71
[e0069bd]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 }
[f47f887]78
[e0069bd]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;
[f47f887]82
[e0069bd]83 std::move(stmts->begin(), stmts->end(), it);
84 stmts->clear();
85 if ( mutated ) *mutated = true;
86 }
[f47f887]87
[e0069bd]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 }
[f47f887]94
[e0069bd]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 }
[f47f887]99
[e0069bd]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 }
[f47f887]106
[e0069bd]107 template<typename node_t>
108 const node_t & get( const node_t & val, long ) {
109 return val;
110 }
[f47f887]111
[e0069bd]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 }
[6d51bd7]118
[e0069bd]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();
[f47f887]122 }
[148f836e]123}
[f47f887]124
[148f836e]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}
[f47f887]144
[148f836e]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 );
[f47f887]149
[148f836e]150 auto nval = expr->accept( *this );
151 return { nval != expr, nval };
152}
[f47f887]153
[148f836e]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 );
[f47f887]158
[148f836e]159 const ast::Stmt * nval = stmt->accept( *this );
160 return { nval != stmt, nval };
161}
[490fb92e]162
[148f836e]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 );
[9e23b446]167
[148f836e]168 const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
169 if ( typeSubs_ptr && expr->env ) {
170 *typeSubs_ptr = expr->env;
[9e23b446]171 }
172
[148f836e]173 auto nval = expr->accept( *this );
174 return { nval != expr, nval };
175}
[f47f887]176
[148f836e]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 }
[f47f887]205
[148f836e]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 )) );
[f47f887]210
[148f836e]211 // Create a new Compound Statement to hold the new decls/stmts
212 ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
[f47f887]213
[148f836e]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 );
[f47f887]217
[148f836e]218 // Insert the original declaration
219 compound->kids.emplace_back( nstmt );
[f47f887]220
[148f836e]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 );
[f47f887]224
[148f836e]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 );
[f47f887]281 }
282
[148f836e]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 }
[f8143a6]289 }
[148f836e]290 pass_visitor_stats.depth--;
291 if ( !errors.isEmpty() ) { throw errors; }
[f8143a6]292
[148f836e]293 return new_kids;
294}
[f47f887]295
[148f836e]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 );
[f47f887]318 }
[148f836e]319 } catch ( SemanticErrorException &e ) {
320 errors.append( e );
[f47f887]321 }
[148f836e]322 }
[f8143a6]323
[148f836e]324 __pedantic_pass_assert( new_kids.size() == container.size() );
325 pass_visitor_stats.depth--;
326 if ( !errors.isEmpty() ) { throw errors; }
[f47f887]327
[148f836e]328 return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
329}
[6d51bd7]330
[148f836e]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" );
[6d51bd7]338
[148f836e]339 if ( __pass::skip( parent->*field ) ) return;
340 const auto & old_val = __pass::get(parent->*field, 0);
[6d51bd7]341
[148f836e]342 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
[6d51bd7]343
[148f836e]344 auto new_val = call_accept( old_val );
[6d51bd7]345
[148f836e]346 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR" );
[6d51bd7]347
[148f836e]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;
[f47f887]352 }
[148f836e]353}
[6d51bd7]354
[148f836e]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" );
[9e23b446]362
[148f836e]363 if ( __pass::skip( parent->*field ) ) return;
364 const auto & old_val = __pass::get(parent->*field, 0);
[9e23b446]365
[148f836e]366 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
[9e23b446]367
[148f836e]368 auto new_val = call_accept_top( old_val );
[9e23b446]369
[148f836e]370 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR" );
[9e23b446]371
[148f836e]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;
[9e23b446]376 }
[148f836e]377}
[9e23b446]378
[148f836e]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" );
[490fb92e]386
[148f836e]387 if ( __pass::skip( parent->*child ) ) return;
388 const auto & old_val = __pass::get(parent->*child, 0);
[490fb92e]389
[148f836e]390 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
[490fb92e]391
[148f836e]392 auto new_val = call_accept_as_compound( old_val );
[490fb92e]393
[148f836e]394 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR" );
[490fb92e]395
[148f836e]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;
[490fb92e]400 }
[f47f887]401}
402
403//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
404//========================================================================================================================================================================
405//========================================================================================================================================================================
406//========================================================================================================================================================================
407//========================================================================================================================================================================
408//========================================================================================================================================================================
409//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
410
[7ff3e522]411template< typename core_t >
412inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
[04124c4]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
[7ff3e522]420 auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
421 auto decls_after = __pass::declsToAddAfter ( visitor.core, 0);
[04124c4]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 ) {
[e00c22f]441 if (__pass::on_error (visitor.core, *i, 0))
[0dd9a5e]442 errors.append( e );
[04124c4]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
[293dc1c]452template< typename core_t >
453inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
[c600df1]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 }
[293dc1c]461}
462
[f47f887]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
[7ff3e522]482template< typename core_t >
483const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
[f47f887]484 VISIT_START( node );
485
[e21f253]486 if ( __visit_children() ) {
[f47f887]487 {
[0e42794]488 guard_symtab guard { *this };
[23f99e1]489 maybe_accept( node, &ObjectDecl::type );
[f47f887]490 }
[23f99e1]491 maybe_accept( node, &ObjectDecl::init );
492 maybe_accept( node, &ObjectDecl::bitfieldWidth );
493 maybe_accept( node, &ObjectDecl::attributes );
[e21f253]494 }
[f47f887]495
[7ff3e522]496 __pass::symtab::addId( core, 0, node );
[f47f887]497
[04124c4]498 VISIT_END( DeclWithType, node );
[f47f887]499}
500
[23f99e1]501//--------------------------------------------------------------------------
502// FunctionDecl
[7ff3e522]503template< typename core_t >
504const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
[23f99e1]505 VISIT_START( node );
506
[7ff3e522]507 __pass::symtab::addId( core, 0, node );
[23f99e1]508
[e21f253]509 if ( __visit_children() ) {
510 maybe_accept( node, &FunctionDecl::withExprs );
511 }
[23f99e1]512 {
513 // with clause introduces a level of scope (for the with expression members).
[0e42794]514 // with clause exprs are added to the symbol table before parameters so that parameters
[23f99e1]515 // shadow with exprs and not the other way around.
[0e42794]516 guard_symtab guard { *this };
[7ff3e522]517 __pass::symtab::addWith( core, 0, node->withExprs, node );
[23f99e1]518 {
[0e42794]519 guard_symtab guard { *this };
[23f99e1]520 // implicit add __func__ identifier as specified in the C manual 6.4.2.2
[e8616b6]521 // This is a C name and so has C linkage.
[798a8b3]522 static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
[9ea38de]523 CodeLocation{}, "__func__",
524 new ast::ArrayType{
525 new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
[8a5530c]526 nullptr, VariableLen, DynamicDim
[e8616b6]527 },
528 nullptr,
529 ast::Storage::Classes(),
530 ast::Linkage::C,
[9ea38de]531 } };
[7ff3e522]532 __pass::symtab::addId( core, 0, func );
[e21f253]533 if ( __visit_children() ) {
[3e5dd913]534 maybe_accept( node, &FunctionDecl::type_params );
535 maybe_accept( node, &FunctionDecl::assertions );
[4ec9513]536 maybe_accept( node, &FunctionDecl::params );
537 maybe_accept( node, &FunctionDecl::returns );
538 maybe_accept( node, &FunctionDecl::type );
[f2ff0a6]539 maybe_accept( node, &FunctionDecl::attributes );
[c6c682cf]540 // First remember that we are now within a function.
[23f99e1]541 ValueGuard< bool > oldInFunction( inFunction );
542 inFunction = true;
[c6c682cf]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;
[8a5530c]547 maybe_accept( node, &FunctionDecl::stmts );
[e21f253]548 }
[23f99e1]549 }
550 }
551
552 VISIT_END( DeclWithType, node );
553}
554
555//--------------------------------------------------------------------------
556// StructDecl
[7ff3e522]557template< typename core_t >
558const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
[23f99e1]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
[7ff3e522]563 __pass::symtab::addStructFwd( core, 0, node );
[23f99e1]564
[e21f253]565 if ( __visit_children() ) {
[0e42794]566 guard_symtab guard { * this };
[798a8b3]567 maybe_accept( node, &StructDecl::params );
568 maybe_accept( node, &StructDecl::members );
569 maybe_accept( node, &StructDecl::attributes );
[e21f253]570 }
[23f99e1]571
572 // this addition replaces the forward declaration
[7ff3e522]573 __pass::symtab::addStruct( core, 0, node );
[23f99e1]574
575 VISIT_END( Decl, node );
576}
577
578//--------------------------------------------------------------------------
579// UnionDecl
[7ff3e522]580template< typename core_t >
581const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
[23f99e1]582 VISIT_START( node );
583
584 // make up a forward declaration and add it before processing the members
[7ff3e522]585 __pass::symtab::addUnionFwd( core, 0, node );
[23f99e1]586
[e21f253]587 if ( __visit_children() ) {
[0e42794]588 guard_symtab guard { * this };
[798a8b3]589 maybe_accept( node, &UnionDecl::params );
590 maybe_accept( node, &UnionDecl::members );
591 maybe_accept( node, &UnionDecl::attributes );
[e21f253]592 }
[23f99e1]593
[7ff3e522]594 __pass::symtab::addUnion( core, 0, node );
[23f99e1]595
596 VISIT_END( Decl, node );
597}
598
599//--------------------------------------------------------------------------
600// EnumDecl
[7ff3e522]601template< typename core_t >
602const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
[23f99e1]603 VISIT_START( node );
604
[7ff3e522]605 __pass::symtab::addEnum( core, 0, node );
[23f99e1]606
[e21f253]607 if ( __visit_children() ) {
[e4d7c1c]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 }
[e21f253]620 }
[23f99e1]621
622 VISIT_END( Decl, node );
623}
624
625//--------------------------------------------------------------------------
626// TraitDecl
[7ff3e522]627template< typename core_t >
628const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
[23f99e1]629 VISIT_START( node );
630
[e21f253]631 if ( __visit_children() ) {
[0e42794]632 guard_symtab guard { *this };
[798a8b3]633 maybe_accept( node, &TraitDecl::params );
634 maybe_accept( node, &TraitDecl::members );
635 maybe_accept( node, &TraitDecl::attributes );
[e21f253]636 }
[23f99e1]637
[7ff3e522]638 __pass::symtab::addTrait( core, 0, node );
[23f99e1]639
640 VISIT_END( Decl, node );
641}
642
643//--------------------------------------------------------------------------
644// TypeDecl
[7ff3e522]645template< typename core_t >
646const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
[23f99e1]647 VISIT_START( node );
648
[e21f253]649 if ( __visit_children() ) {
[0e42794]650 guard_symtab guard { *this };
[87701b6]651 maybe_accept( node, &TypeDecl::base );
[e21f253]652 }
[23f99e1]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
[7ff3e522]657 __pass::symtab::addType( core, 0, node );
[23f99e1]658
[e21f253]659 if ( __visit_children() ) {
[8a5530c]660 maybe_accept( node, &TypeDecl::assertions );
[23f99e1]661
662 {
[0e42794]663 guard_symtab guard { *this };
[23f99e1]664 maybe_accept( node, &TypeDecl::init );
665 }
[e21f253]666 }
[23f99e1]667
668 VISIT_END( Decl, node );
669}
670
671//--------------------------------------------------------------------------
672// TypedefDecl
[7ff3e522]673template< typename core_t >
674const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
[23f99e1]675 VISIT_START( node );
676
[e21f253]677 if ( __visit_children() ) {
[0e42794]678 guard_symtab guard { *this };
[87701b6]679 maybe_accept( node, &TypedefDecl::base );
[e21f253]680 }
[23f99e1]681
[7ff3e522]682 __pass::symtab::addType( core, 0, node );
[23f99e1]683
[e21f253]684 if ( __visit_children() ) {
685 maybe_accept( node, &TypedefDecl::assertions );
686 }
[23f99e1]687
688 VISIT_END( Decl, node );
689}
690
691//--------------------------------------------------------------------------
692// AsmDecl
[7ff3e522]693template< typename core_t >
694const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
[23f99e1]695 VISIT_START( node );
696
[e21f253]697 if ( __visit_children() ) {
[23f99e1]698 maybe_accept( node, &AsmDecl::stmt );
[e21f253]699 }
[23f99e1]700
701 VISIT_END( AsmDecl, node );
702}
703
[2d019af]704//--------------------------------------------------------------------------
705// DirectiveDecl
706template< typename core_t >
707const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
708 VISIT_START( node );
709
[e21f253]710 if ( __visit_children() ) {
[2d019af]711 maybe_accept( node, &DirectiveDecl::stmt );
[e21f253]712 }
[2d019af]713
714 VISIT_END( DirectiveDecl, node );
715}
716
[23f99e1]717//--------------------------------------------------------------------------
718// StaticAssertDecl
[7ff3e522]719template< typename core_t >
720const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
[23f99e1]721 VISIT_START( node );
722
[e21f253]723 if ( __visit_children() ) {
[9e23b446]724 maybe_accept_top( node, &StaticAssertDecl::cond );
[112fe04]725 maybe_accept( node, &StaticAssertDecl::msg );
[e21f253]726 }
[23f99e1]727
728 VISIT_END( StaticAssertDecl, node );
729}
730
[e874605]731//--------------------------------------------------------------------------
[19a8c40]732// InlineMemberDecl
[e874605]733template< typename core_t >
[71806e0]734const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
[e874605]735 VISIT_START( node );
736
737 if ( __visit_children() ) {
738 {
739 guard_symtab guard { *this };
[71806e0]740 maybe_accept( node, &InlineMemberDecl::type );
[e874605]741 }
742 }
743
744 VISIT_END( DeclWithType, node );
745}
746
[23f99e1]747//--------------------------------------------------------------------------
748// CompoundStmt
[7ff3e522]749template< typename core_t >
750const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
[23f99e1]751 VISIT_START( node );
[e21f253]752
753 if ( __visit_children() ) {
[334801b]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 }
[e21f253]766 }
767
[23f99e1]768 VISIT_END( CompoundStmt, node );
769}
770
[8a5530c]771//--------------------------------------------------------------------------
772// ExprStmt
[7ff3e522]773template< typename core_t >
774const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
[8a5530c]775 VISIT_START( node );
776
[e21f253]777 if ( __visit_children() ) {
[9e23b446]778 maybe_accept_top( node, &ExprStmt::expr );
[e21f253]779 }
[8a5530c]780
781 VISIT_END( Stmt, node );
782}
783
784//--------------------------------------------------------------------------
785// AsmStmt
[7ff3e522]786template< typename core_t >
787const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
[8a5530c]788 VISIT_START( node )
789
[e21f253]790 if ( __visit_children() ) {
[8a5530c]791 maybe_accept( node, &AsmStmt::instruction );
792 maybe_accept( node, &AsmStmt::output );
793 maybe_accept( node, &AsmStmt::input );
794 maybe_accept( node, &AsmStmt::clobber );
[e21f253]795 }
[8a5530c]796
797 VISIT_END( Stmt, node );
798}
799
800//--------------------------------------------------------------------------
801// DirectiveStmt
[7ff3e522]802template< typename core_t >
803const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
[8a5530c]804 VISIT_START( node )
805
806 VISIT_END( Stmt, node );
807}
808
809//--------------------------------------------------------------------------
810// IfStmt
[7ff3e522]811template< typename core_t >
812const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
[8a5530c]813 VISIT_START( node );
[17a0228a]814
[e21f253]815 if ( __visit_children() ) {
[8a5530c]816 // if statements introduce a level of scope (for the initialization)
[0e42794]817 guard_symtab guard { *this };
[8a5530c]818 maybe_accept( node, &IfStmt::inits );
[9e23b446]819 maybe_accept_top( node, &IfStmt::cond );
[3b0bc16]820 maybe_accept_as_compound( node, &IfStmt::then );
821 maybe_accept_as_compound( node, &IfStmt::else_ );
[e21f253]822 }
[17a0228a]823
[8a5530c]824 VISIT_END( Stmt, node );
825}
826
827//--------------------------------------------------------------------------
[3b0bc16]828// WhileDoStmt
[7ff3e522]829template< typename core_t >
[3b0bc16]830const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
[8a5530c]831 VISIT_START( node );
832
[e21f253]833 if ( __visit_children() ) {
[8a5530c]834 // while statements introduce a level of scope (for the initialization)
[0e42794]835 guard_symtab guard { *this };
[3b0bc16]836 maybe_accept( node, &WhileDoStmt::inits );
[9e23b446]837 maybe_accept_top( node, &WhileDoStmt::cond );
[3b0bc16]838 maybe_accept_as_compound( node, &WhileDoStmt::body );
[e21f253]839 }
[8a5530c]840
841 VISIT_END( Stmt, node );
842}
[23f99e1]843
[87701b6]844//--------------------------------------------------------------------------
845// ForStmt
[7ff3e522]846template< typename core_t >
847const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
[87701b6]848 VISIT_START( node );
849
[e21f253]850 if ( __visit_children() ) {
[87701b6]851 // for statements introduce a level of scope (for the initialization)
[0e42794]852 guard_symtab guard { *this };
[490fb92e]853 // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
[87701b6]854 maybe_accept( node, &ForStmt::inits );
[9e23b446]855 maybe_accept_top( node, &ForStmt::cond );
856 maybe_accept_top( node, &ForStmt::inc );
[490fb92e]857 maybe_accept_as_compound( node, &ForStmt::body );
[e21f253]858 }
[87701b6]859
860 VISIT_END( Stmt, node );
861}
862
863//--------------------------------------------------------------------------
864// SwitchStmt
[7ff3e522]865template< typename core_t >
866const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
[87701b6]867 VISIT_START( node );
868
[e21f253]869 if ( __visit_children() ) {
[9e23b446]870 maybe_accept_top( node, &SwitchStmt::cond );
[400b8be]871 maybe_accept( node, &SwitchStmt::cases );
[e21f253]872 }
[87701b6]873
874 VISIT_END( Stmt, node );
875}
876
877//--------------------------------------------------------------------------
[400b8be]878// CaseClause
[7ff3e522]879template< typename core_t >
[400b8be]880const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
[87701b6]881 VISIT_START( node );
882
[e21f253]883 if ( __visit_children() ) {
[9e23b446]884 maybe_accept_top( node, &CaseClause::cond );
[400b8be]885 maybe_accept( node, &CaseClause::stmts );
[e21f253]886 }
[87701b6]887
[400b8be]888 VISIT_END( CaseClause, node );
[87701b6]889}
890
891//--------------------------------------------------------------------------
892// BranchStmt
[7ff3e522]893template< typename core_t >
894const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
[87701b6]895 VISIT_START( node );
896 VISIT_END( Stmt, node );
897}
898
899//--------------------------------------------------------------------------
900// ReturnStmt
[7ff3e522]901template< typename core_t >
902const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
[87701b6]903 VISIT_START( node );
904
[e21f253]905 if ( __visit_children() ) {
[9e23b446]906 maybe_accept_top( node, &ReturnStmt::expr );
[e21f253]907 }
[87701b6]908
909 VISIT_END( Stmt, node );
910}
911
912//--------------------------------------------------------------------------
913// ThrowStmt
[7ff3e522]914template< typename core_t >
915const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
[e61207e7]916 VISIT_START( node );
[87701b6]917
[e21f253]918 if ( __visit_children() ) {
[e61207e7]919 maybe_accept( node, &ThrowStmt::expr );
920 maybe_accept( node, &ThrowStmt::target );
[e21f253]921 }
[e61207e7]922
923 VISIT_END( Stmt, node );
924}
925
926//--------------------------------------------------------------------------
927// TryStmt
[7ff3e522]928template< typename core_t >
929const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
[87701b6]930 VISIT_START( node );
931
[e21f253]932 if ( __visit_children() ) {
[acd80b4]933 maybe_accept( node, &TryStmt::body );
934 maybe_accept( node, &TryStmt::handlers );
935 maybe_accept( node, &TryStmt::finally );
[e21f253]936 }
[87701b6]937
[e61207e7]938 VISIT_END( Stmt, node );
[87701b6]939}
940
[10a1225]941//--------------------------------------------------------------------------
[400b8be]942// CatchClause
[7ff3e522]943template< typename core_t >
[400b8be]944const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
[10a1225]945 VISIT_START( node );
946
[e21f253]947 if ( __visit_children() ) {
[10a1225]948 // catch statements introduce a level of scope (for the caught exception)
[0e42794]949 guard_symtab guard { *this };
[400b8be]950 maybe_accept( node, &CatchClause::decl );
[9e23b446]951 maybe_accept_top( node, &CatchClause::cond );
[400b8be]952 maybe_accept_as_compound( node, &CatchClause::body );
[e21f253]953 }
[10a1225]954
[400b8be]955 VISIT_END( CatchClause, node );
[10a1225]956}
957
958//--------------------------------------------------------------------------
[400b8be]959// FinallyClause
[7ff3e522]960template< typename core_t >
[400b8be]961const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
[10a1225]962 VISIT_START( node );
963
[e21f253]964 if ( __visit_children() ) {
[400b8be]965 maybe_accept( node, &FinallyClause::body );
[e21f253]966 }
[10a1225]967
[400b8be]968 VISIT_END( FinallyClause, node );
[10a1225]969}
970
[37cdd97]971//--------------------------------------------------------------------------
972// FinallyStmt
[7ff3e522]973template< typename core_t >
974const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
[37cdd97]975 VISIT_START( node );
976
[e21f253]977 if ( __visit_children() ) {
[37cdd97]978 maybe_accept( node, &SuspendStmt::then );
[e21f253]979 }
[37cdd97]980
981 VISIT_END( Stmt, node );
982}
983
[c86b08d]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
[10a1225]999//--------------------------------------------------------------------------
1000// WaitForStmt
[7ff3e522]1001template< typename core_t >
1002const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
[10a1225]1003 VISIT_START( node );
1004
[e21f253]1005 if ( __visit_children() ) {
[f6e6a55]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 );
[e21f253]1012 }
[e0016a5]1013
[f6e6a55]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 );
[10a1225]1022
[e21f253]1023 if ( __visit_children() ) {
[c86b08d]1024 maybe_accept( node, &WaitForClause::target );
[f6e6a55]1025 maybe_accept( node, &WaitForClause::target_args );
1026 maybe_accept( node, &WaitForClause::stmt );
[c86b08d]1027 maybe_accept( node, &WaitForClause::when_cond );
[e21f253]1028 }
[10a1225]1029
[f6e6a55]1030 VISIT_END( WaitForClause, node );
[10a1225]1031}
1032
[c86b08d]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
[10a1225]1051//--------------------------------------------------------------------------
1052// WithStmt
[7ff3e522]1053template< typename core_t >
1054const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
[10a1225]1055 VISIT_START( node );
1056
[e21f253]1057 if ( __visit_children() ) {
[10a1225]1058 maybe_accept( node, &WithStmt::exprs );
1059 {
1060 // catch statements introduce a level of scope (for the caught exception)
[0e42794]1061 guard_symtab guard { *this };
[7ff3e522]1062 __pass::symtab::addWith( core, 0, node->exprs, node );
[10a1225]1063 maybe_accept( node, &WithStmt::stmt );
1064 }
[e21f253]1065 }
1066
[10a1225]1067 VISIT_END( Stmt, node );
1068}
1069
1070//--------------------------------------------------------------------------
1071// NullStmt
[7ff3e522]1072template< typename core_t >
1073const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
[10a1225]1074 VISIT_START( node );
1075 VISIT_END( NullStmt, node );
1076}
1077
1078//--------------------------------------------------------------------------
1079// DeclStmt
[7ff3e522]1080template< typename core_t >
1081const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
[10a1225]1082 VISIT_START( node );
1083
[e21f253]1084 if ( __visit_children() ) {
[10a1225]1085 maybe_accept( node, &DeclStmt::decl );
[e21f253]1086 }
[10a1225]1087
1088 VISIT_END( Stmt, node );
1089}
1090
1091//--------------------------------------------------------------------------
1092// ImplicitCtorDtorStmt
[7ff3e522]1093template< typename core_t >
1094const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
[10a1225]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
[e21f253]1099 if ( __visit_children() ) {
[c570806]1100 maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
[e21f253]1101 }
[10a1225]1102
1103 VISIT_END( Stmt, node );
1104}
1105
[6cebfef]1106//--------------------------------------------------------------------------
1107// MutexStmt
1108template< typename core_t >
1109const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
1110 VISIT_START( node );
1111
[e21f253]1112 if ( __visit_children() ) {
[6cebfef]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 );
[e21f253]1117 }
[6cebfef]1118
1119 VISIT_END( Stmt, node );
1120}
1121
[eb779d5]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
[3d9d017]1135//--------------------------------------------------------------------------
1136// CoforStmt
1137template< typename core_t >
1138const ast::Stmt * ast::Pass< core_t >::visit( const ast::CoforStmt * node ) {
1139 VISIT_START( node );
1140
1141 if ( __visit_children() ) {
1142 // for statements introduce a level of scope (for the initialization)
1143 guard_symtab guard { *this };
1144 maybe_accept( node, &CoforStmt::inits );
1145 maybe_accept_top( node, &CoforStmt::cond );
1146 maybe_accept_top( node, &CoforStmt::inc );
1147 maybe_accept_as_compound( node, &CoforStmt::body );
1148 }
1149
1150 VISIT_END( Stmt, node );
1151}
1152
[17a0228a]1153//--------------------------------------------------------------------------
1154// ApplicationExpr
[7ff3e522]1155template< typename core_t >
1156const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
[17a0228a]1157 VISIT_START( node );
1158
[e21f253]1159 if ( __visit_children() ) {
[17a0228a]1160 {
[0e42794]1161 guard_symtab guard { *this };
[17a0228a]1162 maybe_accept( node, &ApplicationExpr::result );
1163 }
1164 maybe_accept( node, &ApplicationExpr::func );
1165 maybe_accept( node, &ApplicationExpr::args );
[e21f253]1166 }
[17a0228a]1167
1168 VISIT_END( Expr, node );
1169}
1170
1171//--------------------------------------------------------------------------
1172// UntypedExpr
[7ff3e522]1173template< typename core_t >
1174const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
[17a0228a]1175 VISIT_START( node );
1176
[e21f253]1177 if ( __visit_children() ) {
[17a0228a]1178 {
[0e42794]1179 guard_symtab guard { *this };
[17a0228a]1180 maybe_accept( node, &UntypedExpr::result );
1181 }
1182
1183 maybe_accept( node, &UntypedExpr::args );
[e21f253]1184 }
[17a0228a]1185
1186 VISIT_END( Expr, node );
1187}
1188
1189//--------------------------------------------------------------------------
1190// NameExpr
[7ff3e522]1191template< typename core_t >
1192const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
[17a0228a]1193 VISIT_START( node );
1194
[e21f253]1195 if ( __visit_children() ) {
[0e42794]1196 guard_symtab guard { *this };
[17a0228a]1197 maybe_accept( node, &NameExpr::result );
[e21f253]1198 }
[17a0228a]1199
1200 VISIT_END( Expr, node );
1201}
1202
[b0d9ff7]1203//--------------------------------------------------------------------------
1204// QualifiedNameExpr
1205template< typename core_t >
1206const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
1207 VISIT_START( node );
1208 if ( __visit_children() ) {
1209 guard_symtab guard { *this };
1210 maybe_accept( node, &QualifiedNameExpr::type_decl );
1211 }
1212 VISIT_END( Expr, node );
1213}
1214
[17a0228a]1215//--------------------------------------------------------------------------
1216// CastExpr
[7ff3e522]1217template< typename core_t >
1218const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
[17a0228a]1219 VISIT_START( node );
1220
[e21f253]1221 if ( __visit_children() ) {
1222 {
[0e42794]1223 guard_symtab guard { *this };
[17a0228a]1224 maybe_accept( node, &CastExpr::result );
1225 }
1226 maybe_accept( node, &CastExpr::arg );
[e21f253]1227 }
[17a0228a]1228
1229 VISIT_END( Expr, node );
1230}
1231
1232//--------------------------------------------------------------------------
1233// KeywordCastExpr
[7ff3e522]1234template< typename core_t >
1235const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
[17a0228a]1236 VISIT_START( node );
1237
[e21f253]1238 if ( __visit_children() ) {
1239 {
[0e42794]1240 guard_symtab guard { *this };
[17a0228a]1241 maybe_accept( node, &KeywordCastExpr::result );
1242 }
1243 maybe_accept( node, &KeywordCastExpr::arg );
[e21f253]1244 }
[17a0228a]1245
1246 VISIT_END( Expr, node );
1247}
1248
1249//--------------------------------------------------------------------------
1250// VirtualCastExpr
[7ff3e522]1251template< typename core_t >
1252const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
[17a0228a]1253 VISIT_START( node );
1254
[e21f253]1255 if ( __visit_children() ) {
1256 {
[0e42794]1257 guard_symtab guard { *this };
[17a0228a]1258 maybe_accept( node, &VirtualCastExpr::result );
1259 }
1260 maybe_accept( node, &VirtualCastExpr::arg );
[e21f253]1261 }
[17a0228a]1262
1263 VISIT_END( Expr, node );
1264}
1265
1266//--------------------------------------------------------------------------
1267// AddressExpr
[7ff3e522]1268template< typename core_t >
1269const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
[17a0228a]1270 VISIT_START( node );
1271
[e21f253]1272 if ( __visit_children() ) {
1273 {
[0e42794]1274 guard_symtab guard { *this };
[17a0228a]1275 maybe_accept( node, &AddressExpr::result );
1276 }
1277 maybe_accept( node, &AddressExpr::arg );
[e21f253]1278 }
[17a0228a]1279
1280 VISIT_END( Expr, node );
1281}
1282
1283//--------------------------------------------------------------------------
1284// LabelAddressExpr
[7ff3e522]1285template< typename core_t >
1286const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
[17a0228a]1287 VISIT_START( node );
1288
[e21f253]1289 if ( __visit_children() ) {
[0e42794]1290 guard_symtab guard { *this };
[17a0228a]1291 maybe_accept( node, &LabelAddressExpr::result );
[e21f253]1292 }
[17a0228a]1293
1294 VISIT_END( Expr, node );
1295}
1296
1297//--------------------------------------------------------------------------
1298// UntypedMemberExpr
[7ff3e522]1299template< typename core_t >
1300const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
[17a0228a]1301 VISIT_START( node );
1302
[e21f253]1303 if ( __visit_children() ) {
1304 {
[0e42794]1305 guard_symtab guard { *this };
[17a0228a]1306 maybe_accept( node, &UntypedMemberExpr::result );
1307 }
1308 maybe_accept( node, &UntypedMemberExpr::aggregate );
1309 maybe_accept( node, &UntypedMemberExpr::member );
[e21f253]1310 }
[17a0228a]1311
1312 VISIT_END( Expr, node );
1313}
1314
1315//--------------------------------------------------------------------------
1316// MemberExpr
[7ff3e522]1317template< typename core_t >
1318const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
[17a0228a]1319 VISIT_START( node );
1320
[e21f253]1321 if ( __visit_children() ) {
1322 {
[0e42794]1323 guard_symtab guard { *this };
[17a0228a]1324 maybe_accept( node, &MemberExpr::result );
1325 }
1326 maybe_accept( node, &MemberExpr::aggregate );
[e21f253]1327 }
[17a0228a]1328
1329 VISIT_END( Expr, node );
1330}
1331
1332//--------------------------------------------------------------------------
1333// VariableExpr
[7ff3e522]1334template< typename core_t >
1335const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
[17a0228a]1336 VISIT_START( node );
1337
[e21f253]1338 if ( __visit_children() ) {
[0e42794]1339 guard_symtab guard { *this };
[17a0228a]1340 maybe_accept( node, &VariableExpr::result );
[e21f253]1341 }
[17a0228a]1342
1343 VISIT_END( Expr, node );
1344}
1345
1346//--------------------------------------------------------------------------
1347// ConstantExpr
[7ff3e522]1348template< typename core_t >
1349const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
[17a0228a]1350 VISIT_START( node );
1351
[e21f253]1352 if ( __visit_children() ) {
[0e42794]1353 guard_symtab guard { *this };
[17a0228a]1354 maybe_accept( node, &ConstantExpr::result );
[e21f253]1355 }
[17a0228a]1356
1357 VISIT_END( Expr, node );
1358}
1359
1360//--------------------------------------------------------------------------
1361// SizeofExpr
[7ff3e522]1362template< typename core_t >
1363const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
[17a0228a]1364 VISIT_START( node );
1365
[e21f253]1366 if ( __visit_children() ) {
1367 {
[0e42794]1368 guard_symtab guard { *this };
[17a0228a]1369 maybe_accept( node, &SizeofExpr::result );
1370 }
1371 if ( node->type ) {
1372 maybe_accept( node, &SizeofExpr::type );
1373 } else {
1374 maybe_accept( node, &SizeofExpr::expr );
1375 }
[e21f253]1376 }
[17a0228a]1377
1378 VISIT_END( Expr, node );
1379}
1380
1381//--------------------------------------------------------------------------
1382// AlignofExpr
[7ff3e522]1383template< typename core_t >
1384const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
[17a0228a]1385 VISIT_START( node );
1386
[e21f253]1387 if ( __visit_children() ) {
1388 {
[0e42794]1389 guard_symtab guard { *this };
[17a0228a]1390 maybe_accept( node, &AlignofExpr::result );
1391 }
1392 if ( node->type ) {
1393 maybe_accept( node, &AlignofExpr::type );
1394 } else {
1395 maybe_accept( node, &AlignofExpr::expr );
1396 }
[e21f253]1397 }
[17a0228a]1398
1399 VISIT_END( Expr, node );
1400}
1401
1402//--------------------------------------------------------------------------
1403// UntypedOffsetofExpr
[7ff3e522]1404template< typename core_t >
1405const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
[17a0228a]1406 VISIT_START( node );
1407
[e21f253]1408 if ( __visit_children() ) {
1409 {
[0e42794]1410 guard_symtab guard { *this };
[17a0228a]1411 maybe_accept( node, &UntypedOffsetofExpr::result );
1412 }
1413 maybe_accept( node, &UntypedOffsetofExpr::type );
[e21f253]1414 }
[17a0228a]1415
1416 VISIT_END( Expr, node );
1417}
1418
1419//--------------------------------------------------------------------------
1420// OffsetofExpr
[7ff3e522]1421template< typename core_t >
1422const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
[17a0228a]1423 VISIT_START( node );
1424
[e21f253]1425 if ( __visit_children() ) {
1426 {
[0e42794]1427 guard_symtab guard { *this };
[17a0228a]1428 maybe_accept( node, &OffsetofExpr::result );
1429 }
1430 maybe_accept( node, &OffsetofExpr::type );
[e21f253]1431 }
[17a0228a]1432
1433 VISIT_END( Expr, node );
1434}
1435
1436//--------------------------------------------------------------------------
1437// OffsetPackExpr
[7ff3e522]1438template< typename core_t >
1439const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
[17a0228a]1440 VISIT_START( node );
1441
[e21f253]1442 if ( __visit_children() ) {
1443 {
[0e42794]1444 guard_symtab guard { *this };
[17a0228a]1445 maybe_accept( node, &OffsetPackExpr::result );
1446 }
1447 maybe_accept( node, &OffsetPackExpr::type );
[e21f253]1448 }
[17a0228a]1449
1450 VISIT_END( Expr, node );
1451}
1452
1453//--------------------------------------------------------------------------
1454// LogicalExpr
[7ff3e522]1455template< typename core_t >
1456const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
[17a0228a]1457 VISIT_START( node );
1458
[e21f253]1459 if ( __visit_children() ) {
1460 {
[0e42794]1461 guard_symtab guard { *this };
[17a0228a]1462 maybe_accept( node, &LogicalExpr::result );
1463 }
1464 maybe_accept( node, &LogicalExpr::arg1 );
1465 maybe_accept( node, &LogicalExpr::arg2 );
[e21f253]1466 }
[17a0228a]1467
1468 VISIT_END( Expr, node );
1469}
1470
1471//--------------------------------------------------------------------------
1472// ConditionalExpr
[7ff3e522]1473template< typename core_t >
1474const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
[17a0228a]1475 VISIT_START( node );
1476
[e21f253]1477 if ( __visit_children() ) {
1478 {
[0e42794]1479 guard_symtab guard { *this };
[17a0228a]1480 maybe_accept( node, &ConditionalExpr::result );
1481 }
1482 maybe_accept( node, &ConditionalExpr::arg1 );
1483 maybe_accept( node, &ConditionalExpr::arg2 );
1484 maybe_accept( node, &ConditionalExpr::arg3 );
[e21f253]1485 }
[17a0228a]1486
1487 VISIT_END( Expr, node );
1488}
[10a1225]1489
[17a0228a]1490//--------------------------------------------------------------------------
1491// CommaExpr
[7ff3e522]1492template< typename core_t >
1493const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
[17a0228a]1494 VISIT_START( node );
1495
[e21f253]1496 if ( __visit_children() ) {
1497 {
[0e42794]1498 guard_symtab guard { *this };
[17a0228a]1499 maybe_accept( node, &CommaExpr::result );
1500 }
1501 maybe_accept( node, &CommaExpr::arg1 );
1502 maybe_accept( node, &CommaExpr::arg2 );
[e21f253]1503 }
[17a0228a]1504
1505 VISIT_END( Expr, node );
1506}
1507
1508//--------------------------------------------------------------------------
1509// TypeExpr
[7ff3e522]1510template< typename core_t >
1511const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
[17a0228a]1512 VISIT_START( node );
1513
[e21f253]1514 if ( __visit_children() ) {
1515 {
[0e42794]1516 guard_symtab guard { *this };
[17a0228a]1517 maybe_accept( node, &TypeExpr::result );
1518 }
1519 maybe_accept( node, &TypeExpr::type );
[e21f253]1520 }
[17a0228a]1521
1522 VISIT_END( Expr, node );
1523}
1524
[4ec9513]1525//--------------------------------------------------------------------------
1526// DimensionExpr
1527template< typename core_t >
1528const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
1529 VISIT_START( node );
1530
1531 if ( __visit_children() ) {
1532 guard_symtab guard { *this };
1533 maybe_accept( node, &DimensionExpr::result );
1534 }
1535
1536 VISIT_END( Expr, node );
1537}
1538
[17a0228a]1539//--------------------------------------------------------------------------
1540// AsmExpr
[7ff3e522]1541template< typename core_t >
1542const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
[17a0228a]1543 VISIT_START( node );
[10a1225]1544
[e21f253]1545 if ( __visit_children() ) {
1546 {
[0e42794]1547 guard_symtab guard { *this };
[17a0228a]1548 maybe_accept( node, &AsmExpr::result );
1549 }
1550 maybe_accept( node, &AsmExpr::constraint );
1551 maybe_accept( node, &AsmExpr::operand );
[e21f253]1552 }
[10a1225]1553
[17a0228a]1554 VISIT_END( Expr, node );
1555}
[10a1225]1556
[17a0228a]1557//--------------------------------------------------------------------------
1558// ImplicitCopyCtorExpr
[7ff3e522]1559template< typename core_t >
1560const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
[17a0228a]1561 VISIT_START( node );
1562
[e21f253]1563 if ( __visit_children() ) {
1564 {
[0e42794]1565 guard_symtab guard { *this };
[17a0228a]1566 maybe_accept( node, &ImplicitCopyCtorExpr::result );
1567 }
1568 maybe_accept( node, &ImplicitCopyCtorExpr::callExpr );
[e21f253]1569 }
[17a0228a]1570
1571 VISIT_END( Expr, node );
1572}
1573
1574//--------------------------------------------------------------------------
1575// ConstructorExpr
[7ff3e522]1576template< typename core_t >
1577const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
[17a0228a]1578 VISIT_START( node );
1579
[e21f253]1580 if ( __visit_children() ) {
1581 {
[0e42794]1582 guard_symtab guard { *this };
[17a0228a]1583 maybe_accept( node, &ConstructorExpr::result );
1584 }
1585 maybe_accept( node, &ConstructorExpr::callExpr );
[e21f253]1586 }
[10a1225]1587
[17a0228a]1588 VISIT_END( Expr, node );
1589}
1590
1591//--------------------------------------------------------------------------
1592// CompoundLiteralExpr
[7ff3e522]1593template< typename core_t >
1594const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
[17a0228a]1595 VISIT_START( node );
1596
[e21f253]1597 if ( __visit_children() ) {
1598 {
[0e42794]1599 guard_symtab guard { *this };
[17a0228a]1600 maybe_accept( node, &CompoundLiteralExpr::result );
1601 }
1602 maybe_accept( node, &CompoundLiteralExpr::init );
[e21f253]1603 }
[17a0228a]1604
1605 VISIT_END( Expr, node );
1606}
1607
1608//--------------------------------------------------------------------------
1609// RangeExpr
[7ff3e522]1610template< typename core_t >
1611const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
[17a0228a]1612 VISIT_START( node );
1613
[e21f253]1614 if ( __visit_children() ) {
1615 {
[0e42794]1616 guard_symtab guard { *this };
[17a0228a]1617 maybe_accept( node, &RangeExpr::result );
1618 }
1619 maybe_accept( node, &RangeExpr::low );
1620 maybe_accept( node, &RangeExpr::high );
[e21f253]1621 }
[17a0228a]1622
1623 VISIT_END( Expr, node );
1624}
1625
1626//--------------------------------------------------------------------------
1627// UntypedTupleExpr
[7ff3e522]1628template< typename core_t >
1629const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
[17a0228a]1630 VISIT_START( node );
1631
[e21f253]1632 if ( __visit_children() ) {
1633 {
[0e42794]1634 guard_symtab guard { *this };
[17a0228a]1635 maybe_accept( node, &UntypedTupleExpr::result );
1636 }
1637 maybe_accept( node, &UntypedTupleExpr::exprs );
[e21f253]1638 }
[17a0228a]1639
1640 VISIT_END( Expr, node );
1641}
1642
1643//--------------------------------------------------------------------------
1644// TupleExpr
[7ff3e522]1645template< typename core_t >
1646const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
[17a0228a]1647 VISIT_START( node );
1648
[e21f253]1649 if ( __visit_children() ) {
1650 {
[0e42794]1651 guard_symtab guard { *this };
[17a0228a]1652 maybe_accept( node, &TupleExpr::result );
1653 }
1654 maybe_accept( node, &TupleExpr::exprs );
[e21f253]1655 }
[17a0228a]1656
1657 VISIT_END( Expr, node );
1658}
1659
1660//--------------------------------------------------------------------------
1661// TupleIndexExpr
[7ff3e522]1662template< typename core_t >
1663const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
[17a0228a]1664 VISIT_START( node );
1665
[e21f253]1666 if ( __visit_children() ) {
1667 {
[0e42794]1668 guard_symtab guard { *this };
[17a0228a]1669 maybe_accept( node, &TupleIndexExpr::result );
1670 }
1671 maybe_accept( node, &TupleIndexExpr::tuple );
[e21f253]1672 }
[17a0228a]1673
1674 VISIT_END( Expr, node );
1675}
1676
1677//--------------------------------------------------------------------------
1678// TupleAssignExpr
[7ff3e522]1679template< typename core_t >
1680const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
[17a0228a]1681 VISIT_START( node );
1682
[e21f253]1683 if ( __visit_children() ) {
1684 {
[0e42794]1685 guard_symtab guard { *this };
[17a0228a]1686 maybe_accept( node, &TupleAssignExpr::result );
1687 }
1688 maybe_accept( node, &TupleAssignExpr::stmtExpr );
[e21f253]1689 }
[17a0228a]1690
1691 VISIT_END( Expr, node );
1692}
1693
1694//--------------------------------------------------------------------------
1695// StmtExpr
[7ff3e522]1696template< typename core_t >
1697const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
[17a0228a]1698 VISIT_START( node );
1699
[e21f253]1700 if ( __visit_children() ) {
1701 // don't want statements from outer CompoundStmts to be added to this StmtExpr
[17a0228a]1702 // get the stmts that will need to be spliced in
[7ff3e522]1703 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
1704 auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
[17a0228a]1705
1706 // These may be modified by subnode but most be restored once we exit this statemnet.
[b2a11ba]1707 ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
[17a0228a]1708 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
1709 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
1710
1711 {
[0e42794]1712 guard_symtab guard { *this };
[17a0228a]1713 maybe_accept( node, &StmtExpr::result );
1714 }
1715 maybe_accept( node, &StmtExpr::stmts );
1716 maybe_accept( node, &StmtExpr::returnDecls );
1717 maybe_accept( node, &StmtExpr::dtors );
[e21f253]1718 }
[17a0228a]1719
1720 VISIT_END( Expr, node );
1721}
1722
1723//--------------------------------------------------------------------------
1724// UniqueExpr
[7ff3e522]1725template< typename core_t >
1726const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
[17a0228a]1727 VISIT_START( node );
1728
[e21f253]1729 if ( __visit_children() ) {
1730 {
[0e42794]1731 guard_symtab guard { *this };
[17a0228a]1732 maybe_accept( node, &UniqueExpr::result );
1733 }
1734 maybe_accept( node, &UniqueExpr::expr );
[e21f253]1735 }
[17a0228a]1736
1737 VISIT_END( Expr, node );
1738}
1739
1740//--------------------------------------------------------------------------
1741// UntypedInitExpr
[7ff3e522]1742template< typename core_t >
1743const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
[17a0228a]1744 VISIT_START( node );
1745
[e21f253]1746 if ( __visit_children() ) {
1747 {
[0e42794]1748 guard_symtab guard { *this };
[17a0228a]1749 maybe_accept( node, &UntypedInitExpr::result );
1750 }
1751 maybe_accept( node, &UntypedInitExpr::expr );
1752 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
[e21f253]1753 }
[17a0228a]1754
1755 VISIT_END( Expr, node );
1756}
1757
1758//--------------------------------------------------------------------------
1759// InitExpr
[7ff3e522]1760template< typename core_t >
1761const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
[17a0228a]1762 VISIT_START( node );
1763
[e21f253]1764 if ( __visit_children() ) {
1765 {
[0e42794]1766 guard_symtab guard { *this };
[17a0228a]1767 maybe_accept( node, &InitExpr::result );
1768 }
1769 maybe_accept( node, &InitExpr::expr );
1770 maybe_accept( node, &InitExpr::designation );
[e21f253]1771 }
[17a0228a]1772
1773 VISIT_END( Expr, node );
1774}
1775
1776//--------------------------------------------------------------------------
1777// DeletedExpr
[7ff3e522]1778template< typename core_t >
1779const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
[17a0228a]1780 VISIT_START( node );
1781
[e21f253]1782 if ( __visit_children() ) {
1783 {
[0e42794]1784 guard_symtab guard { *this };
[17a0228a]1785 maybe_accept( node, &DeletedExpr::result );
1786 }
1787 maybe_accept( node, &DeletedExpr::expr );
1788 // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
[e21f253]1789 }
[17a0228a]1790
1791 VISIT_END( Expr, node );
1792}
1793
1794//--------------------------------------------------------------------------
1795// DefaultArgExpr
[7ff3e522]1796template< typename core_t >
1797const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
[17a0228a]1798 VISIT_START( node );
1799
[e21f253]1800 if ( __visit_children() ) {
1801 {
[0e42794]1802 guard_symtab guard { *this };
[17a0228a]1803 maybe_accept( node, &DefaultArgExpr::result );
1804 }
1805 maybe_accept( node, &DefaultArgExpr::expr );
[e21f253]1806 }
[17a0228a]1807
1808 VISIT_END( Expr, node );
1809}
1810
1811//--------------------------------------------------------------------------
1812// GenericExpr
[7ff3e522]1813template< typename core_t >
1814const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
[17a0228a]1815 VISIT_START( node );
1816
[e21f253]1817 if ( __visit_children() ) {
1818 {
[0e42794]1819 guard_symtab guard { *this };
[17a0228a]1820 maybe_accept( node, &GenericExpr::result );
1821 }
1822 maybe_accept( node, &GenericExpr::control );
1823
1824 std::vector<GenericExpr::Association> new_kids;
1825 new_kids.reserve(node->associations.size());
1826 bool mutated = false;
1827 for( const auto & assoc : node->associations ) {
[b0abc8a0]1828 const Type * type = nullptr;
[17a0228a]1829 if( assoc.type ) {
[0e42794]1830 guard_symtab guard { *this };
[17a0228a]1831 type = assoc.type->accept( *this );
1832 if( type != assoc.type ) mutated = true;
1833 }
[b0abc8a0]1834 const Expr * expr = nullptr;
[17a0228a]1835 if( assoc.expr ) {
1836 expr = assoc.expr->accept( *this );
1837 if( expr != assoc.expr ) mutated = true;
1838 }
1839 new_kids.emplace_back( type, expr );
1840 }
1841
1842 if(mutated) {
[d3aa64f1]1843 auto n = __pass::mutate<core_t>(node);
[17a0228a]1844 n->associations = std::move( new_kids );
1845 node = n;
1846 }
[e21f253]1847 }
[17a0228a]1848
1849 VISIT_END( Expr, node );
1850}
[10a1225]1851
[e0016a5]1852//--------------------------------------------------------------------------
1853// VoidType
[7ff3e522]1854template< typename core_t >
1855const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
[e0016a5]1856 VISIT_START( node );
[10a1225]1857
[e0016a5]1858 VISIT_END( Type, node );
1859}
[10a1225]1860
[e0016a5]1861//--------------------------------------------------------------------------
1862// BasicType
[7ff3e522]1863template< typename core_t >
1864const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
[e0016a5]1865 VISIT_START( node );
1866
1867 VISIT_END( Type, node );
1868}
1869
1870//--------------------------------------------------------------------------
1871// PointerType
[7ff3e522]1872template< typename core_t >
1873const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
[e0016a5]1874 VISIT_START( node );
1875
[e21f253]1876 if ( __visit_children() ) {
[4ec9513]1877 maybe_accept( node, &PointerType::dimension );
[e0016a5]1878 maybe_accept( node, &PointerType::base );
[e21f253]1879 }
[e0016a5]1880
1881 VISIT_END( Type, node );
1882}
1883
1884//--------------------------------------------------------------------------
1885// ArrayType
[7ff3e522]1886template< typename core_t >
1887const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
[e0016a5]1888 VISIT_START( node );
1889
[e21f253]1890 if ( __visit_children() ) {
[e0016a5]1891 maybe_accept( node, &ArrayType::dimension );
1892 maybe_accept( node, &ArrayType::base );
[e21f253]1893 }
[e0016a5]1894
1895 VISIT_END( Type, node );
1896}
1897
1898//--------------------------------------------------------------------------
1899// ReferenceType
[7ff3e522]1900template< typename core_t >
1901const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
[e0016a5]1902 VISIT_START( node );
1903
[e21f253]1904 if ( __visit_children() ) {
[e0016a5]1905 maybe_accept( node, &ReferenceType::base );
[e21f253]1906 }
[e0016a5]1907
1908 VISIT_END( Type, node );
1909}
1910
1911//--------------------------------------------------------------------------
1912// QualifiedType
[7ff3e522]1913template< typename core_t >
1914const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
[e0016a5]1915 VISIT_START( node );
1916
[e21f253]1917 if ( __visit_children() ) {
[e0016a5]1918 maybe_accept( node, &QualifiedType::parent );
1919 maybe_accept( node, &QualifiedType::child );
[e21f253]1920 }
[e0016a5]1921
1922 VISIT_END( Type, node );
1923}
1924
1925//--------------------------------------------------------------------------
1926// FunctionType
[7ff3e522]1927template< typename core_t >
1928const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
[e0016a5]1929 VISIT_START( node );
1930
[e21f253]1931 if ( __visit_children() ) {
[3e5dd913]1932 // guard_forall_subs forall_guard { *this, node };
1933 // mutate_forall( node );
1934 maybe_accept( node, &FunctionType::assertions );
[e0016a5]1935 maybe_accept( node, &FunctionType::returns );
1936 maybe_accept( node, &FunctionType::params );
[e21f253]1937 }
[e0016a5]1938
1939 VISIT_END( Type, node );
1940}
1941
1942//--------------------------------------------------------------------------
1943// StructInstType
[7ff3e522]1944template< typename core_t >
1945const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
[e0016a5]1946 VISIT_START( node );
1947
[e0069bd]1948 __pass::symtab::addStructId( core, 0, node->name );
[e0016a5]1949
[e21f253]1950 if ( __visit_children() ) {
[0e42794]1951 guard_symtab guard { *this };
[e0016a5]1952 maybe_accept( node, &StructInstType::params );
[e21f253]1953 }
[e0016a5]1954
1955 VISIT_END( Type, node );
1956}
1957
1958//--------------------------------------------------------------------------
1959// UnionInstType
[7ff3e522]1960template< typename core_t >
1961const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
[e0016a5]1962 VISIT_START( node );
1963
[e0069bd]1964 __pass::symtab::addUnionId( core, 0, node->name );
[e0016a5]1965
[e21f253]1966 if ( __visit_children() ) {
[0e42794]1967 guard_symtab guard { *this };
[e0016a5]1968 maybe_accept( node, &UnionInstType::params );
[e21f253]1969 }
[e0016a5]1970
1971 VISIT_END( Type, node );
1972}
1973
1974//--------------------------------------------------------------------------
1975// EnumInstType
[7ff3e522]1976template< typename core_t >
1977const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
[e0016a5]1978 VISIT_START( node );
1979
[e21f253]1980 if ( __visit_children() ) {
[e0016a5]1981 maybe_accept( node, &EnumInstType::params );
[e21f253]1982 }
[e0016a5]1983
1984 VISIT_END( Type, node );
1985}
1986
[0522ebe]1987//--------------------------------------------------------------------------
1988// EnumPosType
1989template< typename core_t >
1990const ast::Type * ast::Pass< core_t >::visit( const ast::EnumPosType * node ) {
1991 VISIT_START( node );
1992
1993 VISIT_END( Type, node );
1994}
1995
[e0016a5]1996//--------------------------------------------------------------------------
1997// TraitInstType
[7ff3e522]1998template< typename core_t >
1999const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
[e0016a5]2000 VISIT_START( node );
2001
[e21f253]2002 if ( __visit_children() ) {
[e0016a5]2003 maybe_accept( node, &TraitInstType::params );
[e21f253]2004 }
[e0016a5]2005
2006 VISIT_END( Type, node );
2007}
2008
2009//--------------------------------------------------------------------------
2010// TypeInstType
[7ff3e522]2011template< typename core_t >
2012const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
[e0016a5]2013 VISIT_START( node );
2014
[e21f253]2015 if ( __visit_children() ) {
[e0e9a0b]2016 {
2017 maybe_accept( node, &TypeInstType::params );
2018 }
2019 // ensure that base re-bound if doing substitution
[7ff3e522]2020 __pass::forall::replace( core, 0, node );
[e21f253]2021 }
[e0016a5]2022
2023 VISIT_END( Type, node );
2024}
2025
2026//--------------------------------------------------------------------------
2027// TupleType
[7ff3e522]2028template< typename core_t >
2029const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
[e0016a5]2030 VISIT_START( node );
2031
[e21f253]2032 if ( __visit_children() ) {
[e0016a5]2033 maybe_accept( node, &TupleType::types );
[e21f253]2034 }
[e0016a5]2035
2036 VISIT_END( Type, node );
2037}
2038
2039//--------------------------------------------------------------------------
2040// TypeofType
[7ff3e522]2041template< typename core_t >
2042const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
[e0016a5]2043 VISIT_START( node );
2044
[e21f253]2045 if ( __visit_children() ) {
[e0016a5]2046 maybe_accept( node, &TypeofType::expr );
[e21f253]2047 }
[e0016a5]2048
2049 VISIT_END( Type, node );
2050}
2051
[3945abe]2052//--------------------------------------------------------------------------
2053// VTableType
2054template< typename core_t >
2055const ast::Type * ast::Pass< core_t >::visit( const ast::VTableType * node ) {
2056 VISIT_START( node );
2057
[e21f253]2058 if ( __visit_children() ) {
[3945abe]2059 maybe_accept( node, &VTableType::base );
[e21f253]2060 }
[3945abe]2061
2062 VISIT_END( Type, node );
2063}
2064
[e0016a5]2065//--------------------------------------------------------------------------
2066// VarArgsType
[7ff3e522]2067template< typename core_t >
2068const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
[e0016a5]2069 VISIT_START( node );
2070
2071 VISIT_END( Type, node );
2072}
2073
2074//--------------------------------------------------------------------------
2075// ZeroType
[7ff3e522]2076template< typename core_t >
2077const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
[e0016a5]2078 VISIT_START( node );
2079
2080 VISIT_END( Type, node );
2081}
2082
2083//--------------------------------------------------------------------------
2084// OneType
[7ff3e522]2085template< typename core_t >
2086const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
[e0016a5]2087 VISIT_START( node );
2088
2089 VISIT_END( Type, node );
2090}
2091
2092//--------------------------------------------------------------------------
2093// GlobalScopeType
[7ff3e522]2094template< typename core_t >
2095const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
[e0016a5]2096 VISIT_START( node );
2097
2098 VISIT_END( Type, node );
2099}
2100
2101
2102//--------------------------------------------------------------------------
2103// Designation
[7ff3e522]2104template< typename core_t >
2105const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
[e0016a5]2106 VISIT_START( node );
2107
[e21f253]2108 if ( __visit_children() ) {
2109 maybe_accept( node, &Designation::designators );
2110 }
[e0016a5]2111
2112 VISIT_END( Designation, node );
2113}
[10a1225]2114
[6d51bd7]2115//--------------------------------------------------------------------------
2116// SingleInit
[7ff3e522]2117template< typename core_t >
2118const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
[6d51bd7]2119 VISIT_START( node );
2120
[e21f253]2121 if ( __visit_children() ) {
[9e23b446]2122 maybe_accept_top( node, &SingleInit::value );
[e21f253]2123 }
[6d51bd7]2124
2125 VISIT_END( Init, node );
2126}
2127
2128//--------------------------------------------------------------------------
2129// ListInit
[7ff3e522]2130template< typename core_t >
2131const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
[6d51bd7]2132 VISIT_START( node );
2133
[e21f253]2134 if ( __visit_children() ) {
[6d51bd7]2135 maybe_accept( node, &ListInit::designations );
2136 maybe_accept( node, &ListInit::initializers );
[e21f253]2137 }
[6d51bd7]2138
2139 VISIT_END( Init, node );
2140}
2141
2142//--------------------------------------------------------------------------
2143// ConstructorInit
[7ff3e522]2144template< typename core_t >
2145const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
[6d51bd7]2146 VISIT_START( node );
2147
[e21f253]2148 if ( __visit_children() ) {
[6d51bd7]2149 maybe_accept( node, &ConstructorInit::ctor );
2150 maybe_accept( node, &ConstructorInit::dtor );
2151 maybe_accept( node, &ConstructorInit::init );
[e21f253]2152 }
[6d51bd7]2153
2154 VISIT_END( Init, node );
2155}
2156
[f47f887]2157//--------------------------------------------------------------------------
2158// Attribute
[7ff3e522]2159template< typename core_t >
2160const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) {
[6d51bd7]2161 VISIT_START( node );
[f47f887]2162
[e21f253]2163 if ( __visit_children() ) {
[489bacf]2164 maybe_accept( node, &Attribute::params );
[e21f253]2165 }
[f47f887]2166
[8a5530c]2167 VISIT_END( Attribute, node );
[f47f887]2168}
2169
2170//--------------------------------------------------------------------------
2171// TypeSubstitution
[7ff3e522]2172template< typename core_t >
2173const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
[6d51bd7]2174 VISIT_START( node );
[f47f887]2175
[e21f253]2176 if ( __visit_children() ) {
[8631c84]2177 bool mutated = false;
[a8b87d3]2178 ast::TypeSubstitution::TypeMap new_map;
2179 for ( const auto & p : node->typeMap ) {
[8631c84]2180 guard_symtab guard { *this };
2181 auto new_node = p.second->accept( *this );
2182 if (new_node != p.second) mutated = true;
2183 new_map.insert({ p.first, new_node });
2184 }
2185 if (mutated) {
2186 auto new_node = __pass::mutate<core_t>( node );
[a8b87d3]2187 new_node->typeMap.swap( new_map );
[8631c84]2188 node = new_node;
[6d51bd7]2189 }
[e21f253]2190 }
[f47f887]2191
[6d51bd7]2192 VISIT_END( TypeSubstitution, node );
[f47f887]2193}
2194
[2d0f918]2195#undef __pedantic_pass_assertf
2196#undef __pedantic_pass_assert
[f47f887]2197#undef VISIT_START
[112fe04]2198#undef VISIT_END
Note: See TracBrowser for help on using the repository browser.