source: src/AST/Pass.impl.hpp @ 7cf8006

ADTast-experimental
Last change on this file since 7cf8006 was f2ff0a6, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Function attributes are now visited earlier, so they are not considered to be within the function/function's body.

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