source: src/AST/Pass.impl.hpp @ 4eebbcc

ADTast-experimental
Last change on this file since 4eebbcc was 8f06277, checked in by Andrew Beach <ajbeach@…>, 21 months ago

Some clean-up in Common/utility.h. Deleted some unused declarations and moved others to one of two new headers.

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