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

Last change on this file since c1e66d9 was c1e66d9, checked in by JiadaL <j82liang@…>, 5 months ago

Fix designator value in enumerated array and implemented enumerated array with inlined enume declaration

  • Property mode set to 100644
File size: 63.4 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// ApplicationExpr
1124template< typename core_t >
1125const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
1126        VISIT_START( node );
1127
1128        if ( __visit_children() ) {
1129                {
1130                        guard_symtab guard { *this };
1131                        maybe_accept( node, &ApplicationExpr::result );
1132                }
1133                maybe_accept( node, &ApplicationExpr::func );
1134                maybe_accept( node, &ApplicationExpr::args );
1135        }
1136
1137        VISIT_END( Expr, node );
1138}
1139
1140//--------------------------------------------------------------------------
1141// UntypedExpr
1142template< typename core_t >
1143const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
1144        VISIT_START( node );
1145
1146        if ( __visit_children() ) {
1147                {
1148                        guard_symtab guard { *this };
1149                        maybe_accept( node, &UntypedExpr::result );
1150                }
1151
1152                maybe_accept( node, &UntypedExpr::args );
1153        }
1154
1155        VISIT_END( Expr, node );
1156}
1157
1158//--------------------------------------------------------------------------
1159// NameExpr
1160template< typename core_t >
1161const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
1162        VISIT_START( node );
1163
1164        if ( __visit_children() ) {
1165                guard_symtab guard { *this };
1166                maybe_accept( node, &NameExpr::result );
1167        }
1168
1169        VISIT_END( Expr, node );
1170}
1171
1172//--------------------------------------------------------------------------
1173// QualifiedNameExpr
1174template< typename core_t >
1175const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
1176        VISIT_START( node );
1177        if ( __visit_children() ) {
1178                guard_symtab guard { *this };
1179                maybe_accept( node, &QualifiedNameExpr::type_decl );
1180        }
1181        VISIT_END( Expr, node );
1182}
1183
1184//--------------------------------------------------------------------------
1185// CastExpr
1186template< typename core_t >
1187const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
1188        VISIT_START( node );
1189
1190        if ( __visit_children() ) {
1191                {
1192                        guard_symtab guard { *this };
1193                        maybe_accept( node, &CastExpr::result );
1194                }
1195                maybe_accept( node, &CastExpr::arg );
1196        }
1197
1198        VISIT_END( Expr, node );
1199}
1200
1201//--------------------------------------------------------------------------
1202// KeywordCastExpr
1203template< typename core_t >
1204const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
1205        VISIT_START( node );
1206
1207        if ( __visit_children() ) {
1208                {
1209                        guard_symtab guard { *this };
1210                        maybe_accept( node, &KeywordCastExpr::result );
1211                }
1212                maybe_accept( node, &KeywordCastExpr::arg );
1213        }
1214
1215        VISIT_END( Expr, node );
1216}
1217
1218//--------------------------------------------------------------------------
1219// VirtualCastExpr
1220template< typename core_t >
1221const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
1222        VISIT_START( node );
1223
1224        if ( __visit_children() ) {
1225                {
1226                        guard_symtab guard { *this };
1227                        maybe_accept( node, &VirtualCastExpr::result );
1228                }
1229                maybe_accept( node, &VirtualCastExpr::arg );
1230        }
1231
1232        VISIT_END( Expr, node );
1233}
1234
1235//--------------------------------------------------------------------------
1236// AddressExpr
1237template< typename core_t >
1238const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
1239        VISIT_START( node );
1240
1241        if ( __visit_children() ) {
1242                {
1243                        guard_symtab guard { *this };
1244                        maybe_accept( node, &AddressExpr::result );
1245                }
1246                maybe_accept( node, &AddressExpr::arg );
1247        }
1248
1249        VISIT_END( Expr, node );
1250}
1251
1252//--------------------------------------------------------------------------
1253// LabelAddressExpr
1254template< typename core_t >
1255const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
1256        VISIT_START( node );
1257
1258        if ( __visit_children() ) {
1259                guard_symtab guard { *this };
1260                maybe_accept( node, &LabelAddressExpr::result );
1261        }
1262
1263        VISIT_END( Expr, node );
1264}
1265
1266//--------------------------------------------------------------------------
1267// UntypedMemberExpr
1268template< typename core_t >
1269const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
1270        VISIT_START( node );
1271
1272        if ( __visit_children() ) {
1273                {
1274                        guard_symtab guard { *this };
1275                        maybe_accept( node, &UntypedMemberExpr::result );
1276                }
1277                maybe_accept( node, &UntypedMemberExpr::aggregate );
1278                maybe_accept( node, &UntypedMemberExpr::member    );
1279        }
1280
1281        VISIT_END( Expr, node );
1282}
1283
1284//--------------------------------------------------------------------------
1285// MemberExpr
1286template< typename core_t >
1287const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
1288        VISIT_START( node );
1289
1290        if ( __visit_children() ) {
1291                {
1292                        guard_symtab guard { *this };
1293                        maybe_accept( node, &MemberExpr::result );
1294                }
1295                maybe_accept( node, &MemberExpr::aggregate );
1296        }
1297
1298        VISIT_END( Expr, node );
1299}
1300
1301//--------------------------------------------------------------------------
1302// VariableExpr
1303template< typename core_t >
1304const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
1305        VISIT_START( node );
1306
1307        if ( __visit_children() ) {
1308                guard_symtab guard { *this };
1309                maybe_accept( node, &VariableExpr::result );
1310        }
1311
1312        VISIT_END( Expr, node );
1313}
1314
1315//--------------------------------------------------------------------------
1316// ConstantExpr
1317template< typename core_t >
1318const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
1319        VISIT_START( node );
1320
1321        if ( __visit_children() ) {
1322                guard_symtab guard { *this };
1323                maybe_accept( node, &ConstantExpr::result );
1324        }
1325
1326        VISIT_END( Expr, node );
1327}
1328
1329//--------------------------------------------------------------------------
1330// SizeofExpr
1331template< typename core_t >
1332const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
1333        VISIT_START( node );
1334
1335        if ( __visit_children() ) {
1336                {
1337                        guard_symtab guard { *this };
1338                        maybe_accept( node, &SizeofExpr::result );
1339                }
1340                if ( node->type ) {
1341                        maybe_accept( node, &SizeofExpr::type );
1342                } else {
1343                        maybe_accept( node, &SizeofExpr::expr );
1344                }
1345        }
1346
1347        VISIT_END( Expr, node );
1348}
1349
1350//--------------------------------------------------------------------------
1351// AlignofExpr
1352template< typename core_t >
1353const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
1354        VISIT_START( node );
1355
1356        if ( __visit_children() ) {
1357                {
1358                        guard_symtab guard { *this };
1359                        maybe_accept( node, &AlignofExpr::result );
1360                }
1361                if ( node->type ) {
1362                        maybe_accept( node, &AlignofExpr::type );
1363                } else {
1364                        maybe_accept( node, &AlignofExpr::expr );
1365                }
1366        }
1367
1368        VISIT_END( Expr, node );
1369}
1370
1371//--------------------------------------------------------------------------
1372// UntypedOffsetofExpr
1373template< typename core_t >
1374const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
1375        VISIT_START( node );
1376
1377        if ( __visit_children() ) {
1378                {
1379                        guard_symtab guard { *this };
1380                        maybe_accept( node, &UntypedOffsetofExpr::result );
1381                }
1382                maybe_accept( node, &UntypedOffsetofExpr::type   );
1383        }
1384
1385        VISIT_END( Expr, node );
1386}
1387
1388//--------------------------------------------------------------------------
1389// OffsetofExpr
1390template< typename core_t >
1391const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
1392        VISIT_START( node );
1393
1394        if ( __visit_children() ) {
1395                {
1396                        guard_symtab guard { *this };
1397                        maybe_accept( node, &OffsetofExpr::result );
1398                }
1399                maybe_accept( node, &OffsetofExpr::type   );
1400        }
1401
1402        VISIT_END( Expr, node );
1403}
1404
1405//--------------------------------------------------------------------------
1406// OffsetPackExpr
1407template< typename core_t >
1408const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
1409        VISIT_START( node );
1410
1411        if ( __visit_children() ) {
1412                {
1413                        guard_symtab guard { *this };
1414                        maybe_accept( node, &OffsetPackExpr::result );
1415                }
1416                maybe_accept( node, &OffsetPackExpr::type   );
1417        }
1418
1419        VISIT_END( Expr, node );
1420}
1421
1422//--------------------------------------------------------------------------
1423// LogicalExpr
1424template< typename core_t >
1425const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
1426        VISIT_START( node );
1427
1428        if ( __visit_children() ) {
1429                {
1430                        guard_symtab guard { *this };
1431                        maybe_accept( node, &LogicalExpr::result );
1432                }
1433                maybe_accept( node, &LogicalExpr::arg1 );
1434                maybe_accept( node, &LogicalExpr::arg2 );
1435        }
1436
1437        VISIT_END( Expr, node );
1438}
1439
1440//--------------------------------------------------------------------------
1441// ConditionalExpr
1442template< typename core_t >
1443const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
1444        VISIT_START( node );
1445
1446        if ( __visit_children() ) {
1447                {
1448                        guard_symtab guard { *this };
1449                        maybe_accept( node, &ConditionalExpr::result );
1450                }
1451                maybe_accept( node, &ConditionalExpr::arg1 );
1452                maybe_accept( node, &ConditionalExpr::arg2 );
1453                maybe_accept( node, &ConditionalExpr::arg3 );
1454        }
1455
1456        VISIT_END( Expr, node );
1457}
1458
1459//--------------------------------------------------------------------------
1460// CommaExpr
1461template< typename core_t >
1462const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
1463        VISIT_START( node );
1464
1465        if ( __visit_children() ) {
1466                {
1467                        guard_symtab guard { *this };
1468                        maybe_accept( node, &CommaExpr::result );
1469                }
1470                maybe_accept( node, &CommaExpr::arg1 );
1471                maybe_accept( node, &CommaExpr::arg2 );
1472        }
1473
1474        VISIT_END( Expr, node );
1475}
1476
1477//--------------------------------------------------------------------------
1478// TypeExpr
1479template< typename core_t >
1480const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
1481        VISIT_START( node );
1482
1483        if ( __visit_children() ) {
1484                {
1485                        guard_symtab guard { *this };
1486                        maybe_accept( node, &TypeExpr::result );
1487                }
1488                maybe_accept( node, &TypeExpr::type );
1489        }
1490
1491        VISIT_END( Expr, node );
1492}
1493
1494//--------------------------------------------------------------------------
1495// DimensionExpr
1496template< typename core_t >
1497const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
1498        VISIT_START( node );
1499
1500        if ( __visit_children() ) {
1501                guard_symtab guard { *this };
1502                maybe_accept( node, &DimensionExpr::result );
1503        }
1504
1505        VISIT_END( Expr, node );
1506}
1507
1508//--------------------------------------------------------------------------
1509// AsmExpr
1510template< typename core_t >
1511const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
1512        VISIT_START( node );
1513
1514        if ( __visit_children() ) {
1515                {
1516                        guard_symtab guard { *this };
1517                        maybe_accept( node, &AsmExpr::result );
1518                }
1519                maybe_accept( node, &AsmExpr::constraint );
1520                maybe_accept( node, &AsmExpr::operand    );
1521        }
1522
1523        VISIT_END( Expr, node );
1524}
1525
1526//--------------------------------------------------------------------------
1527// ImplicitCopyCtorExpr
1528template< typename core_t >
1529const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
1530        VISIT_START( node );
1531
1532        if ( __visit_children() ) {
1533                {
1534                        guard_symtab guard { *this };
1535                        maybe_accept( node, &ImplicitCopyCtorExpr::result );
1536                }
1537                maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
1538        }
1539
1540        VISIT_END( Expr, node );
1541}
1542
1543//--------------------------------------------------------------------------
1544// ConstructorExpr
1545template< typename core_t >
1546const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
1547        VISIT_START( node );
1548
1549        if ( __visit_children() ) {
1550                {
1551                        guard_symtab guard { *this };
1552                        maybe_accept( node, &ConstructorExpr::result );
1553                }
1554                maybe_accept( node, &ConstructorExpr::callExpr );
1555        }
1556
1557        VISIT_END( Expr, node );
1558}
1559
1560//--------------------------------------------------------------------------
1561// CompoundLiteralExpr
1562template< typename core_t >
1563const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
1564        VISIT_START( node );
1565
1566        if ( __visit_children() ) {
1567                {
1568                        guard_symtab guard { *this };
1569                        maybe_accept( node, &CompoundLiteralExpr::result );
1570                }
1571                maybe_accept( node, &CompoundLiteralExpr::init );
1572        }
1573
1574        VISIT_END( Expr, node );
1575}
1576
1577//--------------------------------------------------------------------------
1578// RangeExpr
1579template< typename core_t >
1580const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
1581        VISIT_START( node );
1582
1583        if ( __visit_children() ) {
1584                {
1585                        guard_symtab guard { *this };
1586                        maybe_accept( node, &RangeExpr::result );
1587                }
1588                maybe_accept( node, &RangeExpr::low    );
1589                maybe_accept( node, &RangeExpr::high   );
1590        }
1591
1592        VISIT_END( Expr, node );
1593}
1594
1595//--------------------------------------------------------------------------
1596// UntypedTupleExpr
1597template< typename core_t >
1598const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
1599        VISIT_START( node );
1600
1601        if ( __visit_children() ) {
1602                {
1603                        guard_symtab guard { *this };
1604                        maybe_accept( node, &UntypedTupleExpr::result );
1605                }
1606                maybe_accept( node, &UntypedTupleExpr::exprs  );
1607        }
1608
1609        VISIT_END( Expr, node );
1610}
1611
1612//--------------------------------------------------------------------------
1613// TupleExpr
1614template< typename core_t >
1615const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
1616        VISIT_START( node );
1617
1618        if ( __visit_children() ) {
1619                {
1620                        guard_symtab guard { *this };
1621                        maybe_accept( node, &TupleExpr::result );
1622                }
1623                maybe_accept( node, &TupleExpr::exprs  );
1624        }
1625
1626        VISIT_END( Expr, node );
1627}
1628
1629//--------------------------------------------------------------------------
1630// TupleIndexExpr
1631template< typename core_t >
1632const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
1633        VISIT_START( node );
1634
1635        if ( __visit_children() ) {
1636                {
1637                        guard_symtab guard { *this };
1638                        maybe_accept( node, &TupleIndexExpr::result );
1639                }
1640                maybe_accept( node, &TupleIndexExpr::tuple  );
1641        }
1642
1643        VISIT_END( Expr, node );
1644}
1645
1646//--------------------------------------------------------------------------
1647// TupleAssignExpr
1648template< typename core_t >
1649const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
1650        VISIT_START( node );
1651
1652        if ( __visit_children() ) {
1653                {
1654                        guard_symtab guard { *this };
1655                        maybe_accept( node, &TupleAssignExpr::result );
1656                }
1657                maybe_accept( node, &TupleAssignExpr::stmtExpr );
1658        }
1659
1660        VISIT_END( Expr, node );
1661}
1662
1663//--------------------------------------------------------------------------
1664// StmtExpr
1665template< typename core_t >
1666const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
1667        VISIT_START( node );
1668
1669        if ( __visit_children() ) {
1670                // don't want statements from outer CompoundStmts to be added to this StmtExpr
1671                // get the stmts that will need to be spliced in
1672                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
1673                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
1674
1675                // These may be modified by subnode but most be restored once we exit this statemnet.
1676                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
1677                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
1678                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
1679
1680                {
1681                        guard_symtab guard { *this };
1682                        maybe_accept( node, &StmtExpr::result );
1683                }
1684                maybe_accept( node, &StmtExpr::stmts       );
1685                maybe_accept( node, &StmtExpr::returnDecls );
1686                maybe_accept( node, &StmtExpr::dtors       );
1687        }
1688
1689        VISIT_END( Expr, node );
1690}
1691
1692//--------------------------------------------------------------------------
1693// UniqueExpr
1694template< typename core_t >
1695const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
1696        VISIT_START( node );
1697
1698        if ( __visit_children() ) {
1699                {
1700                        guard_symtab guard { *this };
1701                        maybe_accept( node, &UniqueExpr::result );
1702                }
1703                maybe_accept( node, &UniqueExpr::expr   );
1704        }
1705
1706        VISIT_END( Expr, node );
1707}
1708
1709//--------------------------------------------------------------------------
1710// UntypedInitExpr
1711template< typename core_t >
1712const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
1713        VISIT_START( node );
1714
1715        if ( __visit_children() ) {
1716                {
1717                        guard_symtab guard { *this };
1718                        maybe_accept( node, &UntypedInitExpr::result );
1719                }
1720                maybe_accept( node, &UntypedInitExpr::expr   );
1721                // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
1722        }
1723
1724        VISIT_END( Expr, node );
1725}
1726
1727//--------------------------------------------------------------------------
1728// InitExpr
1729template< typename core_t >
1730const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
1731        VISIT_START( node );
1732
1733        if ( __visit_children() ) {
1734                {
1735                        guard_symtab guard { *this };
1736                        maybe_accept( node, &InitExpr::result );
1737                }
1738                maybe_accept( node, &InitExpr::expr   );
1739                maybe_accept( node, &InitExpr::designation );
1740        }
1741
1742        VISIT_END( Expr, node );
1743}
1744
1745//--------------------------------------------------------------------------
1746// DeletedExpr
1747template< typename core_t >
1748const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
1749        VISIT_START( node );
1750
1751        if ( __visit_children() ) {
1752                {
1753                        guard_symtab guard { *this };
1754                        maybe_accept( node, &DeletedExpr::result );
1755                }
1756                maybe_accept( node, &DeletedExpr::expr );
1757                // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
1758        }
1759
1760        VISIT_END( Expr, node );
1761}
1762
1763//--------------------------------------------------------------------------
1764// DefaultArgExpr
1765template< typename core_t >
1766const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
1767        VISIT_START( node );
1768
1769        if ( __visit_children() ) {
1770                {
1771                        guard_symtab guard { *this };
1772                        maybe_accept( node, &DefaultArgExpr::result );
1773                }
1774                maybe_accept( node, &DefaultArgExpr::expr );
1775        }
1776
1777        VISIT_END( Expr, node );
1778}
1779
1780//--------------------------------------------------------------------------
1781// GenericExpr
1782template< typename core_t >
1783const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
1784        VISIT_START( node );
1785
1786        if ( __visit_children() ) {
1787                {
1788                        guard_symtab guard { *this };
1789                        maybe_accept( node, &GenericExpr::result );
1790                }
1791                maybe_accept( node, &GenericExpr::control );
1792
1793                std::vector<GenericExpr::Association> new_kids;
1794                new_kids.reserve(node->associations.size());
1795                bool mutated = false;
1796                for( const auto & assoc : node->associations ) {
1797                        const Type * type = nullptr;
1798                        if( assoc.type ) {
1799                                guard_symtab guard { *this };
1800                                type = assoc.type->accept( *this );
1801                                if( type != assoc.type ) mutated = true;
1802                        }
1803                        const Expr * expr = nullptr;
1804                        if( assoc.expr ) {
1805                                expr = assoc.expr->accept( *this );
1806                                if( expr != assoc.expr ) mutated = true;
1807                        }
1808                        new_kids.emplace_back( type, expr );
1809                }
1810
1811                if(mutated) {
1812                        auto n = __pass::mutate<core_t>(node);
1813                        n->associations = std::move( new_kids );
1814                        node = n;
1815                }
1816        }
1817
1818        VISIT_END( Expr, node );
1819}
1820
1821//--------------------------------------------------------------------------
1822// VoidType
1823template< typename core_t >
1824const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
1825        VISIT_START( node );
1826
1827        VISIT_END( Type, node );
1828}
1829
1830//--------------------------------------------------------------------------
1831// BasicType
1832template< typename core_t >
1833const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
1834        VISIT_START( node );
1835
1836        VISIT_END( Type, node );
1837}
1838
1839//--------------------------------------------------------------------------
1840// PointerType
1841template< typename core_t >
1842const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
1843        VISIT_START( node );
1844
1845        if ( __visit_children() ) {
1846                maybe_accept( node, &PointerType::dimension );
1847                maybe_accept( node, &PointerType::base );
1848        }
1849
1850        VISIT_END( Type, node );
1851}
1852
1853//--------------------------------------------------------------------------
1854// ArrayType
1855template< typename core_t >
1856const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
1857        VISIT_START( node );
1858
1859        if ( __visit_children() ) {
1860                maybe_accept( node, &ArrayType::dimension );
1861                maybe_accept( node, &ArrayType::base );
1862                maybe_accept( node, &ArrayType::declaredType );
1863        }
1864
1865        VISIT_END( Type, node );
1866}
1867
1868//--------------------------------------------------------------------------
1869// ReferenceType
1870template< typename core_t >
1871const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
1872        VISIT_START( node );
1873
1874        if ( __visit_children() ) {
1875                maybe_accept( node, &ReferenceType::base );
1876        }
1877
1878        VISIT_END( Type, node );
1879}
1880
1881//--------------------------------------------------------------------------
1882// QualifiedType
1883template< typename core_t >
1884const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
1885        VISIT_START( node );
1886
1887        if ( __visit_children() ) {
1888                maybe_accept( node, &QualifiedType::parent );
1889                maybe_accept( node, &QualifiedType::child );
1890        }
1891
1892        VISIT_END( Type, node );
1893}
1894
1895//--------------------------------------------------------------------------
1896// FunctionType
1897template< typename core_t >
1898const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
1899        VISIT_START( node );
1900
1901        if ( __visit_children() ) {
1902                // guard_forall_subs forall_guard { *this, node };
1903                // mutate_forall( node );
1904                maybe_accept( node, &FunctionType::assertions );
1905                maybe_accept( node, &FunctionType::returns );
1906                maybe_accept( node, &FunctionType::params  );
1907        }
1908
1909        VISIT_END( Type, node );
1910}
1911
1912//--------------------------------------------------------------------------
1913// StructInstType
1914template< typename core_t >
1915const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
1916        VISIT_START( node );
1917
1918        __pass::symtab::addStructId( core, 0, node->name );
1919
1920        if ( __visit_children() ) {
1921                guard_symtab guard { *this };
1922                maybe_accept( node, &StructInstType::params );
1923        }
1924
1925        VISIT_END( Type, node );
1926}
1927
1928//--------------------------------------------------------------------------
1929// UnionInstType
1930template< typename core_t >
1931const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
1932        VISIT_START( node );
1933
1934        __pass::symtab::addUnionId( core, 0, node->name );
1935
1936        if ( __visit_children() ) {
1937                guard_symtab guard { *this };
1938                maybe_accept( node, &UnionInstType::params );
1939        }
1940
1941        VISIT_END( Type, node );
1942}
1943
1944//--------------------------------------------------------------------------
1945// EnumInstType
1946template< typename core_t >
1947const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
1948        VISIT_START( node );
1949
1950        if ( __visit_children() ) {
1951                maybe_accept( node, &EnumInstType::params );
1952        }
1953
1954        VISIT_END( Type, node );
1955}
1956
1957//--------------------------------------------------------------------------
1958// TraitInstType
1959template< typename core_t >
1960const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
1961        VISIT_START( node );
1962
1963        if ( __visit_children() ) {
1964                maybe_accept( node, &TraitInstType::params );
1965        }
1966
1967        VISIT_END( Type, node );
1968}
1969
1970//--------------------------------------------------------------------------
1971// TypeInstType
1972template< typename core_t >
1973const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
1974        VISIT_START( node );
1975
1976        if ( __visit_children() ) {
1977                {
1978                        maybe_accept( node, &TypeInstType::params );
1979                }
1980                // ensure that base re-bound if doing substitution
1981                __pass::forall::replace( core, 0, node );
1982        }
1983
1984        VISIT_END( Type, node );
1985}
1986
1987//--------------------------------------------------------------------------
1988// TupleType
1989template< typename core_t >
1990const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
1991        VISIT_START( node );
1992
1993        if ( __visit_children() ) {
1994                maybe_accept( node, &TupleType::types );
1995        }
1996
1997        VISIT_END( Type, node );
1998}
1999
2000//--------------------------------------------------------------------------
2001// TypeofType
2002template< typename core_t >
2003const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
2004        VISIT_START( node );
2005
2006        if ( __visit_children() ) {
2007                maybe_accept( node, &TypeofType::expr );
2008        }
2009
2010        VISIT_END( Type, node );
2011}
2012
2013//--------------------------------------------------------------------------
2014// VTableType
2015template< typename core_t >
2016const ast::Type * ast::Pass< core_t >::visit( const ast::VTableType * node ) {
2017        VISIT_START( node );
2018
2019        if ( __visit_children() ) {
2020                maybe_accept( node, &VTableType::base );
2021        }
2022
2023        VISIT_END( Type, node );
2024}
2025
2026//--------------------------------------------------------------------------
2027// VarArgsType
2028template< typename core_t >
2029const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
2030        VISIT_START( node );
2031
2032        VISIT_END( Type, node );
2033}
2034
2035//--------------------------------------------------------------------------
2036// ZeroType
2037template< typename core_t >
2038const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
2039        VISIT_START( node );
2040
2041        VISIT_END( Type, node );
2042}
2043
2044//--------------------------------------------------------------------------
2045// OneType
2046template< typename core_t >
2047const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
2048        VISIT_START( node );
2049
2050        VISIT_END( Type, node );
2051}
2052
2053//--------------------------------------------------------------------------
2054// GlobalScopeType
2055template< typename core_t >
2056const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
2057        VISIT_START( node );
2058
2059        VISIT_END( Type, node );
2060}
2061
2062
2063//--------------------------------------------------------------------------
2064// Designation
2065template< typename core_t >
2066const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
2067        VISIT_START( node );
2068
2069        if ( __visit_children() ) {
2070                maybe_accept( node, &Designation::designators );
2071        }
2072
2073        VISIT_END( Designation, node );
2074}
2075
2076//--------------------------------------------------------------------------
2077// SingleInit
2078template< typename core_t >
2079const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
2080        VISIT_START( node );
2081
2082        if ( __visit_children() ) {
2083                maybe_accept_top( node, &SingleInit::value );
2084        }
2085
2086        VISIT_END( Init, node );
2087}
2088
2089//--------------------------------------------------------------------------
2090// ListInit
2091template< typename core_t >
2092const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
2093        VISIT_START( node );
2094
2095        if ( __visit_children() ) {
2096                maybe_accept( node, &ListInit::designations );
2097                maybe_accept( node, &ListInit::initializers );
2098        }
2099
2100        VISIT_END( Init, node );
2101}
2102
2103//--------------------------------------------------------------------------
2104// ConstructorInit
2105template< typename core_t >
2106const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
2107        VISIT_START( node );
2108
2109        if ( __visit_children() ) {
2110                maybe_accept( node, &ConstructorInit::ctor );
2111                maybe_accept( node, &ConstructorInit::dtor );
2112                maybe_accept( node, &ConstructorInit::init );
2113        }
2114
2115        VISIT_END( Init, node );
2116}
2117
2118//--------------------------------------------------------------------------
2119// Attribute
2120template< typename core_t >
2121const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node  )  {
2122        VISIT_START( node );
2123
2124        if ( __visit_children() ) {
2125                maybe_accept( node, &Attribute::params );
2126        }
2127
2128        VISIT_END( Attribute, node );
2129}
2130
2131//--------------------------------------------------------------------------
2132// TypeSubstitution
2133template< typename core_t >
2134const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
2135        VISIT_START( node );
2136
2137        if ( __visit_children() ) {
2138                bool mutated = false;
2139                ast::TypeSubstitution::TypeMap new_map;
2140                for ( const auto & p : node->typeMap ) {
2141                        guard_symtab guard { *this };
2142                        auto new_node = p.second->accept( *this );
2143                        if (new_node != p.second) mutated = true;
2144                        new_map.insert({ p.first, new_node });
2145                }
2146                if (mutated) {
2147                        auto new_node = __pass::mutate<core_t>( node );
2148                        new_node->typeMap.swap( new_map );
2149                        node = new_node;
2150                }
2151        }
2152
2153        VISIT_END( TypeSubstitution, node );
2154}
2155
2156#undef __pedantic_pass_assertf
2157#undef __pedantic_pass_assert
2158#undef VISIT_START
2159#undef VISIT_END
Note: See TracBrowser for help on using the repository browser.