source: src/Common/PassVisitor.impl.h @ 6a625de

arm-ehcleanup-dtorsenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 6a625de was 6a625de, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Some clean-up, some more assertions to check assumptions and changes to node.hpp

  • Property mode set to 100644
File size: 79.6 KB
Line 
1#pragma once
2// IWYU pragma: private, include "PassVisitor.h"
3
4#define VISIT_START( node )                                     \
5        __attribute__((unused))                                   \
6        ChildrenGuard children_guard( get_visit_children_ptr() ); \
7        __attribute__((unused))                                   \
8        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
9        call_previsit( node );                                    \
10
11#define VISIT_END( node )                       \
12        call_postvisit( node );                   \
13
14#define MUTATE_START( node )                                    \
15        __attribute__((unused))                                   \
16        ChildrenGuard children_guard( get_visit_children_ptr() ); \
17        __attribute__((unused))                                   \
18        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
19        call_premutate( node );                                   \
20
21#define MUTATE_END( type, node )                \
22        auto __return = call_postmutate< type * >( node ); \
23        assert( __return ); \
24        return __return;
25
26
27#define VISIT_BODY( node )          \
28        VISIT_START( node );          \
29        if( children_guard ) {        \
30                Visitor::visit( node ); \
31        }                             \
32        VISIT_END( node );            \
33
34
35#define MUTATE_BODY( type, node )    \
36        MUTATE_START( node );          \
37        if( children_guard ) {         \
38                Mutator::mutate( node ); \
39        }                              \
40        MUTATE_END( type, node );      \
41
42
43
44template<typename T>
45static inline bool empty( T * ptr ) {
46        return !ptr || ptr->empty();
47}
48
49typedef std::list< Statement   * > StmtList_t;
50typedef std::list< Declaration * > DeclList_t;
51
52template<typename iterator_t>
53static inline void splice( iterator_t it, DeclList_t * decls ) {
54        std::transform(
55                decls->begin(),
56                decls->end(),
57                it,
58                [](Declaration * decl) -> auto {
59                        return new DeclStmt( decl );
60                }
61        );
62        decls->clear();
63}
64
65template< typename pass_type >
66inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
67        DeclList_t* beforeDecls = visitor.get_beforeDecls();
68        DeclList_t* afterDecls  = visitor.get_afterDecls();
69        SemanticErrorException errors;
70
71        pass_visitor_stats.depth++;
72        pass_visitor_stats.max->push(pass_visitor_stats.depth);
73        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
74        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
75
76
77                // splice in new declarations after previous decl
78                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
79
80                if ( i == decls.end() ) break;
81
82                try {
83                        // run visitor on declaration
84                        maybeAccept_impl( *i, visitor );
85                } catch( SemanticErrorException &e ) {
86                        errors.append( e );
87                }
88
89                // splice in new declarations before current decl
90                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
91        }
92        pass_visitor_stats.depth--;
93        if ( ! errors.isEmpty() ) {
94                throw errors;
95        }
96}
97
98template< typename pass_type >
99inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
100        DeclList_t* beforeDecls = mutator.get_beforeDecls();
101        DeclList_t* afterDecls  = mutator.get_afterDecls();
102        SemanticErrorException errors;
103
104        pass_visitor_stats.depth++;
105        pass_visitor_stats.max->push(pass_visitor_stats.depth);
106        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
107        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
108                // splice in new declarations after previous decl
109                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
110
111                if ( i == decls.end() ) break;
112                try {
113                        // run mutator on declaration
114                        maybeMutate_impl( *i, mutator );
115                } catch( SemanticErrorException &e ) {
116                        errors.append( e );
117                }
118
119                // splice in new declarations before current decl
120                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
121        }
122        pass_visitor_stats.depth--;
123        if ( ! errors.isEmpty() ) {
124                throw errors;
125        }
126}
127
128template< typename TreeType, typename pass_type >
129inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) {
130        if ( ! visitor.get_visit_children() ) return;
131        if ( tree ) {
132                tree->accept( visitor );
133        }
134}
135
136template< typename Container, typename pass_type >
137inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
138        if ( ! visitor.get_visit_children() ) return;
139        SemanticErrorException errors;
140
141        pass_visitor_stats.depth++;
142        pass_visitor_stats.max->push(pass_visitor_stats.depth);
143        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
144        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
145                try {
146                        if ( *i ) {
147                                (*i)->accept( visitor );
148                        }
149                } catch( SemanticErrorException &e ) {
150                        errors.append( e );
151                }
152        }
153        pass_visitor_stats.depth--;
154        if ( ! errors.isEmpty() ) {
155                throw errors;
156        }
157}
158
159template< typename TreeType, typename pass_type >
160inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) {
161        if ( ! mutator.get_visit_children() ) return;
162
163        if ( tree ) {
164                tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) );
165        }
166}
167
168template< typename Container, typename pass_type >
169inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
170        if ( ! mutator.get_visit_children() ) return;
171        SemanticErrorException errors;
172
173        pass_visitor_stats.depth++;
174        pass_visitor_stats.max->push(pass_visitor_stats.depth);
175        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
176        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
177                try {
178                        if ( *i ) {
179                                *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
180                                assert( *i );
181                        } // if
182                } catch( SemanticErrorException &e ) {
183                        errors.append( e );
184                } // try
185        } // for
186        pass_visitor_stats.depth--;
187        if ( ! errors.isEmpty() ) {
188                throw errors;
189        } // if
190}
191
192template< typename pass_type >
193template< typename func_t >
194void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
195        if ( ! get_visit_children() ) return;
196        SemanticErrorException errors;
197
198        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
199        ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
200        ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
201        ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
202        ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
203
204        StmtList_t* beforeStmts = get_beforeStmts();
205        StmtList_t* afterStmts  = get_afterStmts();
206        DeclList_t* beforeDecls = get_beforeDecls();
207        DeclList_t* afterDecls  = get_afterDecls();
208
209        pass_visitor_stats.depth++;
210        pass_visitor_stats.max->push(pass_visitor_stats.depth);
211        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
212        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
213
214                if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
215                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
216
217                try {
218                        func( *i );
219                        assert(( empty( beforeStmts ) && empty( afterStmts ))
220                            || ( empty( beforeDecls ) && empty( afterDecls )) );
221
222                } catch ( SemanticErrorException &e ) {
223                        errors.append( e );
224                }
225
226                if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
227                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
228        }
229        pass_visitor_stats.depth--;
230
231        if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
232        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
233        if ( !errors.isEmpty() ) { throw errors; }
234}
235
236template< typename pass_type >
237void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
238        handleStatementList( statements, [this]( Statement * stmt) {
239                maybeAccept_impl( stmt, *this );
240        });
241}
242
243template< typename pass_type >
244void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
245        handleStatementList( statements, [this]( Statement *& stmt) {
246                maybeMutate_impl( stmt, *this );
247        });
248}
249
250
251template< typename pass_type >
252template< typename func_t >
253Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
254        if ( ! get_visit_children() ) return stmt;
255
256        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
257        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
258        ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
259        ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
260        ValueGuardPtr< StmtList_t >          oldBeforeStmts( get_beforeStmts() );
261        ValueGuardPtr< StmtList_t >          oldAfterStmts ( get_afterStmts () );
262
263        Statement *newStmt = func( stmt );
264
265        StmtList_t* beforeStmts = get_beforeStmts();
266        StmtList_t* afterStmts  = get_afterStmts();
267        DeclList_t* beforeDecls = get_beforeDecls();
268        DeclList_t* afterDecls  = get_afterDecls();
269
270        if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
271        assert(( empty( beforeStmts ) && empty( afterStmts ))
272            || ( empty( beforeDecls ) && empty( afterDecls )) );
273
274        CompoundStmt *compound = new CompoundStmt();
275        if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
276        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
277        compound->get_kids().push_back( newStmt );
278        if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
279        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
280        return compound;
281}
282
283template< typename pass_type >
284Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
285        return handleStatement( stmt, [this]( Statement * stmt ) {
286                maybeAccept_impl( stmt, *this );
287                return stmt;
288        });
289}
290
291template< typename pass_type >
292Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
293        return handleStatement( stmt, [this]( Statement * stmt ) {
294                maybeMutate_impl( stmt, *this );
295                return stmt;
296        });
297}
298
299template< typename pass_type >
300template< typename func_t >
301Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
302        if ( ! get_visit_children() ) return expr;
303        if( !expr ) return nullptr;
304
305        auto env_ptr = get_env_ptr();
306        if ( env_ptr && expr->get_env() ) {
307                *env_ptr = expr->get_env();
308        }
309
310        // should env be moved onto the result of the mutate?
311        return func( expr );
312}
313
314template< typename pass_type >
315Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
316        return handleExpression(expr, [this]( Expression * expr ) {
317                maybeAccept_impl( expr, *this );
318                return expr;
319        });
320}
321
322template< typename pass_type >
323Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
324        return handleExpression(expr, [this]( Expression * expr ) {
325                maybeMutate_impl( expr, *this );
326                return expr;
327        });
328}
329
330template< typename TreeType, typename VisitorType >
331inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
332        if ( ! visitor.get_visit_children() ) return;
333        auto guard = makeFuncGuard(
334                [&visitor]() { visitor.indexerScopeEnter(); },
335                [&visitor]() { visitor.indexerScopeLeave(); }
336        );
337        maybeAccept_impl( tree, visitor );
338}
339
340template< typename TreeType, typename MutatorType >
341inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
342        if ( ! mutator.get_visit_children() ) return;
343        auto guard = makeFuncGuard(
344                [&mutator]() { mutator.indexerScopeEnter(); },
345                [&mutator]() { mutator.indexerScopeLeave(); }
346        );
347        maybeMutate_impl( tree, mutator );
348}
349
350//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
351//========================================================================================================================================================================
352//========================================================================================================================================================================
353//========================================================================================================================================================================
354//========================================================================================================================================================================
355//========================================================================================================================================================================
356//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
357
358// A NOTE ON THE ORDER OF TRAVERSAL
359//
360// Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
361// no such thing as a recursive type or typedef.
362//
363//             typedef struct { T *x; } T; // never allowed
364//
365// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
366// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
367// declaration).
368//
369//             struct T { struct T *x; }; // allowed
370//
371// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
372// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
373// queried later in this pass.
374//
375// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
376
377//--------------------------------------------------------------------------
378// ObjectDecl
379template< typename pass_type >
380void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
381        VISIT_START( node );
382
383        indexerScopedAccept( node->type         , *this );
384        maybeAccept_impl   ( node->init         , *this );
385        maybeAccept_impl   ( node->bitfieldWidth, *this );
386        maybeAccept_impl   ( node->attributes   , *this );
387
388        indexerAddId( node );
389
390        VISIT_END( node );
391}
392
393template< typename pass_type >
394DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
395        MUTATE_START( node );
396
397        indexerScopedMutate( node->type         , *this );
398        maybeMutate_impl   ( node->init         , *this );
399        maybeMutate_impl   ( node->bitfieldWidth, *this );
400        maybeMutate_impl   ( node->attributes   , *this );
401
402        indexerAddId( node );
403
404        MUTATE_END( DeclarationWithType, node );
405}
406
407//--------------------------------------------------------------------------
408// FunctionDecl
409template< typename pass_type >
410void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
411        VISIT_START( node );
412
413        indexerAddId( node );
414
415        maybeAccept_impl( node->withExprs, *this );
416        {
417                // with clause introduces a level of scope (for the with expression members).
418                // with clause exprs are added to the indexer before parameters so that parameters
419                // shadow with exprs and not the other way around.
420                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
421                indexerAddWith( node->withExprs, node );
422                {
423                        auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
424                        // implicit add __func__ identifier as specified in the C manual 6.4.2.2
425                        static ObjectDecl func(
426                                "__func__", noStorageClasses, LinkageSpec::C, nullptr,
427                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
428                                nullptr
429                        );
430                        indexerAddId( &func );
431                        maybeAccept_impl( node->type, *this );
432                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
433                        // a new scope if inFunction is true
434                        ValueGuard< bool > oldInFunction( inFunction );
435                        inFunction = true;
436                        maybeAccept_impl( node->statements, *this );
437                        maybeAccept_impl( node->attributes, *this );
438                }
439        }
440
441        VISIT_END( node );
442}
443
444template< typename pass_type >
445DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
446        MUTATE_START( node );
447
448        indexerAddId( node );
449
450        {
451                // with clause introduces a level of scope (for the with expression members).
452                // with clause exprs are added to the indexer before parameters so that parameters
453                // shadow with exprs and not the other way around.
454                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
455                indexerAddWith( node->withExprs, node );
456                {
457                        auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
458                        // implicit add __func__ identifier as specified in the C manual 6.4.2.2
459                        static ObjectDecl func(
460                                "__func__", noStorageClasses, LinkageSpec::C, nullptr,
461                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
462                                nullptr
463                        );
464                        indexerAddId( &func );
465                        maybeMutate_impl( node->type, *this );
466                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
467                        // a new scope if inFunction is true
468                        ValueGuard< bool > oldInFunction( inFunction );
469                        inFunction = true;
470                        maybeMutate_impl( node->statements, *this );
471                        maybeMutate_impl( node->attributes, *this );
472                }
473        }
474
475        MUTATE_END( DeclarationWithType, node );
476}
477
478//--------------------------------------------------------------------------
479// StructDecl
480template< typename pass_type >
481void PassVisitor< pass_type >::visit( StructDecl * node ) {
482        VISIT_START( node );
483
484        // make up a forward declaration and add it before processing the members
485        // needs to be on the heap because addStruct saves the pointer
486        indexerAddStructFwd( node );
487
488        {
489                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
490                maybeAccept_impl( node->parameters, *this );
491                maybeAccept_impl( node->members   , *this );
492        }
493
494        // this addition replaces the forward declaration
495        indexerAddStruct( node );
496
497        VISIT_END( node );
498}
499
500template< typename pass_type >
501Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
502        MUTATE_START( node );
503
504        // make up a forward declaration and add it before processing the members
505        // needs to be on the heap because addStruct saves the pointer
506        indexerAddStructFwd( node );
507
508        {
509                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
510                maybeMutate_impl( node->parameters, *this );
511                maybeMutate_impl( node->members   , *this );
512        }
513
514        // this addition replaces the forward declaration
515        indexerAddStruct( node );
516
517        MUTATE_END( Declaration, node );
518}
519
520//--------------------------------------------------------------------------
521// UnionDecl
522template< typename pass_type >
523void PassVisitor< pass_type >::visit( UnionDecl * node ) {
524        VISIT_START( node );
525
526        // make up a forward declaration and add it before processing the members
527        indexerAddUnionFwd( node );
528
529        {
530                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
531                maybeAccept_impl( node->parameters, *this );
532                maybeAccept_impl( node->members   , *this );
533        }
534
535        indexerAddUnion( node );
536
537        VISIT_END( node );
538}
539
540template< typename pass_type >
541Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
542        MUTATE_START( node );
543
544        // make up a forward declaration and add it before processing the members
545        indexerAddUnionFwd( node );
546
547        {
548                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
549                maybeMutate_impl( node->parameters, *this );
550                maybeMutate_impl( node->members   , *this );
551        }
552
553        indexerAddUnion( node );
554
555        MUTATE_END( Declaration, node );
556}
557
558//--------------------------------------------------------------------------
559// EnumDecl
560template< typename pass_type >
561void PassVisitor< pass_type >::visit( EnumDecl * node ) {
562        VISIT_START( node );
563
564        indexerAddEnum( node );
565
566        // unlike structs, traits, and unions, enums inject their members into the global scope
567        maybeAccept_impl( node->parameters, *this );
568        maybeAccept_impl( node->members   , *this );
569
570        VISIT_END( node );
571}
572
573template< typename pass_type >
574Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
575        MUTATE_START( node );
576
577        indexerAddEnum( node );
578
579        // unlike structs, traits, and unions, enums inject their members into the global scope
580        maybeMutate_impl( node->parameters, *this );
581        maybeMutate_impl( node->members   , *this );
582
583        MUTATE_END( Declaration, node );
584}
585
586//--------------------------------------------------------------------------
587// TraitDecl
588template< typename pass_type >
589void PassVisitor< pass_type >::visit( TraitDecl * node ) {
590        VISIT_START( node );
591
592        {
593                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
594                maybeAccept_impl( node->parameters, *this );
595                maybeAccept_impl( node->members   , *this );
596        }
597
598        indexerAddTrait( node );
599
600        VISIT_END( node );
601}
602
603template< typename pass_type >
604Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
605        MUTATE_START( node );
606
607        {
608                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
609                maybeMutate_impl( node->parameters, *this );
610                maybeMutate_impl( node->members   , *this );
611        }
612
613        indexerAddTrait( node );
614
615        MUTATE_END( Declaration, node );
616}
617
618//--------------------------------------------------------------------------
619// TypeDecl
620template< typename pass_type >
621void PassVisitor< pass_type >::visit( TypeDecl * node ) {
622        VISIT_START( node );
623
624        {
625                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
626                maybeAccept_impl( node->parameters, *this );
627                maybeAccept_impl( node->base      , *this );
628        }
629
630        // see A NOTE ON THE ORDER OF TRAVERSAL, above
631        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
632        // and may depend on the type itself
633        indexerAddType( node );
634
635        maybeAccept_impl( node->assertions, *this );
636
637        indexerScopedAccept( node->init, *this );
638
639        VISIT_END( node );
640}
641
642template< typename pass_type >
643Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
644        MUTATE_START( node );
645
646        {
647                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
648                maybeMutate_impl( node->parameters, *this );
649                maybeMutate_impl( node->base      , *this );
650        }
651
652        // see A NOTE ON THE ORDER OF TRAVERSAL, above
653        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
654        // and may depend on the type itself
655        indexerAddType( node );
656
657        maybeMutate_impl( node->assertions, *this );
658
659        indexerScopedMutate( node->init, *this );
660
661        MUTATE_END( Declaration, node );
662}
663
664//--------------------------------------------------------------------------
665// TypedefDecl
666template< typename pass_type >
667void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
668        VISIT_START( node );
669
670        {
671                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
672                maybeAccept_impl( node->parameters, *this );
673                maybeAccept_impl( node->base      , *this );
674        }
675
676        indexerAddType( node );
677
678        maybeAccept_impl( node->assertions, *this );
679
680        VISIT_END( node );
681}
682
683template< typename pass_type >
684Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
685        MUTATE_START( node );
686
687        {
688                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
689                maybeMutate_impl( node->parameters, *this );
690                maybeMutate_impl( node->base      , *this );
691        }
692
693        indexerAddType( node );
694
695        maybeMutate_impl( node->assertions, *this );
696
697        MUTATE_END( Declaration, node );
698}
699
700//--------------------------------------------------------------------------
701// AsmDecl
702template< typename pass_type >
703void PassVisitor< pass_type >::visit( AsmDecl * node ) {
704        VISIT_START( node );
705
706        maybeAccept_impl( node->stmt, *this );
707
708        VISIT_END( node );
709}
710
711template< typename pass_type >
712AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
713        MUTATE_START( node );
714
715        maybeMutate_impl( node->stmt, *this );
716
717        MUTATE_END( AsmDecl, node );
718}
719
720//--------------------------------------------------------------------------
721// StaticAssertDecl
722template< typename pass_type >
723void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) {
724        VISIT_START( node );
725
726        node->condition = visitExpression( node->condition );
727        maybeAccept_impl( node->message, *this );
728
729        VISIT_END( node );
730}
731
732template< typename pass_type >
733StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) {
734        MUTATE_START( node );
735
736        node->condition = mutateExpression( node->condition );
737        maybeMutate_impl( node->message, *this );
738
739        MUTATE_END( StaticAssertDecl, node );
740}
741
742//--------------------------------------------------------------------------
743// CompoundStmt
744template< typename pass_type >
745void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
746        VISIT_START( node );
747        {
748                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
749                ValueGuard< bool > oldInFunction( inFunction );
750                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
751                auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
752                inFunction = false;
753                visitStatementList( node->kids );
754        }
755        VISIT_END( node );
756}
757
758template< typename pass_type >
759CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
760        MUTATE_START( node );
761        {
762                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
763                ValueGuard< bool > oldInFunction( inFunction );
764                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
765                auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
766                inFunction = false;
767                mutateStatementList( node->kids );
768        }
769        MUTATE_END( CompoundStmt, node );
770}
771
772//--------------------------------------------------------------------------
773// ExprStmt
774template< typename pass_type >
775void PassVisitor< pass_type >::visit( ExprStmt * node ) {
776        VISIT_START( node );
777
778        visitExpression( node->expr );
779
780        VISIT_END( node );
781}
782
783template< typename pass_type >
784Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
785        MUTATE_START( node );
786
787        node->expr = mutateExpression( node->expr );
788
789        MUTATE_END( Statement, node );
790}
791
792//--------------------------------------------------------------------------
793// AsmStmt
794template< typename pass_type >
795void PassVisitor< pass_type >::visit( AsmStmt * node ) {
796        VISIT_START( node )
797
798        maybeAccept_impl( node->instruction, *this );
799        maybeAccept_impl( node->output, *this );
800        maybeAccept_impl( node->input, *this );
801        maybeAccept_impl( node->clobber, *this );
802
803        VISIT_END( node );
804}
805
806template< typename pass_type >
807Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
808        MUTATE_START( node );
809
810        maybeMutate_impl( node->instruction, *this );
811        maybeMutate_impl( node->output, *this );
812        maybeMutate_impl( node->input, *this );
813        maybeMutate_impl( node->clobber, *this );
814
815        MUTATE_END( Statement, node );
816}
817
818//--------------------------------------------------------------------------
819// AsmStmt
820template< typename pass_type >
821void PassVisitor< pass_type >::visit( DirectiveStmt * node ) {
822        VISIT_START( node )
823
824        VISIT_END( node );
825}
826
827template< typename pass_type >
828Statement * PassVisitor< pass_type >::mutate( DirectiveStmt * node ) {
829        MUTATE_START( node );
830
831        MUTATE_END( Statement, node );
832}
833
834//--------------------------------------------------------------------------
835// IfStmt
836template< typename pass_type >
837void PassVisitor< pass_type >::visit( IfStmt * node ) {
838        VISIT_START( node );
839        {
840                // if statements introduce a level of scope (for the initialization)
841                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
842                maybeAccept_impl( node->get_initialization(), *this );
843                visitExpression ( node->condition );
844                node->thenPart = visitStatement( node->thenPart );
845                node->elsePart = visitStatement( node->elsePart );
846        }
847        VISIT_END( node );
848}
849
850template< typename pass_type >
851Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
852        MUTATE_START( node );
853        {
854                // if statements introduce a level of scope (for the initialization)
855                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
856                maybeMutate_impl( node->get_initialization(), *this );
857                node->condition = mutateExpression( node->condition );
858                node->thenPart  = mutateStatement ( node->thenPart  );
859                node->elsePart  = mutateStatement ( node->elsePart  );
860        }
861        MUTATE_END( Statement, node );
862}
863
864//--------------------------------------------------------------------------
865// WhileStmt
866template< typename pass_type >
867void PassVisitor< pass_type >::visit( WhileStmt * node ) {
868        VISIT_START( node );
869
870        {
871                // while statements introduce a level of scope (for the initialization)
872                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
873                maybeAccept_impl( node->initialization, *this );
874                visitExpression ( node->condition );
875                node->body = visitStatement( node->body );
876        }
877
878        VISIT_END( node );
879}
880
881template< typename pass_type >
882Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
883        MUTATE_START( node );
884
885        {
886                // while statements introduce a level of scope (for the initialization)
887                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
888                maybeMutate_impl( node->initialization, *this );
889                node->condition = mutateExpression( node->condition );
890                node->body      = mutateStatement ( node->body      );
891        }
892
893
894        MUTATE_END( Statement, node );
895}
896
897//--------------------------------------------------------------------------
898// ForStmt
899template< typename pass_type >
900void PassVisitor< pass_type >::visit( ForStmt * node ) {
901        VISIT_START( node );
902        {
903                // for statements introduce a level of scope (for the initialization)
904                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
905                maybeAccept_impl( node->initialization, *this );
906                visitExpression( node->condition );
907                visitExpression( node->increment );
908                node->body = visitStatement( node->body );
909        }
910        VISIT_END( node );
911}
912
913template< typename pass_type >
914Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
915        MUTATE_START( node );
916        {
917                // for statements introduce a level of scope (for the initialization)
918                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
919                maybeMutate_impl( node->initialization, *this );
920                node->condition = mutateExpression( node->condition );
921                node->increment = mutateExpression( node->increment );
922                node->body      = mutateStatement ( node->body      );
923        }
924        MUTATE_END( Statement, node );
925}
926
927//--------------------------------------------------------------------------
928// SwitchStmt
929template< typename pass_type >
930void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
931        VISIT_START( node );
932
933        visitExpression   ( node->condition  );
934        visitStatementList( node->statements );
935
936        VISIT_END( node );
937}
938
939template< typename pass_type >
940Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
941        MUTATE_START( node );
942
943        node->condition = mutateExpression( node->condition );
944        mutateStatementList( node->statements );
945
946        MUTATE_END( Statement, node );
947}
948
949//--------------------------------------------------------------------------
950// CaseStmt
951template< typename pass_type >
952void PassVisitor< pass_type >::visit( CaseStmt * node ) {
953        VISIT_START( node );
954
955        visitExpression   ( node->condition );
956        visitStatementList( node->stmts     );
957
958        VISIT_END( node );
959}
960
961template< typename pass_type >
962Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
963        MUTATE_START( node );
964
965        node->condition = mutateExpression( node->condition );
966        mutateStatementList( node->stmts );
967
968        MUTATE_END( Statement, node );
969}
970
971//--------------------------------------------------------------------------
972// BranchStmt
973template< typename pass_type >
974void PassVisitor< pass_type >::visit( BranchStmt * node ) {
975        VISIT_START( node );
976        VISIT_END( node );
977}
978
979template< typename pass_type >
980Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
981        MUTATE_START( node );
982        MUTATE_END( Statement, node );
983}
984
985//--------------------------------------------------------------------------
986// ReturnStmt
987template< typename pass_type >
988void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
989        VISIT_START( node );
990
991        visitExpression( node->expr );
992
993        VISIT_END( node );
994}
995
996template< typename pass_type >
997Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
998        MUTATE_START( node );
999
1000        node->expr = mutateExpression( node->expr );
1001
1002        MUTATE_END( Statement, node );
1003}
1004
1005//--------------------------------------------------------------------------
1006// ThrowStmt
1007
1008template< typename pass_type >
1009void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
1010        VISIT_START( node );
1011
1012        maybeAccept_impl( node->expr, *this );
1013        maybeAccept_impl( node->target, *this );
1014
1015        VISIT_END( node );
1016}
1017
1018template< typename pass_type >
1019Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
1020        MUTATE_START( node );
1021
1022        maybeMutate_impl( node->expr, *this );
1023        maybeMutate_impl( node->target, *this );
1024
1025        MUTATE_END( Statement, node );
1026}
1027
1028//--------------------------------------------------------------------------
1029// TryStmt
1030template< typename pass_type >
1031void PassVisitor< pass_type >::visit( TryStmt * node ) {
1032        VISIT_START( node );
1033
1034        maybeAccept_impl( node->block       , *this );
1035        maybeAccept_impl( node->handlers    , *this );
1036        maybeAccept_impl( node->finallyBlock, *this );
1037
1038        VISIT_END( node );
1039}
1040
1041template< typename pass_type >
1042Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
1043        MUTATE_START( node );
1044
1045        maybeMutate_impl( node->block       , *this );
1046        maybeMutate_impl( node->handlers    , *this );
1047        maybeMutate_impl( node->finallyBlock, *this );
1048
1049        MUTATE_END( Statement, node );
1050}
1051
1052//--------------------------------------------------------------------------
1053// CatchStmt
1054template< typename pass_type >
1055void PassVisitor< pass_type >::visit( CatchStmt * node ) {
1056        VISIT_START( node );
1057        {
1058                // catch statements introduce a level of scope (for the caught exception)
1059                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1060                maybeAccept_impl( node->decl, *this );
1061                node->cond = visitExpression( node->cond );
1062                node->body = visitStatement ( node->body );
1063        }
1064        VISIT_END( node );
1065}
1066
1067template< typename pass_type >
1068Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
1069        MUTATE_START( node );
1070        {
1071                // catch statements introduce a level of scope (for the caught exception)
1072                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1073                maybeMutate_impl( node->decl, *this );
1074                node->cond = mutateExpression( node->cond );
1075                node->body = mutateStatement ( node->body );
1076        }
1077        MUTATE_END( Statement, node );
1078}
1079
1080//--------------------------------------------------------------------------
1081// FinallyStmt
1082template< typename pass_type >
1083void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
1084        VISIT_START( node );
1085
1086        maybeAccept_impl( node->block, *this );
1087
1088        VISIT_END( node );
1089}
1090
1091template< typename pass_type >
1092Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
1093        MUTATE_START( node );
1094
1095        maybeMutate_impl( node->block, *this );
1096
1097        MUTATE_END( Statement, node );
1098}
1099
1100//--------------------------------------------------------------------------
1101// WaitForStmt
1102template< typename pass_type >
1103void PassVisitor< pass_type >::visit( WaitForStmt * node ) {
1104        VISIT_START( node );
1105
1106        for( auto & clause : node->clauses ) {
1107                maybeAccept_impl( clause.target.function, *this );
1108                maybeAccept_impl( clause.target.arguments, *this );
1109
1110                maybeAccept_impl( clause.statement, *this );
1111                maybeAccept_impl( clause.condition, *this );
1112        }
1113
1114        maybeAccept_impl( node->timeout.time, *this );
1115        maybeAccept_impl( node->timeout.statement, *this );
1116        maybeAccept_impl( node->timeout.condition, *this );
1117        maybeAccept_impl( node->orelse.statement, *this );
1118        maybeAccept_impl( node->orelse.condition, *this );
1119
1120        VISIT_END( node );
1121}
1122
1123template< typename pass_type >
1124Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
1125        MUTATE_START( node );
1126
1127        for( auto & clause : node->clauses ) {
1128                maybeMutate_impl( clause.target.function, *this );
1129                maybeMutate_impl( clause.target.arguments, *this );
1130
1131                maybeMutate_impl( clause.statement, *this );
1132                maybeMutate_impl( clause.condition, *this );
1133        }
1134
1135        maybeMutate_impl( node->timeout.time, *this );
1136        maybeMutate_impl( node->timeout.statement, *this );
1137        maybeMutate_impl( node->timeout.condition, *this );
1138        maybeMutate_impl( node->orelse.statement, *this );
1139        maybeMutate_impl( node->orelse.condition, *this );
1140
1141        MUTATE_END( Statement, node );
1142}
1143
1144
1145
1146//--------------------------------------------------------------------------
1147// NullStmt
1148template< typename pass_type >
1149void PassVisitor< pass_type >::visit( WithStmt * node ) {
1150        VISIT_START( node );
1151        maybeAccept_impl( node->exprs, *this );
1152        {
1153                // catch statements introduce a level of scope (for the caught exception)
1154                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1155                indexerAddWith( node->exprs, node );
1156                maybeAccept_impl( node->stmt, *this );
1157        }
1158        VISIT_END( node );
1159}
1160
1161template< typename pass_type >
1162Statement * PassVisitor< pass_type >::mutate( WithStmt * node ) {
1163        MUTATE_START( node );
1164        maybeMutate_impl( node->exprs, *this );
1165        {
1166                // catch statements introduce a level of scope (for the caught exception)
1167                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1168                indexerAddWith( node->exprs, node );
1169                maybeMutate_impl( node->stmt, *this );
1170        }
1171        MUTATE_END( Statement, node );
1172}
1173
1174//--------------------------------------------------------------------------
1175// NullStmt
1176template< typename pass_type >
1177void PassVisitor< pass_type >::visit( NullStmt * node ) {
1178        VISIT_START( node );
1179        VISIT_END( node );
1180}
1181
1182template< typename pass_type >
1183NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
1184        MUTATE_START( node );
1185        MUTATE_END( NullStmt, node );
1186}
1187
1188//--------------------------------------------------------------------------
1189// DeclStmt
1190template< typename pass_type >
1191void PassVisitor< pass_type >::visit( DeclStmt * node ) {
1192        VISIT_START( node );
1193
1194        maybeAccept_impl( node->decl, *this );
1195
1196        VISIT_END( node );
1197}
1198
1199template< typename pass_type >
1200Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
1201        MUTATE_START( node );
1202
1203        maybeMutate_impl( node->decl, *this );
1204
1205        MUTATE_END( Statement, node );
1206}
1207
1208//--------------------------------------------------------------------------
1209// ImplicitCtorDtorStmt
1210template< typename pass_type >
1211void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
1212        VISIT_START( node );
1213
1214        maybeAccept_impl( node->callStmt, *this );
1215
1216        VISIT_END( node );
1217}
1218
1219template< typename pass_type >
1220Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
1221        MUTATE_START( node );
1222
1223        maybeMutate_impl( node->callStmt, *this );
1224
1225        MUTATE_END( Statement, node );
1226}
1227
1228//--------------------------------------------------------------------------
1229// ApplicationExpr
1230template< typename pass_type >
1231void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
1232        VISIT_START( node );
1233
1234        indexerScopedAccept( node->result  , *this );
1235        maybeAccept_impl        ( node->function, *this );
1236        maybeAccept_impl        ( node->args    , *this );
1237
1238        VISIT_END( node );
1239}
1240
1241template< typename pass_type >
1242Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
1243        MUTATE_START( node );
1244
1245        indexerScopedMutate( node->env     , *this );
1246        indexerScopedMutate( node->result  , *this );
1247        maybeMutate_impl   ( node->function, *this );
1248        maybeMutate_impl   ( node->args    , *this );
1249
1250        MUTATE_END( Expression, node );
1251}
1252
1253//--------------------------------------------------------------------------
1254// UntypedExpr
1255template< typename pass_type >
1256void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
1257        VISIT_START( node );
1258
1259        // maybeAccept_impl( node->get_env(), *this );
1260        indexerScopedAccept( node->result, *this );
1261
1262        for ( auto expr : node->args ) {
1263                visitExpression( expr );
1264        }
1265
1266        VISIT_END( node );
1267}
1268
1269template< typename pass_type >
1270Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
1271        MUTATE_START( node );
1272
1273        indexerScopedMutate( node->env   , *this );
1274        indexerScopedMutate( node->result, *this );
1275
1276        for ( auto& expr : node->args ) {
1277                expr = mutateExpression( expr );
1278        }
1279
1280        MUTATE_END( Expression, node );
1281}
1282
1283//--------------------------------------------------------------------------
1284// NameExpr
1285template< typename pass_type >
1286void PassVisitor< pass_type >::visit( NameExpr * node ) {
1287        VISIT_START( node );
1288
1289        indexerScopedAccept( node->result, *this );
1290
1291        VISIT_END( node );
1292}
1293
1294template< typename pass_type >
1295Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
1296        MUTATE_START( node );
1297
1298        indexerScopedMutate( node->env   , *this );
1299        indexerScopedMutate( node->result, *this );
1300
1301        MUTATE_END( Expression, node );
1302}
1303
1304//--------------------------------------------------------------------------
1305// CastExpr
1306template< typename pass_type >
1307void PassVisitor< pass_type >::visit( CastExpr * node ) {
1308        VISIT_START( node );
1309
1310        indexerScopedAccept( node->result, *this );
1311        maybeAccept_impl        ( node->arg   , *this );
1312
1313        VISIT_END( node );
1314}
1315
1316template< typename pass_type >
1317Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
1318        MUTATE_START( node );
1319
1320        indexerScopedMutate( node->env   , *this );
1321        indexerScopedMutate( node->result, *this );
1322        maybeMutate_impl   ( node->arg   , *this );
1323
1324        MUTATE_END( Expression, node );
1325}
1326
1327//--------------------------------------------------------------------------
1328// KeywordCastExpr
1329template< typename pass_type >
1330void PassVisitor< pass_type >::visit( KeywordCastExpr * node ) {
1331        VISIT_START( node );
1332
1333        indexerScopedAccept( node->result, *this );
1334        maybeAccept_impl        ( node->arg   , *this );
1335
1336        VISIT_END( node );
1337}
1338
1339template< typename pass_type >
1340Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) {
1341        MUTATE_START( node );
1342
1343        indexerScopedMutate( node->env   , *this );
1344        indexerScopedMutate( node->result, *this );
1345        maybeMutate_impl   ( node->arg   , *this );
1346
1347        MUTATE_END( Expression, node );
1348}
1349
1350//--------------------------------------------------------------------------
1351// VirtualCastExpr
1352template< typename pass_type >
1353void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
1354        VISIT_START( node );
1355
1356        indexerScopedAccept( node->result, *this );
1357        maybeAccept_impl( node->arg, *this );
1358
1359        VISIT_END( node );
1360}
1361
1362template< typename pass_type >
1363Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
1364        MUTATE_START( node );
1365
1366        indexerScopedMutate( node->env   , *this );
1367        indexerScopedMutate( node->result, *this );
1368        maybeMutate_impl   ( node->arg   , *this );
1369
1370        MUTATE_END( Expression, node );
1371}
1372
1373//--------------------------------------------------------------------------
1374// AddressExpr
1375template< typename pass_type >
1376void PassVisitor< pass_type >::visit( AddressExpr * node ) {
1377        VISIT_START( node );
1378
1379        indexerScopedAccept( node->result, *this );
1380        maybeAccept_impl   ( node->arg   , *this );
1381
1382        VISIT_END( node );
1383}
1384
1385template< typename pass_type >
1386Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
1387        MUTATE_START( node );
1388
1389        indexerScopedMutate( node->env   , *this );
1390        indexerScopedMutate( node->result, *this );
1391        maybeMutate_impl   ( node->arg   , *this );
1392
1393        MUTATE_END( Expression, node );
1394}
1395
1396//--------------------------------------------------------------------------
1397// LabelAddressExpr
1398template< typename pass_type >
1399void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
1400        VISIT_START( node );
1401
1402        indexerScopedAccept( node->result, *this );
1403
1404        VISIT_END( node );
1405}
1406
1407template< typename pass_type >
1408Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
1409        MUTATE_START( node );
1410
1411        indexerScopedMutate( node->env   , *this );
1412        indexerScopedMutate( node->result, *this );
1413
1414        MUTATE_END( Expression, node );
1415}
1416
1417//--------------------------------------------------------------------------
1418// UntypedMemberExpr
1419template< typename pass_type >
1420void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
1421        VISIT_START( node );
1422
1423        indexerScopedAccept( node->result   , *this );
1424        maybeAccept_impl   ( node->aggregate, *this );
1425        maybeAccept_impl   ( node->member   , *this );
1426
1427        VISIT_END( node );
1428}
1429
1430template< typename pass_type >
1431Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
1432        MUTATE_START( node );
1433
1434        indexerScopedMutate( node->env      , *this );
1435        indexerScopedMutate( node->result   , *this );
1436        maybeMutate_impl   ( node->aggregate, *this );
1437        maybeMutate_impl   ( node->member   , *this );
1438
1439        MUTATE_END( Expression, node );
1440}
1441
1442//--------------------------------------------------------------------------
1443// MemberExpr
1444template< typename pass_type >
1445void PassVisitor< pass_type >::visit( MemberExpr * node ) {
1446        VISIT_START( node );
1447
1448        indexerScopedAccept( node->result   , *this );
1449        maybeAccept_impl   ( node->aggregate, *this );
1450
1451        VISIT_END( node );
1452}
1453
1454template< typename pass_type >
1455Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
1456        MUTATE_START( node );
1457
1458        indexerScopedMutate( node->env      , *this );
1459        indexerScopedMutate( node->result   , *this );
1460        maybeMutate_impl   ( node->aggregate, *this );
1461
1462        MUTATE_END( Expression, node );
1463}
1464
1465//--------------------------------------------------------------------------
1466// VariableExpr
1467template< typename pass_type >
1468void PassVisitor< pass_type >::visit( VariableExpr * node ) {
1469        VISIT_START( node );
1470
1471        indexerScopedAccept( node->result, *this );
1472
1473        VISIT_END( node );
1474}
1475
1476template< typename pass_type >
1477Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
1478        MUTATE_START( node );
1479
1480        indexerScopedMutate( node->env   , *this );
1481        indexerScopedMutate( node->result, *this );
1482
1483        MUTATE_END( Expression, node );
1484}
1485
1486//--------------------------------------------------------------------------
1487// ConstantExpr
1488template< typename pass_type >
1489void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
1490        VISIT_START( node );
1491
1492        indexerScopedAccept( node->result   , *this );
1493        maybeAccept_impl   ( &node->constant, *this );
1494
1495        VISIT_END( node );
1496}
1497
1498template< typename pass_type >
1499Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
1500        MUTATE_START( node );
1501
1502        indexerScopedMutate( node->env   , *this );
1503        indexerScopedMutate( node->result, *this );
1504        Constant * ptr = &node->constant;
1505        maybeMutate_impl( ptr, *this );
1506        node->constant = *ptr;
1507
1508        MUTATE_END( Expression, node );
1509}
1510
1511//--------------------------------------------------------------------------
1512// SizeofExpr
1513template< typename pass_type >
1514void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
1515        VISIT_START( node );
1516
1517        indexerScopedAccept( node->result, *this );
1518        if ( node->get_isType() ) {
1519                maybeAccept_impl( node->type, *this );
1520        } else {
1521                maybeAccept_impl( node->expr, *this );
1522        }
1523
1524        VISIT_END( node );
1525}
1526
1527template< typename pass_type >
1528Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
1529        MUTATE_START( node );
1530
1531        indexerScopedMutate( node->env   , *this );
1532        indexerScopedMutate( node->result, *this );
1533        if ( node->get_isType() ) {
1534                maybeMutate_impl( node->type, *this );
1535        } else {
1536                maybeMutate_impl( node->expr, *this );
1537        }
1538
1539        MUTATE_END( Expression, node );
1540}
1541
1542//--------------------------------------------------------------------------
1543// AlignofExpr
1544template< typename pass_type >
1545void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
1546        VISIT_START( node );
1547
1548        indexerScopedAccept( node->result, *this );
1549        if ( node->get_isType() ) {
1550                maybeAccept_impl( node->type, *this );
1551        } else {
1552                maybeAccept_impl( node->expr, *this );
1553        }
1554
1555        VISIT_END( node );
1556}
1557
1558template< typename pass_type >
1559Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
1560        MUTATE_START( node );
1561
1562        indexerScopedMutate( node->env   , *this );
1563        indexerScopedMutate( node->result, *this );
1564        if ( node->get_isType() ) {
1565                maybeMutate_impl( node->type, *this );
1566        } else {
1567                maybeMutate_impl( node->expr, *this );
1568        }
1569
1570        MUTATE_END( Expression, node );
1571}
1572
1573//--------------------------------------------------------------------------
1574// UntypedOffsetofExpr
1575template< typename pass_type >
1576void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
1577        VISIT_START( node );
1578
1579        indexerScopedAccept( node->result, *this );
1580        maybeAccept_impl   ( node->type  , *this );
1581
1582        VISIT_END( node );
1583}
1584
1585template< typename pass_type >
1586Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
1587        MUTATE_START( node );
1588
1589        indexerScopedMutate( node->env   , *this );
1590        indexerScopedMutate( node->result, *this );
1591        maybeMutate_impl   ( node->type  , *this );
1592
1593        MUTATE_END( Expression, node );
1594}
1595
1596//--------------------------------------------------------------------------
1597// OffsetofExpr
1598template< typename pass_type >
1599void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
1600        VISIT_START( node );
1601
1602        indexerScopedAccept( node->result, *this );
1603        maybeAccept_impl   ( node->type  , *this );
1604
1605        VISIT_END( node );
1606}
1607
1608template< typename pass_type >
1609Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
1610        MUTATE_START( node );
1611
1612        indexerScopedMutate( node->env   , *this );
1613        indexerScopedMutate( node->result, *this );
1614        maybeMutate_impl   ( node->type  , *this );
1615
1616        MUTATE_END( Expression, node );
1617}
1618
1619//--------------------------------------------------------------------------
1620// OffsetPackExpr
1621template< typename pass_type >
1622void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
1623        VISIT_START( node );
1624
1625        indexerScopedAccept( node->result, *this );
1626        maybeAccept_impl   ( node->type  , *this );
1627
1628        VISIT_END( node );
1629}
1630
1631template< typename pass_type >
1632Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
1633        MUTATE_START( node );
1634
1635        indexerScopedMutate( node->env   , *this );
1636        indexerScopedMutate( node->result, *this );
1637        maybeMutate_impl   ( node->type  , *this );
1638
1639        MUTATE_END( Expression, node );
1640}
1641
1642//--------------------------------------------------------------------------
1643// AttrExpr
1644template< typename pass_type >
1645void PassVisitor< pass_type >::visit( AttrExpr * node ) {
1646        VISIT_START( node );
1647
1648        indexerScopedAccept( node->result, *this );
1649        if ( node->get_isType() ) {
1650                maybeAccept_impl( node->type, *this );
1651        } else {
1652                maybeAccept_impl( node->expr, *this );
1653        }
1654
1655        VISIT_END( node );
1656}
1657
1658template< typename pass_type >
1659Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
1660        MUTATE_START( node );
1661
1662        indexerScopedMutate( node->env   , *this );
1663        indexerScopedMutate( node->result, *this );
1664        if ( node->get_isType() ) {
1665                maybeMutate_impl( node->type, *this );
1666        } else {
1667                maybeMutate_impl( node->expr, *this );
1668        }
1669
1670        MUTATE_END( Expression, node );
1671}
1672
1673//--------------------------------------------------------------------------
1674// LogicalExpr
1675template< typename pass_type >
1676void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
1677        VISIT_START( node );
1678
1679        indexerScopedAccept( node->result, *this );
1680        maybeAccept_impl   ( node->arg1  , *this );
1681        maybeAccept_impl   ( node->arg2  , *this );
1682
1683        VISIT_END( node );
1684}
1685
1686template< typename pass_type >
1687Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
1688        MUTATE_START( node );
1689
1690        indexerScopedMutate( node->env   , *this );
1691        indexerScopedMutate( node->result, *this );
1692        maybeMutate_impl   ( node->arg1  , *this );
1693        maybeMutate_impl   ( node->arg2  , *this );
1694
1695        MUTATE_END( Expression, node );
1696}
1697
1698//--------------------------------------------------------------------------
1699// ConditionalExpr
1700template< typename pass_type >
1701void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
1702        VISIT_START( node );
1703
1704        indexerScopedAccept( node->result, *this );
1705        maybeAccept_impl        ( node->arg1  , *this );
1706        maybeAccept_impl        ( node->arg2  , *this );
1707        maybeAccept_impl        ( node->arg3  , *this );
1708
1709        VISIT_END( node );
1710}
1711
1712template< typename pass_type >
1713Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
1714        MUTATE_START( node );
1715
1716        indexerScopedMutate( node->env   , *this );
1717        indexerScopedMutate( node->result, *this );
1718        maybeMutate_impl   ( node->arg1  , *this );
1719        maybeMutate_impl   ( node->arg2  , *this );
1720        maybeMutate_impl   ( node->arg3  , *this );
1721
1722        MUTATE_END( Expression, node );
1723}
1724
1725//--------------------------------------------------------------------------
1726// CommaExpr
1727template< typename pass_type >
1728void PassVisitor< pass_type >::visit( CommaExpr * node ) {
1729        VISIT_START( node );
1730
1731        indexerScopedAccept( node->result, *this );
1732        maybeAccept_impl   ( node->arg1  , *this );
1733        maybeAccept_impl   ( node->arg2  , *this );
1734
1735        VISIT_END( node );
1736}
1737
1738template< typename pass_type >
1739Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
1740        MUTATE_START( node );
1741
1742        indexerScopedMutate( node->env   , *this );
1743        indexerScopedMutate( node->result, *this );
1744        maybeMutate_impl   ( node->arg1  , *this );
1745        maybeMutate_impl   ( node->arg2  , *this );
1746
1747        MUTATE_END( Expression, node );
1748}
1749
1750//--------------------------------------------------------------------------
1751// TypeExpr
1752template< typename pass_type >
1753void PassVisitor< pass_type >::visit( TypeExpr * node ) {
1754        VISIT_START( node );
1755
1756        indexerScopedAccept( node->result, *this );
1757        maybeAccept_impl   ( node->type, *this );
1758
1759        VISIT_END( node );
1760}
1761
1762template< typename pass_type >
1763Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
1764        MUTATE_START( node );
1765
1766        indexerScopedMutate( node->env   , *this );
1767        indexerScopedMutate( node->result, *this );
1768        maybeMutate_impl   ( node->type  , *this );
1769
1770        MUTATE_END( Expression, node );
1771}
1772
1773//--------------------------------------------------------------------------
1774// AsmExpr
1775template< typename pass_type >
1776void PassVisitor< pass_type >::visit( AsmExpr * node ) {
1777        VISIT_START( node );
1778
1779        indexerScopedAccept( node->result    , *this );
1780        maybeAccept_impl   ( node->inout     , *this );
1781        maybeAccept_impl   ( node->constraint, *this );
1782        maybeAccept_impl   ( node->operand   , *this );
1783
1784        VISIT_END( node );
1785}
1786
1787template< typename pass_type >
1788Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
1789        MUTATE_START( node );
1790
1791        indexerScopedMutate( node->env       , *this );
1792        indexerScopedMutate( node->result    , *this );
1793        maybeMutate_impl   ( node->inout     , *this );
1794        maybeMutate_impl   ( node->constraint, *this );
1795        maybeMutate_impl   ( node->operand   , *this );
1796
1797        MUTATE_END( Expression, node );
1798}
1799
1800//--------------------------------------------------------------------------
1801// ImplicitCopyCtorExpr
1802template< typename pass_type >
1803void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
1804        VISIT_START( node );
1805
1806        indexerScopedAccept( node->result     , *this );
1807        maybeAccept_impl   ( node->callExpr   , *this );
1808        maybeAccept_impl   ( node->tempDecls  , *this );
1809        maybeAccept_impl   ( node->returnDecls, *this );
1810        maybeAccept_impl   ( node->dtors      , *this );
1811
1812        VISIT_END( node );
1813}
1814
1815template< typename pass_type >
1816Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
1817        MUTATE_START( node );
1818
1819        indexerScopedMutate( node->env        , *this );
1820        indexerScopedMutate( node->result     , *this );
1821        maybeMutate_impl   ( node->callExpr   , *this );
1822        maybeMutate_impl   ( node->tempDecls  , *this );
1823        maybeMutate_impl   ( node->returnDecls, *this );
1824        maybeMutate_impl   ( node->dtors      , *this );
1825
1826        MUTATE_END( Expression, node );
1827}
1828
1829//--------------------------------------------------------------------------
1830// ConstructorExpr
1831template< typename pass_type >
1832void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
1833        VISIT_START( node );
1834
1835        indexerScopedAccept( node->result  , *this );
1836        maybeAccept_impl   ( node->callExpr, *this );
1837
1838        VISIT_END( node );
1839}
1840
1841template< typename pass_type >
1842Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
1843        MUTATE_START( node );
1844
1845        indexerScopedMutate( node->env     , *this );
1846        indexerScopedMutate( node->result  , *this );
1847        maybeMutate_impl   ( node->callExpr, *this );
1848
1849        MUTATE_END( Expression, node );
1850}
1851
1852//--------------------------------------------------------------------------
1853// CompoundLiteralExpr
1854template< typename pass_type >
1855void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
1856        VISIT_START( node );
1857
1858        indexerScopedAccept( node->result     , *this );
1859        maybeAccept_impl   ( node->initializer, *this );
1860
1861        VISIT_END( node );
1862}
1863
1864template< typename pass_type >
1865Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
1866        MUTATE_START( node );
1867
1868        indexerScopedMutate( node->env        , *this );
1869        indexerScopedMutate( node->result     , *this );
1870        maybeMutate_impl     ( node->initializer, *this );
1871
1872        MUTATE_END( Expression, node );
1873}
1874
1875//--------------------------------------------------------------------------
1876// RangeExpr
1877template< typename pass_type >
1878void PassVisitor< pass_type >::visit( RangeExpr * node ) {
1879        VISIT_START( node );
1880
1881        indexerScopedAccept( node->result, *this );
1882        maybeAccept_impl   ( node->low   , *this );
1883        maybeAccept_impl   ( node->high  , *this );
1884
1885        VISIT_END( node );
1886}
1887
1888template< typename pass_type >
1889Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
1890        MUTATE_START( node );
1891
1892        indexerScopedMutate( node->env   , *this );
1893        indexerScopedMutate( node->result, *this );
1894        maybeMutate_impl   ( node->low   , *this );
1895        maybeMutate_impl   ( node->high  , *this );
1896
1897        MUTATE_END( Expression, node );
1898}
1899
1900//--------------------------------------------------------------------------
1901// UntypedTupleExpr
1902template< typename pass_type >
1903void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
1904        VISIT_START( node );
1905
1906        indexerScopedAccept( node->result, *this );
1907        maybeAccept_impl   ( node->exprs , *this );
1908
1909        VISIT_END( node );
1910}
1911
1912template< typename pass_type >
1913Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
1914        MUTATE_START( node );
1915
1916        indexerScopedMutate( node->env   , *this );
1917        indexerScopedMutate( node->result, *this );
1918        maybeMutate_impl   ( node->exprs , *this );
1919
1920        MUTATE_END( Expression, node );
1921}
1922
1923//--------------------------------------------------------------------------
1924// TupleExpr
1925template< typename pass_type >
1926void PassVisitor< pass_type >::visit( TupleExpr * node ) {
1927        VISIT_START( node );
1928
1929        indexerScopedAccept( node->result, *this );
1930        maybeAccept_impl   ( node->exprs , *this );
1931
1932        VISIT_END( node );
1933}
1934
1935template< typename pass_type >
1936Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
1937        MUTATE_START( node );
1938
1939        indexerScopedMutate( node->env   , *this );
1940        indexerScopedMutate( node->result, *this );
1941        maybeMutate_impl   ( node->exprs , *this );
1942
1943        MUTATE_END( Expression, node );
1944}
1945
1946//--------------------------------------------------------------------------
1947// TupleIndexExpr
1948template< typename pass_type >
1949void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
1950        VISIT_START( node );
1951
1952        indexerScopedAccept( node->result, *this );
1953        maybeAccept_impl   ( node->tuple , *this );
1954
1955        VISIT_END( node );
1956}
1957
1958template< typename pass_type >
1959Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
1960        MUTATE_START( node );
1961
1962        indexerScopedMutate( node->env   , *this );
1963        indexerScopedMutate( node->result, *this );
1964        maybeMutate_impl   ( node->tuple , *this );
1965
1966        MUTATE_END( Expression, node );
1967}
1968
1969//--------------------------------------------------------------------------
1970// TupleAssignExpr
1971template< typename pass_type >
1972void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
1973        VISIT_START( node );
1974
1975        indexerScopedAccept( node->result  , *this );
1976        maybeAccept_impl   ( node->stmtExpr, *this );
1977
1978        VISIT_END( node );
1979}
1980
1981template< typename pass_type >
1982Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
1983        MUTATE_START( node );
1984
1985        indexerScopedMutate( node->env     , *this );
1986        indexerScopedMutate( node->result  , *this );
1987        maybeMutate_impl   ( node->stmtExpr, *this );
1988
1989        MUTATE_END( Expression, node );
1990}
1991
1992//--------------------------------------------------------------------------
1993// StmtExpr
1994template< typename pass_type >
1995void PassVisitor< pass_type >::visit( StmtExpr * node ) {
1996        VISIT_START( node );
1997
1998        // don't want statements from outer CompoundStmts to be added to this StmtExpr
1999        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
2000        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
2001        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
2002
2003        indexerScopedAccept( node->result     , *this );
2004        maybeAccept_impl   ( node->statements , *this );
2005        maybeAccept_impl   ( node->returnDecls, *this );
2006        maybeAccept_impl   ( node->dtors      , *this );
2007
2008        VISIT_END( node );
2009}
2010
2011template< typename pass_type >
2012Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
2013        MUTATE_START( node );
2014
2015        // don't want statements from outer CompoundStmts to be added to this StmtExpr
2016        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
2017        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
2018        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
2019
2020        indexerScopedMutate( node->result     , *this );
2021        maybeMutate_impl   ( node->statements , *this );
2022        maybeMutate_impl   ( node->returnDecls, *this );
2023        maybeMutate_impl   ( node->dtors      , *this );
2024
2025        MUTATE_END( Expression, node );
2026}
2027
2028//--------------------------------------------------------------------------
2029// UniqueExpr
2030template< typename pass_type >
2031void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
2032        VISIT_START( node );
2033
2034        indexerScopedAccept( node->result, *this );
2035        maybeAccept_impl   ( node->expr  , *this );
2036
2037        VISIT_END( node );
2038}
2039
2040template< typename pass_type >
2041Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
2042        MUTATE_START( node );
2043
2044        indexerScopedMutate( node->env   , *this );
2045        indexerScopedMutate( node->result, *this );
2046        maybeMutate_impl   ( node->expr  , *this );
2047
2048        MUTATE_END( Expression, node );
2049}
2050
2051//--------------------------------------------------------------------------
2052// UntypedInitExpr
2053template< typename pass_type >
2054void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) {
2055        VISIT_START( node );
2056
2057        indexerScopedAccept( node->result, *this );
2058        maybeAccept_impl   ( node->expr  , *this );
2059        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
2060
2061        VISIT_END( node );
2062}
2063
2064template< typename pass_type >
2065Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
2066        MUTATE_START( node );
2067
2068        indexerScopedMutate( node->env   , *this );
2069        indexerScopedMutate( node->result, *this );
2070        maybeMutate_impl   ( node->expr  , *this );
2071        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
2072
2073        MUTATE_END( Expression, node );
2074}
2075
2076//--------------------------------------------------------------------------
2077// InitExpr
2078template< typename pass_type >
2079void PassVisitor< pass_type >::visit( InitExpr * node ) {
2080        VISIT_START( node );
2081
2082        indexerScopedAccept( node->result, *this );
2083        maybeAccept_impl   ( node->expr  , *this );
2084        maybeAccept_impl   ( node->designation, *this );
2085
2086        VISIT_END( node );
2087}
2088
2089template< typename pass_type >
2090Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
2091        MUTATE_START( node );
2092
2093        indexerScopedMutate( node->env   , *this );
2094        indexerScopedMutate( node->result, *this );
2095        maybeMutate_impl   ( node->expr  , *this );
2096        maybeMutate_impl   ( node->designation, *this );
2097
2098        MUTATE_END( Expression, node );
2099}
2100
2101//--------------------------------------------------------------------------
2102// DeletedExpr
2103template< typename pass_type >
2104void PassVisitor< pass_type >::visit( DeletedExpr * node ) {
2105        VISIT_START( node );
2106
2107        indexerScopedAccept( node->result, *this );
2108        maybeAccept_impl( node->expr, *this );
2109        // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
2110
2111        VISIT_END( node );
2112}
2113
2114template< typename pass_type >
2115Expression * PassVisitor< pass_type >::mutate( DeletedExpr * node ) {
2116        MUTATE_START( node );
2117
2118        indexerScopedMutate( node->env, *this );
2119        indexerScopedMutate( node->result, *this );
2120        maybeMutate_impl( node->expr, *this );
2121
2122        MUTATE_END( Expression, node );
2123}
2124
2125//--------------------------------------------------------------------------
2126// DefaultArgExpr
2127template< typename pass_type >
2128void PassVisitor< pass_type >::visit( DefaultArgExpr * node ) {
2129        VISIT_START( node );
2130
2131        indexerScopedAccept( node->result, *this );
2132        maybeAccept_impl( node->expr, *this );
2133
2134        VISIT_END( node );
2135}
2136
2137template< typename pass_type >
2138Expression * PassVisitor< pass_type >::mutate( DefaultArgExpr * node ) {
2139        MUTATE_START( node );
2140
2141        indexerScopedMutate( node->env, *this );
2142        indexerScopedMutate( node->result, *this );
2143        maybeMutate_impl( node->expr, *this );
2144
2145        MUTATE_END( Expression, node );
2146}
2147
2148//--------------------------------------------------------------------------
2149// GenericExpr
2150template< typename pass_type >
2151void PassVisitor< pass_type >::visit( GenericExpr * node ) {
2152        VISIT_START( node );
2153
2154        indexerScopedAccept( node->result, *this );
2155        maybeAccept_impl( node->control, *this );
2156        for ( GenericExpr::Association & assoc : node->associations ) {
2157                indexerScopedAccept( assoc.type, *this );
2158                maybeAccept_impl( assoc.expr, *this );
2159        }
2160
2161        VISIT_END( node );
2162}
2163
2164template< typename pass_type >
2165Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) {
2166        MUTATE_START( node );
2167
2168        indexerScopedMutate( node->env, *this );
2169        indexerScopedMutate( node->result, *this );
2170        maybeMutate_impl( node->control, *this );
2171        for ( GenericExpr::Association & assoc : node->associations ) {
2172                indexerScopedMutate( assoc.type, *this );
2173                maybeMutate_impl( assoc.expr, *this );
2174        }
2175
2176        MUTATE_END( Expression, node );
2177}
2178
2179//--------------------------------------------------------------------------
2180// VoidType
2181template< typename pass_type >
2182void PassVisitor< pass_type >::visit( VoidType * node ) {
2183        VISIT_START( node );
2184
2185        maybeAccept_impl( node->forall, *this );
2186
2187        VISIT_END( node );
2188}
2189
2190template< typename pass_type >
2191Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
2192        MUTATE_START( node );
2193
2194        maybeMutate_impl( node->forall, *this );
2195
2196        MUTATE_END( Type, node );
2197}
2198
2199//--------------------------------------------------------------------------
2200// BasicType
2201template< typename pass_type >
2202void PassVisitor< pass_type >::visit( BasicType * node ) {
2203        VISIT_START( node );
2204
2205        maybeAccept_impl( node->forall, *this );
2206
2207        VISIT_END( node );
2208}
2209
2210template< typename pass_type >
2211Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
2212        MUTATE_START( node );
2213
2214        maybeMutate_impl( node->forall, *this );
2215
2216        MUTATE_END( Type, node );
2217}
2218
2219//--------------------------------------------------------------------------
2220// PointerType
2221template< typename pass_type >
2222void PassVisitor< pass_type >::visit( PointerType * node ) {
2223        VISIT_START( node );
2224
2225        maybeAccept_impl( node->forall, *this );
2226        // xxx - should PointerType visit/mutate dimension?
2227        maybeAccept_impl( node->base, *this );
2228
2229        VISIT_END( node );
2230}
2231
2232template< typename pass_type >
2233Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
2234        MUTATE_START( node );
2235
2236        maybeMutate_impl( node->forall, *this );
2237        // xxx - should PointerType visit/mutate dimension?
2238        maybeMutate_impl( node->base, *this );
2239
2240        MUTATE_END( Type, node );
2241}
2242
2243//--------------------------------------------------------------------------
2244// ArrayType
2245template< typename pass_type >
2246void PassVisitor< pass_type >::visit( ArrayType * node ) {
2247        VISIT_START( node );
2248
2249        maybeAccept_impl( node->forall, *this );
2250        maybeAccept_impl( node->dimension, *this );
2251        maybeAccept_impl( node->base, *this );
2252
2253        VISIT_END( node );
2254}
2255
2256template< typename pass_type >
2257Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
2258        MUTATE_START( node );
2259
2260        maybeMutate_impl( node->forall, *this );
2261        maybeMutate_impl( node->dimension, *this );
2262        maybeMutate_impl( node->base, *this );
2263
2264        MUTATE_END( Type, node );
2265}
2266
2267//--------------------------------------------------------------------------
2268// ReferenceType
2269template< typename pass_type >
2270void PassVisitor< pass_type >::visit( ReferenceType * node ) {
2271        VISIT_START( node );
2272
2273        maybeAccept_impl( node->forall, *this );
2274        maybeAccept_impl( node->base, *this );
2275
2276        VISIT_END( node );
2277}
2278
2279template< typename pass_type >
2280Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
2281        MUTATE_START( node );
2282
2283        maybeMutate_impl( node->forall, *this );
2284        maybeMutate_impl( node->base, *this );
2285
2286        MUTATE_END( Type, node );
2287}
2288
2289//--------------------------------------------------------------------------
2290// QualifiedType
2291template< typename pass_type >
2292void PassVisitor< pass_type >::visit( QualifiedType * node ) {
2293        VISIT_START( node );
2294
2295        maybeAccept_impl( node->forall, *this );
2296        maybeAccept_impl( node->parent, *this );
2297        maybeAccept_impl( node->child, *this );
2298
2299        VISIT_END( node );
2300}
2301
2302template< typename pass_type >
2303Type * PassVisitor< pass_type >::mutate( QualifiedType * node ) {
2304        MUTATE_START( node );
2305
2306        maybeMutate_impl( node->forall, *this );
2307        maybeMutate_impl( node->parent, *this );
2308        maybeMutate_impl( node->child, *this );
2309
2310        MUTATE_END( Type, node );
2311}
2312
2313//--------------------------------------------------------------------------
2314// FunctionType
2315template< typename pass_type >
2316void PassVisitor< pass_type >::visit( FunctionType * node ) {
2317        VISIT_START( node );
2318
2319        maybeAccept_impl( node->forall, *this );
2320        maybeAccept_impl( node->returnVals, *this );
2321        maybeAccept_impl( node->parameters, *this );
2322
2323        VISIT_END( node );
2324}
2325
2326template< typename pass_type >
2327Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
2328        MUTATE_START( node );
2329
2330        maybeMutate_impl( node->forall, *this );
2331        maybeMutate_impl( node->returnVals, *this );
2332        maybeMutate_impl( node->parameters, *this );
2333
2334        MUTATE_END( Type, node );
2335}
2336
2337//--------------------------------------------------------------------------
2338// StructInstType
2339template< typename pass_type >
2340void PassVisitor< pass_type >::visit( StructInstType * node ) {
2341        VISIT_START( node );
2342
2343        indexerAddStruct( node->name );
2344
2345        {
2346                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
2347                maybeAccept_impl( node->forall    , *this );
2348                maybeAccept_impl( node->parameters, *this );
2349        }
2350
2351        VISIT_END( node );
2352}
2353
2354template< typename pass_type >
2355Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
2356        MUTATE_START( node );
2357
2358        indexerAddStruct( node->name );
2359
2360        {
2361                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
2362                maybeMutate_impl( node->forall    , *this );
2363                maybeMutate_impl( node->parameters, *this );
2364        }
2365
2366        MUTATE_END( Type, node );
2367}
2368
2369//--------------------------------------------------------------------------
2370// UnionInstType
2371template< typename pass_type >
2372void PassVisitor< pass_type >::visit( UnionInstType * node ) {
2373        VISIT_START( node );
2374
2375        indexerAddStruct( node->name );
2376
2377        {
2378                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
2379                maybeAccept_impl( node->forall    , *this );
2380                maybeAccept_impl( node->parameters, *this );
2381        }
2382
2383        VISIT_END( node );
2384}
2385
2386template< typename pass_type >
2387Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
2388        MUTATE_START( node );
2389
2390        indexerAddStruct( node->name );
2391
2392        {
2393                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
2394                maybeMutate_impl( node->forall    , *this );
2395                maybeMutate_impl( node->parameters, *this );
2396        }
2397
2398        MUTATE_END( Type, node );
2399}
2400
2401//--------------------------------------------------------------------------
2402// EnumInstType
2403template< typename pass_type >
2404void PassVisitor< pass_type >::visit( EnumInstType * node ) {
2405        VISIT_START( node );
2406
2407        maybeAccept_impl( node->forall, *this );
2408        maybeAccept_impl( node->parameters, *this );
2409
2410        VISIT_END( node );
2411}
2412
2413template< typename pass_type >
2414Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
2415        MUTATE_START( node );
2416
2417        maybeMutate_impl( node->forall, *this );
2418        maybeMutate_impl( node->parameters, *this );
2419
2420        MUTATE_END( Type, node );
2421}
2422
2423//--------------------------------------------------------------------------
2424// TraitInstType
2425template< typename pass_type >
2426void PassVisitor< pass_type >::visit( TraitInstType * node ) {
2427        VISIT_START( node );
2428
2429        maybeAccept_impl( node->forall    , *this );
2430        maybeAccept_impl( node->parameters, *this );
2431
2432        VISIT_END( node );
2433}
2434
2435template< typename pass_type >
2436Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
2437        MUTATE_START( node );
2438
2439        maybeMutate_impl( node->forall    , *this );
2440        maybeMutate_impl( node->parameters, *this );
2441
2442        MUTATE_END( Type, node );
2443}
2444
2445//--------------------------------------------------------------------------
2446// TypeInstType
2447template< typename pass_type >
2448void PassVisitor< pass_type >::visit( TypeInstType * node ) {
2449        VISIT_START( node );
2450
2451        maybeAccept_impl( node->forall    , *this );
2452        maybeAccept_impl( node->parameters, *this );
2453
2454        VISIT_END( node );
2455}
2456
2457template< typename pass_type >
2458Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
2459        MUTATE_START( node );
2460
2461        maybeMutate_impl( node->forall    , *this );
2462        maybeMutate_impl( node->parameters, *this );
2463
2464        MUTATE_END( Type, node );
2465}
2466
2467//--------------------------------------------------------------------------
2468// TupleType
2469template< typename pass_type >
2470void PassVisitor< pass_type >::visit( TupleType * node ) {
2471        VISIT_START( node );
2472
2473        maybeAccept_impl( node->forall, *this );
2474        maybeAccept_impl( node->types, *this );
2475        maybeAccept_impl( node->members, *this );
2476
2477        VISIT_END( node );
2478}
2479
2480template< typename pass_type >
2481Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
2482        MUTATE_START( node );
2483
2484        maybeMutate_impl( node->forall, *this );
2485        maybeMutate_impl( node->types, *this );
2486        maybeMutate_impl( node->members, *this );
2487
2488        MUTATE_END( Type, node );
2489}
2490
2491//--------------------------------------------------------------------------
2492// TypeofType
2493template< typename pass_type >
2494void PassVisitor< pass_type >::visit( TypeofType * node ) {
2495        VISIT_START( node );
2496
2497        assert( node->expr );
2498        maybeAccept_impl( node->expr, *this );
2499
2500        VISIT_END( node );
2501}
2502
2503template< typename pass_type >
2504Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
2505        MUTATE_START( node );
2506
2507        assert( node->expr );
2508        maybeMutate_impl( node->expr, *this );
2509
2510        MUTATE_END( Type, node );
2511}
2512
2513//--------------------------------------------------------------------------
2514// AttrType
2515template< typename pass_type >
2516void PassVisitor< pass_type >::visit( AttrType * node ) {
2517        VISIT_START( node );
2518
2519        if ( node->isType ) {
2520                assert( node->type );
2521                maybeAccept_impl( node->type, *this );
2522        } else {
2523                assert( node->expr );
2524                maybeAccept_impl( node->expr, *this );
2525        } // if
2526
2527        VISIT_END( node );
2528}
2529
2530template< typename pass_type >
2531Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
2532        MUTATE_START( node );
2533
2534        if ( node->isType ) {
2535                assert( node->type );
2536                maybeMutate_impl( node->type, *this );
2537        } else {
2538                assert( node->expr );
2539                maybeMutate_impl( node->expr, *this );
2540        } // if
2541
2542        MUTATE_END( Type, node );
2543}
2544
2545//--------------------------------------------------------------------------
2546// VarArgsType
2547template< typename pass_type >
2548void PassVisitor< pass_type >::visit( VarArgsType * node ) {
2549        VISIT_START( node );
2550
2551        maybeAccept_impl( node->forall, *this );
2552
2553        VISIT_END( node );
2554}
2555
2556template< typename pass_type >
2557Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
2558        MUTATE_START( node );
2559
2560        maybeMutate_impl( node->forall, *this );
2561
2562        MUTATE_END( Type, node );
2563}
2564
2565//--------------------------------------------------------------------------
2566// ZeroType
2567template< typename pass_type >
2568void PassVisitor< pass_type >::visit( ZeroType * node ) {
2569        VISIT_START( node );
2570
2571        maybeAccept_impl( node->forall, *this );
2572
2573        VISIT_END( node );
2574}
2575
2576template< typename pass_type >
2577Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
2578        MUTATE_START( node );
2579
2580        maybeMutate_impl( node->forall, *this );
2581
2582        MUTATE_END( Type, node );
2583}
2584
2585//--------------------------------------------------------------------------
2586// OneType
2587template< typename pass_type >
2588void PassVisitor< pass_type >::visit( OneType * node ) {
2589        VISIT_START( node );
2590
2591        maybeAccept_impl( node->forall, *this );
2592
2593        VISIT_END( node );
2594}
2595
2596template< typename pass_type >
2597Type * PassVisitor< pass_type >::mutate( OneType * node ) {
2598        MUTATE_START( node );
2599
2600        maybeMutate_impl( node->forall, *this );
2601
2602        MUTATE_END( Type, node );
2603}
2604
2605//--------------------------------------------------------------------------
2606// GlobalScopeType
2607template< typename pass_type >
2608void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
2609        VISIT_START( node );
2610
2611        maybeAccept_impl( node->forall, *this );
2612
2613        VISIT_END( node );
2614}
2615
2616template< typename pass_type >
2617Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
2618        MUTATE_START( node );
2619
2620        maybeMutate_impl( node->forall, *this );
2621
2622        MUTATE_END( Type, node );
2623}
2624
2625//--------------------------------------------------------------------------
2626// Designation
2627template< typename pass_type >
2628void PassVisitor< pass_type >::visit( Designation * node ) {
2629        VISIT_START( node );
2630
2631        maybeAccept_impl( node->designators, *this );
2632
2633        VISIT_END( node );
2634}
2635
2636template< typename pass_type >
2637Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
2638        MUTATE_START( node );
2639
2640        maybeMutate_impl( node->designators, *this );
2641
2642        MUTATE_END( Designation, node );
2643}
2644
2645//--------------------------------------------------------------------------
2646// SingleInit
2647template< typename pass_type >
2648void PassVisitor< pass_type >::visit( SingleInit * node ) {
2649        VISIT_START( node );
2650
2651        visitExpression( node->value );
2652
2653        VISIT_END( node );
2654}
2655
2656template< typename pass_type >
2657Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
2658        MUTATE_START( node );
2659
2660        node->value = mutateExpression( node->value );
2661
2662        MUTATE_END( Initializer, node );
2663}
2664
2665//--------------------------------------------------------------------------
2666// ListInit
2667template< typename pass_type >
2668void PassVisitor< pass_type >::visit( ListInit * node ) {
2669        VISIT_START( node );
2670
2671        maybeAccept_impl( node->designations, *this );
2672        maybeAccept_impl( node->initializers, *this );
2673
2674        VISIT_END( node );
2675}
2676
2677template< typename pass_type >
2678Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
2679        MUTATE_START( node );
2680
2681        maybeMutate_impl( node->designations, *this );
2682        maybeMutate_impl( node->initializers, *this );
2683
2684        MUTATE_END( Initializer, node );
2685}
2686
2687//--------------------------------------------------------------------------
2688// ConstructorInit
2689template< typename pass_type >
2690void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
2691        VISIT_START( node );
2692
2693        maybeAccept_impl( node->ctor, *this );
2694        maybeAccept_impl( node->dtor, *this );
2695        maybeAccept_impl( node->init, *this );
2696
2697        VISIT_END( node );
2698}
2699
2700template< typename pass_type >
2701Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
2702        MUTATE_START( node );
2703
2704        maybeMutate_impl( node->ctor, *this );
2705        maybeMutate_impl( node->dtor, *this );
2706        maybeMutate_impl( node->init, *this );
2707
2708        MUTATE_END( Initializer, node );
2709}
2710
2711//--------------------------------------------------------------------------
2712// Subrange
2713template< typename pass_type >
2714void PassVisitor< pass_type >::visit( Subrange * node ) {
2715        VISIT_START( node );
2716
2717        VISIT_END( node );
2718}
2719
2720template< typename pass_type >
2721Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
2722        MUTATE_START( node );
2723
2724        MUTATE_END( Subrange, node );
2725}
2726
2727//--------------------------------------------------------------------------
2728// Attribute
2729template< typename pass_type >
2730void PassVisitor< pass_type >::visit( Constant * node ) {
2731        VISIT_START( node );
2732
2733        VISIT_END( node );
2734}
2735
2736template< typename pass_type >
2737Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
2738        MUTATE_START( node );
2739
2740        MUTATE_END( Constant, node );
2741}
2742
2743//--------------------------------------------------------------------------
2744// Attribute
2745template< typename pass_type >
2746void PassVisitor< pass_type >::visit( Attribute * node ) {
2747        VISIT_START( node );
2748
2749        maybeAccept_impl( node->parameters, *this );
2750
2751        VISIT_END( node );
2752}
2753
2754template< typename pass_type >
2755Attribute * PassVisitor< pass_type >::mutate( Attribute * node  )  {
2756        MUTATE_START( node );
2757
2758        maybeMutate_impl( node->parameters, *this );
2759
2760        MUTATE_END( Attribute, node );
2761}
2762
2763//--------------------------------------------------------------------------
2764// TypeSubstitution
2765template< typename pass_type >
2766TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
2767        MUTATE_START( node );
2768
2769        for ( auto & p : node->typeEnv ) {
2770                indexerScopedMutate( p.second, *this );
2771        }
2772        for ( auto & p : node->varEnv ) {
2773                indexerScopedMutate( p.second, *this );
2774        }
2775
2776        MUTATE_END( TypeSubstitution, node );
2777}
Note: See TracBrowser for help on using the repository browser.