source: src/AST/Pass.impl.hpp @ 0c327ce

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