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

ADTast-experimentalpthread-emulationqualifiedEnum
Last change on this file since 1df492a was 1df492a, checked in by JiadaL <j82liang@…>, 22 months ago

Convert TypeInstType? to PointerType? before resolution

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