source: src/AST/Pass.impl.hpp @ 293dc1c

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 293dc1c was 293dc1c, checked in by Andrew Beach <ajbeach@…>, 13 months ago

TranslationUnit? is now used at the top-level of the new-ast passes.

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