source: src/Common/PassVisitor.impl.h@ c935c3a

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since c935c3a was 982832e, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
  • Property mode set to 100644
File size: 56.1 KB
Line 
1#pragma once
2// IWYU pragma: private, include "PassVisitor.h"
3
4#define VISIT_START( node ) \
5 __attribute__((unused)) \
6 guard_value_impl guard( at_cleanup_impl(pass, 0) ); \
7 bool visit_children = true; \
8 set_visit_children( visit_children ); \
9 call_previsit( node ); \
10 if( visit_children ) { \
11
12#define VISIT_END( node ) \
13 } \
14 call_postvisit( node ); \
15
16#define MUTATE_START( node ) \
17 __attribute__((unused)) \
18 guard_value_impl guard( at_cleanup_impl(pass, 0) ); \
19 bool visit_children = true; \
20 set_visit_children( visit_children ); \
21 call_premutate( node ); \
22 if( visit_children ) { \
23
24#define MUTATE_END( type, node ) \
25 } \
26 return call_postmutate< type * >( node ); \
27
28
29#define VISIT_BODY( node ) \
30 VISIT_START( node ); \
31 Visitor::visit( node ); \
32 VISIT_END( node ); \
33
34
35#define MUTATE_BODY( type, node ) \
36 MUTATE_START( node ); \
37 Mutator::mutate( node ); \
38 MUTATE_END( type, node ); \
39
40
41
42template<typename T>
43static inline bool empty( T * ptr ) {
44 return !ptr || ptr->empty();
45}
46
47typedef std::list< Statement * > StmtList_t;
48typedef std::list< Declaration * > DeclList_t;
49
50template<typename iterator_t>
51static inline void splice( iterator_t it, DeclList_t * decls ) {
52 std::transform(
53 decls->begin(),
54 decls->end(),
55 it,
56 [](Declaration * decl) -> auto {
57 return new DeclStmt( noLabels, decl );
58 }
59 );
60 decls->clear();
61}
62
63template< typename pass_type >
64static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
65
66 DeclList_t* beforeDecls = visitor.get_beforeDecls();
67 DeclList_t* afterDecls = visitor.get_afterDecls();
68
69 for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
70 // splice in new declarations after previous decl
71 if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
72
73 if ( i == decls.end() ) break;
74
75 // run mutator on declaration
76 maybeAccept( *i, visitor );
77
78 // splice in new declarations before current decl
79 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
80 }
81}
82
83template< typename pass_type >
84static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
85
86 DeclList_t* beforeDecls = mutator.get_beforeDecls();
87 DeclList_t* afterDecls = mutator.get_afterDecls();
88
89 for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
90 // splice in new declarations after previous decl
91 if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
92
93 if ( i == decls.end() ) break;
94
95 // run mutator on declaration
96 *i = maybeMutate( *i, mutator );
97
98 // splice in new declarations before current decl
99 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
100 }
101}
102
103template< typename Container, typename VisitorType >
104inline void maybeAccept( Container &container, VisitorType &visitor ) {
105 SemanticError errors;
106 for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
107 try {
108 if ( *i ) {
109 (*i)->accept( visitor );
110 }
111 } catch( SemanticError &e ) {
112 e.set_location( (*i)->location );
113 errors.append( e );
114 }
115 }
116 if ( ! errors.isEmpty() ) {
117 throw errors;
118 }
119}
120
121template< typename Container, typename MutatorType >
122inline void maybeMutateRef( Container &container, MutatorType &mutator ) {
123 SemanticError errors;
124 for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
125 try {
126 if ( *i ) {
127/// *i = (*i)->acceptMutator( mutator );
128 *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
129 assert( *i );
130 } // if
131 } catch( SemanticError &e ) {
132 e.set_location( (*i)->location );
133 errors.append( e );
134 } // try
135 } // for
136 if ( ! errors.isEmpty() ) {
137 throw errors;
138 } // if
139}
140
141template< typename pass_type >
142template< typename func_t >
143void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
144 SemanticError errors;
145
146 // don't want statements from outer CompoundStmts to be added to this CompoundStmt
147 ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
148 ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
149 ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
150 ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
151
152 StmtList_t* beforeStmts = get_beforeStmts();
153 StmtList_t* afterStmts = get_afterStmts();
154 DeclList_t* beforeDecls = get_beforeDecls();
155 DeclList_t* afterDecls = get_afterDecls();
156
157 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
158
159 if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
160 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
161
162 try {
163 func( *i );
164 assert(( empty( beforeStmts ) && empty( afterStmts ))
165 || ( empty( beforeDecls ) && empty( afterDecls )) );
166
167 } catch ( SemanticError &e ) {
168 errors.append( e );
169 }
170
171 if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
172 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
173 }
174
175 if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
176 if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
177 if ( !errors.isEmpty() ) { throw errors; }
178}
179
180template< typename pass_type >
181void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
182 handleStatementList( statements, [this]( Statement * stmt) {
183 stmt->accept( *this );
184 });
185}
186
187template< typename pass_type >
188void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
189 handleStatementList( statements, [this]( Statement *& stmt) {
190 stmt = stmt->acceptMutator( *this );
191 });
192}
193
194
195template< typename pass_type >
196template< typename func_t >
197Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
198 // don't want statements from outer CompoundStmts to be added to this CompoundStmt
199 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr () );
200 ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
201 ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
202 ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
203 ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
204
205 Statement *newStmt = func( stmt );
206
207 StmtList_t* beforeStmts = get_beforeStmts();
208 StmtList_t* afterStmts = get_afterStmts();
209 DeclList_t* beforeDecls = get_beforeDecls();
210 DeclList_t* afterDecls = get_afterDecls();
211
212 if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
213 assert(( empty( beforeStmts ) && empty( afterStmts ))
214 || ( empty( beforeDecls ) && empty( afterDecls )) );
215
216 CompoundStmt *compound = new CompoundStmt( noLabels );
217 if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
218 if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
219 compound->get_kids().push_back( newStmt );
220 if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
221 if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
222 return compound;
223}
224
225template< typename pass_type >
226Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
227 return handleStatement( stmt, [this]( Statement * stmt ) {
228 maybeAccept( stmt, *this );
229 return stmt;
230 });
231}
232
233template< typename pass_type >
234Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
235 return handleStatement( stmt, [this]( Statement * stmt ) {
236 return maybeMutate( stmt, *this );
237 });
238}
239
240template< typename pass_type >
241template< typename func_t >
242Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
243 if( !expr ) return nullptr;
244
245 auto env_ptr = get_env_ptr();
246 if ( env_ptr && expr->get_env() ) {
247 *env_ptr = expr->get_env();
248 }
249
250 // should env be cloned (or moved) onto the result of the mutate?
251 return func( expr );
252}
253
254template< typename pass_type >
255Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
256 return handleExpression(expr, [this]( Expression * expr ) {
257 expr->accept( *this );
258 return expr;
259 });
260}
261
262template< typename pass_type >
263Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
264 return handleExpression(expr, [this]( Expression * expr ) {
265 return expr->acceptMutator( *this );
266 });
267}
268
269//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
270//========================================================================================================================================================================
271//========================================================================================================================================================================
272//========================================================================================================================================================================
273//========================================================================================================================================================================
274//========================================================================================================================================================================
275//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
276
277
278//--------------------------------------------------------------------------
279// ObjectDecl
280template< typename pass_type >
281void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
282 VISIT_START( node );
283
284 indexerScopedAccept( node->type , *this );
285 maybeAccept ( node->init , *this );
286 maybeAccept ( node->bitfieldWidth, *this );
287
288 if ( node->name != "" ) {
289 indexerAddId( node );
290 }
291
292 VISIT_END( node );
293}
294
295template< typename pass_type >
296DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
297 MUTATE_START( node );
298
299 indexerScopedMutate( node->type , *this );
300 maybeMutateRef ( node->init , *this );
301 maybeMutateRef ( node->bitfieldWidth, *this );
302
303 if ( node->name != "" ) {
304 indexerAddId( node );
305 }
306
307 MUTATE_END( DeclarationWithType, node );
308}
309
310//--------------------------------------------------------------------------
311// FunctionDecl
312template< typename pass_type >
313void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
314 VISIT_START( node );
315
316 if ( node->name != "" ) {
317 indexerAddId( node );
318 }
319
320 {
321 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
322 maybeAccept( node->type, *this );
323 maybeAccept( node->statements, *this );
324 }
325
326 VISIT_END( node );
327}
328
329template< typename pass_type >
330DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
331 MUTATE_START( node );
332
333 if ( node->name != "" ) {
334 indexerAddId( node );
335 }
336
337 {
338 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
339 maybeMutateRef( node->type, *this );
340 maybeMutateRef( node->statements, *this );
341 }
342
343 MUTATE_END( DeclarationWithType, node );
344}
345
346//--------------------------------------------------------------------------
347// StructDecl
348template< typename pass_type >
349void PassVisitor< pass_type >::visit( StructDecl * node ) {
350 VISIT_START( node );
351
352 // make up a forward declaration and add it before processing the members
353 // needs to be on the heap because addStruct saves the pointer
354 indexerAddStructFwd( node );
355
356 {
357 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
358 maybeAccept( node->parameters, *this );
359 maybeAccept( node->members , *this );
360 }
361
362 // this addition replaces the forward declaration
363 indexerAddStruct( node );
364
365 VISIT_END( node );
366}
367
368template< typename pass_type >
369Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
370 MUTATE_START( node );
371
372 // make up a forward declaration and add it before processing the members
373 // needs to be on the heap because addStruct saves the pointer
374 indexerAddStructFwd( node );
375
376 {
377 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
378 maybeMutateRef( node->parameters, *this );
379 maybeMutateRef( node->members , *this );
380 }
381
382 // this addition replaces the forward declaration
383 indexerAddStruct( node );
384
385 MUTATE_END( Declaration, node );
386}
387
388//--------------------------------------------------------------------------
389// UnionDecl
390template< typename pass_type >
391void PassVisitor< pass_type >::visit( UnionDecl * node ) {
392 VISIT_START( node );
393
394 // make up a forward declaration and add it before processing the members
395 indexerAddUnionFwd( node );
396
397 {
398 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
399 maybeAccept( node->parameters, *this );
400 maybeAccept( node->members , *this );
401 }
402
403 indexerAddUnion( node );
404
405 VISIT_END( node );
406}
407
408template< typename pass_type >
409Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
410 MUTATE_START( node );
411
412 // make up a forward declaration and add it before processing the members
413 indexerAddUnionFwd( node );
414
415 {
416 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
417 maybeMutateRef( node->parameters, *this );
418 maybeMutateRef( node->members , *this );
419 }
420
421 indexerAddUnion( node );
422
423 MUTATE_END( Declaration, node );
424}
425
426//--------------------------------------------------------------------------
427// EnumDecl
428template< typename pass_type >
429void PassVisitor< pass_type >::visit( EnumDecl * node ) {
430 VISIT_START( node );
431
432 indexerAddEnum( node );
433
434 // unlike structs, contexts, and unions, enums inject their members into the global scope
435 maybeAccept( node->parameters, *this );
436 maybeAccept( node->members , *this );
437
438 VISIT_END( node );
439}
440
441template< typename pass_type >
442Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
443 MUTATE_START( node );
444
445 indexerAddEnum( node );
446
447 // unlike structs, contexts, and unions, enums inject their members into the global scope
448 maybeMutateRef( node->parameters, *this );
449 maybeMutateRef( node->members , *this );
450
451 MUTATE_END( Declaration, node );
452}
453
454//--------------------------------------------------------------------------
455// TraitDecl
456template< typename pass_type >
457void PassVisitor< pass_type >::visit( TraitDecl * node ) {
458 VISIT_START( node );
459
460 {
461 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
462 maybeAccept( node->parameters, *this );
463 maybeAccept( node->members , *this );
464 }
465
466 indexerAddTrait( node );
467
468 VISIT_END( node );
469}
470
471template< typename pass_type >
472Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
473 MUTATE_START( node );
474
475 {
476 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
477 maybeMutateRef( node->parameters, *this );
478 maybeMutateRef( node->members , *this );
479 }
480
481 indexerAddTrait( node );
482
483 MUTATE_END( Declaration, node );
484}
485
486//--------------------------------------------------------------------------
487// TypeDecl
488template< typename pass_type >
489void PassVisitor< pass_type >::visit( TypeDecl * node ) {
490 VISIT_START( node );
491
492 {
493 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
494 maybeAccept( node->parameters, *this );
495 maybeAccept( node->base , *this );
496 }
497
498 indexerAddType( node );
499
500 maybeAccept( node->assertions, *this );
501
502 indexerScopedAccept( node->init, *this );
503
504 VISIT_END( node );
505}
506
507template< typename pass_type >
508Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
509 MUTATE_START( node );
510
511 {
512 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
513 maybeMutateRef( node->parameters, *this );
514 maybeMutateRef( node->base , *this );
515 }
516
517 indexerAddType( node );
518
519 maybeMutateRef( node->assertions, *this );
520
521 indexerScopedMutate( node->init, *this );
522
523 MUTATE_END( Declaration, node );
524}
525
526//--------------------------------------------------------------------------
527// TypedefDecl
528template< typename pass_type >
529void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
530 VISIT_START( node );
531
532 {
533 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
534 maybeAccept( node->parameters, *this );
535 maybeAccept( node->base , *this );
536 }
537
538 indexerAddType( node );
539
540 maybeAccept( node->assertions, *this );
541
542 VISIT_END( node );
543}
544
545template< typename pass_type >
546Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
547 MUTATE_START( node );
548
549 {
550 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
551 maybeMutateRef ( node->parameters, *this );
552 maybeMutateRef( node->base , *this );
553 }
554
555 indexerAddType( node );
556
557 maybeMutateRef( node->assertions, *this );
558
559 MUTATE_END( Declaration, node );
560}
561
562//--------------------------------------------------------------------------
563// AsmDecl
564template< typename pass_type >
565void PassVisitor< pass_type >::visit( AsmDecl * node ) {
566 VISIT_START( node );
567
568 maybeAccept( node->stmt, *this );
569
570 VISIT_END( node );
571}
572
573template< typename pass_type >
574AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
575 MUTATE_START( node );
576
577 maybeMutateRef( node->stmt, *this );
578
579 MUTATE_END( AsmDecl, node );
580}
581
582//--------------------------------------------------------------------------
583// CompoundStmt
584template< typename pass_type >
585void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
586 VISIT_START( node );
587 {
588 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
589 auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
590 visitStatementList( node->kids );
591 }
592 VISIT_END( node );
593}
594
595template< typename pass_type >
596CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
597 MUTATE_START( node );
598 {
599 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
600 auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
601 mutateStatementList( node->kids );
602 }
603 MUTATE_END( CompoundStmt, node );
604}
605
606//--------------------------------------------------------------------------
607// ExprStmt
608template< typename pass_type >
609void PassVisitor< pass_type >::visit( ExprStmt * node ) {
610 VISIT_START( node );
611
612 visitExpression( node->expr );
613
614 VISIT_END( node );
615}
616
617template< typename pass_type >
618Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
619 MUTATE_START( node );
620
621 node->expr = mutateExpression( node->expr );
622
623 MUTATE_END( Statement, node );
624}
625
626//--------------------------------------------------------------------------
627// AsmStmt
628template< typename pass_type >
629void PassVisitor< pass_type >::visit( AsmStmt * node ) {
630 VISIT_BODY( node );
631}
632
633template< typename pass_type >
634Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
635 MUTATE_BODY( Statement, node );
636}
637
638//--------------------------------------------------------------------------
639// IfStmt
640template< typename pass_type >
641void PassVisitor< pass_type >::visit( IfStmt * node ) {
642 VISIT_START( node );
643
644 visitExpression( node->condition );
645 node->thenPart = visitStatement( node->thenPart );
646 node->elsePart = visitStatement( node->elsePart );
647
648 VISIT_END( node );
649}
650
651template< typename pass_type >
652Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
653 MUTATE_START( node );
654 {
655 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
656 node->condition = mutateExpression( node->condition );
657 node->thenPart = mutateStatement ( node->thenPart );
658 node->elsePart = mutateStatement ( node->elsePart );
659 }
660 MUTATE_END( Statement, node );
661}
662
663//--------------------------------------------------------------------------
664// WhileStmt
665template< typename pass_type >
666void PassVisitor< pass_type >::visit( WhileStmt * node ) {
667 VISIT_START( node );
668
669 visitExpression( node->condition );
670 node->body = visitStatement( node->body );
671
672 VISIT_END( node );
673}
674
675template< typename pass_type >
676Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
677 MUTATE_START( node );
678
679 node->condition = mutateExpression( node->condition );
680 node->body = mutateStatement ( node->body );
681
682 MUTATE_END( Statement, node );
683}
684
685//--------------------------------------------------------------------------
686// ForStmt
687template< typename pass_type >
688void PassVisitor< pass_type >::visit( ForStmt * node ) {
689 VISIT_START( node );
690 {
691 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
692 maybeAccept( node->initialization, *this );
693 visitExpression( node->condition );
694 visitExpression( node->increment );
695 node->body = visitStatement( node->body );
696 }
697 VISIT_END( node );
698}
699
700template< typename pass_type >
701Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
702 MUTATE_START( node );
703 {
704 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
705 maybeMutateRef( node->initialization, *this );
706 node->condition = mutateExpression( node->condition );
707 node->increment = mutateExpression( node->increment );
708 node->body = mutateStatement ( node->body );
709 }
710 MUTATE_END( Statement, node );
711}
712
713//--------------------------------------------------------------------------
714// SwitchStmt
715template< typename pass_type >
716void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
717 VISIT_START( node );
718
719 visitExpression ( node->condition );
720 visitStatementList( node->statements );
721
722 VISIT_END( node );
723}
724
725template< typename pass_type >
726Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
727 MUTATE_START( node );
728
729 node->condition = mutateExpression( node->condition );
730 mutateStatementList( node->statements );
731
732 MUTATE_END( Statement, node );
733}
734
735//--------------------------------------------------------------------------
736// CaseStmt
737template< typename pass_type >
738void PassVisitor< pass_type >::visit( CaseStmt * node ) {
739 VISIT_START( node );
740
741 visitExpression ( node->condition );
742 visitStatementList( node->stmts );
743
744 VISIT_END( node );
745}
746
747template< typename pass_type >
748Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
749 MUTATE_START( node );
750
751 node->condition = mutateExpression( node->condition );
752 mutateStatementList( node->stmts );
753
754 MUTATE_END( Statement, node );
755}
756
757//--------------------------------------------------------------------------
758// BranchStmt
759template< typename pass_type >
760void PassVisitor< pass_type >::visit( BranchStmt * node ) {
761 VISIT_BODY( node );
762}
763
764template< typename pass_type >
765Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
766 MUTATE_BODY( Statement, node );
767}
768
769//--------------------------------------------------------------------------
770// ReturnStmt
771template< typename pass_type >
772void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
773 VISIT_START( node );
774
775 visitExpression( node->expr );
776
777 VISIT_END( node );
778}
779
780template< typename pass_type >
781Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
782 MUTATE_START( node );
783
784 node->expr = mutateExpression( node->expr );
785
786 MUTATE_END( Statement, node );
787}
788
789//--------------------------------------------------------------------------
790// ThrowStmt
791
792template< typename pass_type >
793void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
794 VISIT_BODY( node );
795}
796
797template< typename pass_type >
798Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
799 MUTATE_BODY( Statement, node );
800}
801
802//--------------------------------------------------------------------------
803// TryStmt
804template< typename pass_type >
805void PassVisitor< pass_type >::visit( TryStmt * node ) {
806 VISIT_START( node );
807
808 maybeAccept( node->block , *this );
809 maybeAccept( node->handlers , *this );
810 maybeAccept( node->finallyBlock, *this );
811
812 VISIT_END( node );
813}
814
815template< typename pass_type >
816Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
817 MUTATE_START( node );
818
819 maybeMutateRef( node->block , *this );
820 maybeMutateRef( node->handlers , *this );
821 maybeMutateRef( node->finallyBlock, *this );
822
823 MUTATE_END( Statement, node );
824}
825
826//--------------------------------------------------------------------------
827// CatchStmt
828template< typename pass_type >
829void PassVisitor< pass_type >::visit( CatchStmt * node ) {
830 VISIT_START( node );
831 {
832 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
833 maybeAccept( node->decl, *this );
834 node->cond = visitExpression( node->cond );
835 node->body = visitStatement ( node->body );
836 }
837 VISIT_END( node );
838}
839
840template< typename pass_type >
841Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
842 MUTATE_START( node );
843 {
844 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
845 maybeMutateRef( node->decl, *this );
846 node->cond = mutateExpression( node->cond );
847 node->body = mutateStatement ( node->body );
848 }
849 MUTATE_END( Statement, node );
850}
851
852//--------------------------------------------------------------------------
853// FinallyStmt
854template< typename pass_type >
855void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
856 VISIT_BODY( node );
857}
858
859template< typename pass_type >
860Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
861 MUTATE_BODY( Statement, node );
862}
863
864//--------------------------------------------------------------------------
865// WaitForStmt
866template< typename pass_type >
867void PassVisitor< pass_type >::visit( WaitForStmt * node ) {
868 VISIT_BODY( node );
869}
870
871template< typename pass_type >
872Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
873 MUTATE_BODY( Statement, node );
874}
875
876//--------------------------------------------------------------------------
877// NullStmt
878template< typename pass_type >
879void PassVisitor< pass_type >::visit( NullStmt * node ) {
880 VISIT_BODY( node );
881}
882
883template< typename pass_type >
884NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
885 MUTATE_BODY( NullStmt, node );
886}
887
888//--------------------------------------------------------------------------
889// DeclStmt
890template< typename pass_type >
891void PassVisitor< pass_type >::visit( DeclStmt * node ) {
892 VISIT_BODY( node );
893}
894
895template< typename pass_type >
896Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
897 MUTATE_BODY( Statement, node );
898}
899
900//--------------------------------------------------------------------------
901// ImplicitCtorDtorStmt
902template< typename pass_type >
903void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
904 VISIT_BODY( node );
905}
906
907template< typename pass_type >
908Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
909 MUTATE_BODY( Statement, node );
910}
911
912//--------------------------------------------------------------------------
913// ApplicationExpr
914template< typename pass_type >
915void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
916 VISIT_START( node );
917
918 indexerScopedAccept( node->result , *this );
919 maybeAccept ( node->function, *this );
920 maybeAccept ( node->args , *this );
921
922 VISIT_END( node );
923}
924
925template< typename pass_type >
926Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
927 MUTATE_START( node );
928
929 indexerScopedMutate( node->env , *this );
930 indexerScopedMutate( node->result , *this );
931 maybeMutateRef ( node->function, *this );
932 maybeMutateRef ( node->args , *this );
933
934 MUTATE_END( Expression, node );
935}
936
937//--------------------------------------------------------------------------
938// UntypedExpr
939template< typename pass_type >
940void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
941 VISIT_START( node );
942
943 // maybeAccept( node->get_env(), *this );
944 indexerScopedAccept( node->result, *this );
945
946 for ( auto expr : node->args ) {
947 visitExpression( expr );
948 }
949
950 VISIT_END( node );
951}
952
953template< typename pass_type >
954Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
955 MUTATE_START( node );
956
957 indexerScopedMutate( node->env , *this );
958 indexerScopedMutate( node->result, *this );
959
960 for ( auto& expr : node->args ) {
961 expr = mutateExpression( expr );
962 }
963
964 MUTATE_END( Expression, node );
965}
966
967//--------------------------------------------------------------------------
968// NameExpr
969template< typename pass_type >
970void PassVisitor< pass_type >::visit( NameExpr * node ) {
971 VISIT_START( node );
972
973 indexerScopedAccept( node->result, *this );
974
975 VISIT_END( node );
976}
977
978template< typename pass_type >
979Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
980 MUTATE_START( node );
981
982 indexerScopedMutate( node->env , *this );
983 indexerScopedMutate( node->result, *this );
984
985 MUTATE_END( Expression, node );
986}
987
988//--------------------------------------------------------------------------
989// CastExpr
990template< typename pass_type >
991void PassVisitor< pass_type >::visit( CastExpr * node ) {
992 VISIT_START( node );
993
994 indexerScopedAccept( node->result, *this );
995 maybeAccept ( node->arg , *this );
996
997 VISIT_END( node );
998}
999
1000template< typename pass_type >
1001Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
1002 MUTATE_START( node );
1003
1004 indexerScopedMutate( node->env , *this );
1005 indexerScopedMutate( node->result, *this );
1006 maybeMutateRef ( node->arg , *this );
1007
1008 MUTATE_END( Expression, node );
1009}
1010
1011//--------------------------------------------------------------------------
1012// VirtualCastExpr
1013template< typename pass_type >
1014void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
1015 VISIT_START( node );
1016
1017 indexerScopedAccept( node->result, *this );
1018 maybeAccept( node->arg, *this );
1019
1020 VISIT_END( node );
1021}
1022
1023template< typename pass_type >
1024Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
1025 MUTATE_START( node );
1026
1027 indexerScopedMutate( node->env , *this );
1028 indexerScopedMutate( node->result, *this );
1029 maybeMutateRef ( node->arg , *this );
1030
1031 MUTATE_END( Expression, node );
1032}
1033
1034//--------------------------------------------------------------------------
1035// AddressExpr
1036template< typename pass_type >
1037void PassVisitor< pass_type >::visit( AddressExpr * node ) {
1038 VISIT_START( node );
1039
1040 indexerScopedAccept( node->result, *this );
1041 maybeAccept ( node->arg , *this );
1042
1043 VISIT_END( node );
1044}
1045
1046template< typename pass_type >
1047Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
1048 MUTATE_START( node );
1049
1050 indexerScopedMutate( node->env , *this );
1051 indexerScopedMutate( node->result, *this );
1052 maybeMutateRef ( node->arg , *this );
1053
1054 MUTATE_END( Expression, node );
1055}
1056
1057//--------------------------------------------------------------------------
1058// LabelAddressExpr
1059template< typename pass_type >
1060void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
1061 VISIT_START( node );
1062
1063 indexerScopedAccept( node->result, *this );
1064
1065 VISIT_END( node );
1066}
1067
1068template< typename pass_type >
1069Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
1070 MUTATE_START( node );
1071
1072 indexerScopedMutate( node->env , *this );
1073 indexerScopedMutate( node->result, *this );
1074
1075 MUTATE_END( Expression, node );
1076}
1077
1078//--------------------------------------------------------------------------
1079// UntypedMemberExpr
1080template< typename pass_type >
1081void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
1082 VISIT_START( node );
1083
1084 indexerScopedAccept( node->result , *this );
1085 maybeAccept ( node->aggregate, *this );
1086 maybeAccept ( node->member , *this );
1087
1088 VISIT_END( node );
1089}
1090
1091template< typename pass_type >
1092Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
1093 MUTATE_START( node );
1094
1095 indexerScopedMutate( node->env , *this );
1096 indexerScopedMutate( node->result , *this );
1097 maybeMutateRef ( node->aggregate, *this );
1098 maybeMutateRef ( node->member , *this );
1099
1100 MUTATE_END( Expression, node );
1101}
1102
1103//--------------------------------------------------------------------------
1104// MemberExpr
1105template< typename pass_type >
1106void PassVisitor< pass_type >::visit( MemberExpr * node ) {
1107 VISIT_START( node );
1108
1109 indexerScopedAccept( node->result , *this );
1110 maybeAccept ( node->aggregate, *this );
1111
1112 VISIT_END( node );
1113}
1114
1115template< typename pass_type >
1116Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
1117 MUTATE_START( node );
1118
1119 indexerScopedMutate( node->env , *this );
1120 indexerScopedMutate( node->result , *this );
1121 maybeMutateRef ( node->aggregate, *this );
1122
1123 MUTATE_END( Expression, node );
1124}
1125
1126//--------------------------------------------------------------------------
1127// VariableExpr
1128template< typename pass_type >
1129void PassVisitor< pass_type >::visit( VariableExpr * node ) {
1130 VISIT_START( node );
1131
1132 indexerScopedAccept( node->result, *this );
1133
1134 VISIT_END( node );
1135}
1136
1137template< typename pass_type >
1138Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
1139 MUTATE_START( node );
1140
1141 indexerScopedMutate( node->env , *this );
1142 indexerScopedMutate( node->result, *this );
1143
1144 MUTATE_END( Expression, node );
1145}
1146
1147//--------------------------------------------------------------------------
1148// ConstantExpr
1149template< typename pass_type >
1150void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
1151 VISIT_START( node );
1152
1153 indexerScopedAccept( node->result , *this );
1154 maybeAccept ( &node->constant, *this );
1155
1156 VISIT_END( node );
1157}
1158
1159template< typename pass_type >
1160Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
1161 MUTATE_START( node );
1162
1163 indexerScopedMutate( node->env , *this );
1164 indexerScopedMutate( node->result, *this );
1165 node->constant = *maybeMutate( &node->constant, *this );
1166
1167 MUTATE_END( Expression, node );
1168}
1169
1170//--------------------------------------------------------------------------
1171// SizeofExpr
1172template< typename pass_type >
1173void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
1174 VISIT_START( node );
1175
1176 indexerScopedAccept( node->result, *this );
1177 if ( node->get_isType() ) {
1178 maybeAccept( node->type, *this );
1179 } else {
1180 maybeAccept( node->expr, *this );
1181 }
1182
1183 VISIT_END( node );
1184}
1185
1186template< typename pass_type >
1187Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
1188 MUTATE_START( node );
1189
1190 indexerScopedMutate( node->env , *this );
1191 indexerScopedMutate( node->result, *this );
1192 if ( node->get_isType() ) {
1193 maybeMutateRef( node->type, *this );
1194 } else {
1195 maybeMutateRef( node->expr, *this );
1196 }
1197
1198 MUTATE_END( Expression, node );
1199}
1200
1201//--------------------------------------------------------------------------
1202// AlignofExpr
1203template< typename pass_type >
1204void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
1205 VISIT_START( node );
1206
1207 indexerScopedAccept( node->result, *this );
1208 if ( node->get_isType() ) {
1209 maybeAccept( node->type, *this );
1210 } else {
1211 maybeAccept( node->expr, *this );
1212 }
1213
1214 VISIT_END( node );
1215}
1216
1217template< typename pass_type >
1218Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
1219 MUTATE_START( node );
1220
1221 indexerScopedMutate( node->env , *this );
1222 indexerScopedMutate( node->result, *this );
1223 if ( node->get_isType() ) {
1224 maybeMutateRef( node->type, *this );
1225 } else {
1226 maybeMutateRef( node->expr, *this );
1227 }
1228
1229 MUTATE_END( Expression, node );
1230}
1231
1232//--------------------------------------------------------------------------
1233// UntypedOffsetofExpr
1234template< typename pass_type >
1235void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
1236 VISIT_START( node );
1237
1238 indexerScopedAccept( node->result, *this );
1239 maybeAccept ( node->type , *this );
1240
1241 VISIT_END( node );
1242}
1243
1244template< typename pass_type >
1245Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
1246 MUTATE_START( node );
1247
1248 indexerScopedMutate( node->env , *this );
1249 indexerScopedMutate( node->result, *this );
1250 maybeMutateRef ( node->type , *this );
1251
1252 MUTATE_END( Expression, node );
1253}
1254
1255//--------------------------------------------------------------------------
1256// OffsetofExpr
1257template< typename pass_type >
1258void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
1259 VISIT_START( node );
1260
1261 indexerScopedAccept( node->result, *this );
1262 maybeAccept ( node->type , *this );
1263 maybeAccept ( node->member, *this );
1264
1265 VISIT_END( node );
1266}
1267
1268template< typename pass_type >
1269Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
1270 MUTATE_START( node );
1271
1272 indexerScopedMutate( node->env , *this );
1273 indexerScopedMutate( node->result, *this );
1274 maybeMutateRef ( node->type , *this );
1275 maybeMutateRef ( node->member, *this );
1276
1277 MUTATE_END( Expression, node );
1278}
1279
1280//--------------------------------------------------------------------------
1281// OffsetPackExpr
1282template< typename pass_type >
1283void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
1284 VISIT_START( node );
1285
1286 indexerScopedAccept( node->result, *this );
1287 maybeAccept ( node->type , *this );
1288
1289 VISIT_END( node );
1290}
1291
1292template< typename pass_type >
1293Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
1294 MUTATE_START( node );
1295
1296 indexerScopedMutate( node->env , *this );
1297 indexerScopedMutate( node->result, *this );
1298 maybeMutateRef ( node->type , *this );
1299
1300 MUTATE_END( Expression, node );
1301}
1302
1303//--------------------------------------------------------------------------
1304// AttrExpr
1305template< typename pass_type >
1306void PassVisitor< pass_type >::visit( AttrExpr * node ) {
1307 VISIT_START( node );
1308
1309 indexerScopedAccept( node->result, *this );
1310 if ( node->get_isType() ) {
1311 maybeAccept( node->type, *this );
1312 } else {
1313 maybeAccept( node->expr, *this );
1314 }
1315
1316 VISIT_END( node );
1317}
1318
1319template< typename pass_type >
1320Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
1321 MUTATE_START( node );
1322
1323 indexerScopedMutate( node->env , *this );
1324 indexerScopedMutate( node->result, *this );
1325 if ( node->get_isType() ) {
1326 maybeMutateRef( node->type, *this );
1327 } else {
1328 maybeMutateRef( node->expr, *this );
1329 }
1330
1331 MUTATE_END( Expression, node );
1332}
1333
1334//--------------------------------------------------------------------------
1335// LogicalExpr
1336template< typename pass_type >
1337void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
1338 VISIT_START( node );
1339
1340 indexerScopedAccept( node->result, *this );
1341 maybeAccept ( node->arg1 , *this );
1342 maybeAccept ( node->arg2 , *this );
1343
1344 VISIT_END( node );
1345}
1346
1347template< typename pass_type >
1348Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
1349 MUTATE_START( node );
1350
1351 indexerScopedMutate( node->env , *this );
1352 indexerScopedMutate( node->result, *this );
1353 maybeMutateRef ( node->arg1 , *this );
1354 maybeMutateRef ( node->arg2 , *this );
1355
1356 MUTATE_END( Expression, node );
1357}
1358
1359//--------------------------------------------------------------------------
1360// ConditionalExpr
1361template< typename pass_type >
1362void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
1363 VISIT_START( node );
1364
1365 indexerScopedAccept( node->result, *this );
1366 maybeAccept ( node->arg1 , *this );
1367 maybeAccept ( node->arg2 , *this );
1368 maybeAccept ( node->arg3 , *this );
1369
1370 VISIT_END( node );
1371}
1372
1373template< typename pass_type >
1374Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
1375 MUTATE_START( node );
1376
1377 indexerScopedMutate( node->env , *this );
1378 indexerScopedMutate( node->result, *this );
1379 maybeMutateRef ( node->arg1 , *this );
1380 maybeMutateRef ( node->arg2 , *this );
1381 maybeMutateRef ( node->arg3 , *this );
1382
1383 MUTATE_END( Expression, node );
1384}
1385
1386//--------------------------------------------------------------------------
1387// CommaExpr
1388template< typename pass_type >
1389void PassVisitor< pass_type >::visit( CommaExpr * node ) {
1390 VISIT_START( node );
1391
1392 indexerScopedAccept( node->result, *this );
1393 maybeAccept ( node->arg1 , *this );
1394 maybeAccept ( node->arg2 , *this );
1395
1396 VISIT_END( node );
1397}
1398
1399template< typename pass_type >
1400Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
1401 MUTATE_START( node );
1402
1403 indexerScopedMutate( node->env , *this );
1404 indexerScopedMutate( node->result, *this );
1405 maybeMutateRef ( node->arg1 , *this );
1406 maybeMutateRef ( node->arg2 , *this );
1407
1408 MUTATE_END( Expression, node );
1409}
1410
1411//--------------------------------------------------------------------------
1412// TypeExpr
1413template< typename pass_type >
1414void PassVisitor< pass_type >::visit( TypeExpr * node ) {
1415 VISIT_START( node );
1416
1417 indexerScopedAccept( node->result, *this );
1418 maybeAccept ( node->type, *this );
1419
1420 VISIT_END( node );
1421}
1422
1423template< typename pass_type >
1424Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
1425 MUTATE_START( node );
1426
1427 indexerScopedMutate( node->env , *this );
1428 indexerScopedMutate( node->result, *this );
1429 maybeMutateRef ( node->type , *this );
1430
1431 MUTATE_END( Expression, node );
1432}
1433
1434//--------------------------------------------------------------------------
1435// AsmExpr
1436template< typename pass_type >
1437void PassVisitor< pass_type >::visit( AsmExpr * node ) {
1438 VISIT_START( node );
1439
1440 indexerScopedAccept( node->result , *this );
1441 maybeAccept ( node->inout , *this );
1442 maybeAccept ( node->constraint, *this );
1443 maybeAccept ( node->operand , *this );
1444
1445 VISIT_END( node );
1446}
1447
1448template< typename pass_type >
1449Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
1450 MUTATE_START( node );
1451
1452 indexerScopedMutate( node->env , *this );
1453 indexerScopedMutate( node->result , *this );
1454 maybeMutateRef ( node->inout , *this );
1455 maybeMutateRef ( node->constraint, *this );
1456 maybeMutateRef ( node->operand , *this );
1457
1458 MUTATE_END( Expression, node );
1459}
1460
1461//--------------------------------------------------------------------------
1462// ImplicitCopyCtorExpr
1463template< typename pass_type >
1464void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
1465 VISIT_START( node );
1466
1467 indexerScopedAccept( node->result , *this );
1468 maybeAccept ( node->callExpr , *this );
1469 maybeAccept ( node->tempDecls , *this );
1470 maybeAccept ( node->returnDecls, *this );
1471 maybeAccept ( node->dtors , *this );
1472
1473 VISIT_END( node );
1474}
1475
1476template< typename pass_type >
1477Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
1478 MUTATE_START( node );
1479
1480 indexerScopedMutate( node->env , *this );
1481 indexerScopedMutate( node->result , *this );
1482 maybeMutateRef ( node->callExpr , *this );
1483 maybeMutateRef ( node->tempDecls , *this );
1484 maybeMutateRef ( node->returnDecls, *this );
1485 maybeMutateRef ( node->dtors , *this );
1486
1487 MUTATE_END( Expression, node );
1488}
1489
1490//--------------------------------------------------------------------------
1491// ConstructorExpr
1492template< typename pass_type >
1493void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
1494 VISIT_START( node );
1495
1496 indexerScopedAccept( node->result , *this );
1497 maybeAccept ( node->callExpr, *this );
1498
1499 VISIT_END( node );
1500}
1501
1502template< typename pass_type >
1503Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
1504 MUTATE_START( node );
1505
1506 indexerScopedMutate( node->env , *this );
1507 indexerScopedMutate( node->result , *this );
1508 maybeMutateRef ( node->callExpr, *this );
1509
1510 MUTATE_END( Expression, node );
1511}
1512
1513//--------------------------------------------------------------------------
1514// CompoundLiteralExpr
1515template< typename pass_type >
1516void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
1517 VISIT_START( node );
1518
1519 indexerScopedAccept( node->result , *this );
1520 maybeAccept ( node->initializer, *this );
1521
1522 VISIT_END( node );
1523}
1524
1525template< typename pass_type >
1526Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
1527 MUTATE_START( node );
1528
1529 indexerScopedMutate( node->env , *this );
1530 indexerScopedMutate( node->result , *this );
1531 maybeMutateRef ( node->initializer, *this );
1532
1533 MUTATE_END( Expression, node );
1534}
1535
1536//--------------------------------------------------------------------------
1537// RangeExpr
1538template< typename pass_type >
1539void PassVisitor< pass_type >::visit( RangeExpr * node ) {
1540 VISIT_START( node );
1541
1542 indexerScopedAccept( node->result, *this );
1543 maybeAccept ( node->low , *this );
1544 maybeAccept ( node->high , *this );
1545
1546 VISIT_END( node );
1547}
1548
1549template< typename pass_type >
1550Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
1551 MUTATE_START( node );
1552
1553 indexerScopedMutate( node->env , *this );
1554 indexerScopedMutate( node->result, *this );
1555 maybeMutateRef ( node->low , *this );
1556 maybeMutateRef ( node->high , *this );
1557
1558 MUTATE_END( Expression, node );
1559}
1560
1561//--------------------------------------------------------------------------
1562// UntypedTupleExpr
1563template< typename pass_type >
1564void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
1565 VISIT_START( node );
1566
1567 indexerScopedAccept( node->result, *this );
1568 maybeAccept ( node->exprs , *this );
1569
1570 VISIT_END( node );
1571}
1572
1573template< typename pass_type >
1574Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
1575 MUTATE_START( node );
1576
1577 indexerScopedMutate( node->env , *this );
1578 indexerScopedMutate( node->result, *this );
1579 maybeMutateRef ( node->exprs , *this );
1580
1581 MUTATE_END( Expression, node );
1582}
1583
1584//--------------------------------------------------------------------------
1585// TupleExpr
1586template< typename pass_type >
1587void PassVisitor< pass_type >::visit( TupleExpr * node ) {
1588 VISIT_START( node );
1589
1590 indexerScopedAccept( node->result, *this );
1591 maybeAccept ( node->exprs , *this );
1592
1593 VISIT_END( node );
1594}
1595
1596template< typename pass_type >
1597Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
1598 MUTATE_START( node );
1599
1600 indexerScopedMutate( node->env , *this );
1601 indexerScopedMutate( node->result, *this );
1602 maybeMutateRef ( node->exprs , *this );
1603
1604 MUTATE_END( Expression, node );
1605}
1606
1607//--------------------------------------------------------------------------
1608// TupleIndexExpr
1609template< typename pass_type >
1610void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
1611 VISIT_START( node );
1612
1613 indexerScopedAccept( node->result, *this );
1614 maybeAccept ( node->tuple , *this );
1615
1616 VISIT_END( node );
1617}
1618
1619template< typename pass_type >
1620Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
1621 MUTATE_START( node );
1622
1623 indexerScopedMutate( node->env , *this );
1624 indexerScopedMutate( node->result, *this );
1625 maybeMutateRef ( node->tuple , *this );
1626
1627 MUTATE_END( Expression, node );
1628}
1629
1630//--------------------------------------------------------------------------
1631// TupleAssignExpr
1632template< typename pass_type >
1633void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
1634 VISIT_START( node );
1635
1636 indexerScopedAccept( node->result , *this );
1637 maybeAccept ( node->stmtExpr, *this );
1638
1639 VISIT_END( node );
1640}
1641
1642template< typename pass_type >
1643Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
1644 MUTATE_START( node );
1645
1646 indexerScopedMutate( node->env , *this );
1647 indexerScopedMutate( node->result , *this );
1648 maybeMutateRef ( node->stmtExpr, *this );
1649
1650 MUTATE_END( Expression, node );
1651}
1652
1653//--------------------------------------------------------------------------
1654// StmtExpr
1655template< typename pass_type >
1656void PassVisitor< pass_type >::visit( StmtExpr * node ) {
1657 VISIT_START( node );
1658
1659 // don't want statements from outer CompoundStmts to be added to this StmtExpr
1660 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
1661 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
1662 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
1663
1664 indexerScopedAccept( node->result , *this );
1665 maybeAccept ( node->statements , *this );
1666 maybeAccept ( node->returnDecls, *this );
1667 maybeAccept ( node->dtors , *this );
1668
1669 VISIT_END( node );
1670}
1671
1672template< typename pass_type >
1673Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
1674 MUTATE_START( node );
1675
1676 // don't want statements from outer CompoundStmts to be added to this StmtExpr
1677 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
1678 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
1679 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
1680
1681 indexerScopedMutate( node->result , *this );
1682 maybeMutateRef ( node->statements , *this );
1683 maybeMutateRef ( node->returnDecls, *this );
1684 maybeMutateRef ( node->dtors , *this );
1685
1686 MUTATE_END( Expression, node );
1687}
1688
1689//--------------------------------------------------------------------------
1690// UniqueExpr
1691template< typename pass_type >
1692void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
1693 VISIT_START( node );
1694
1695 indexerScopedAccept( node->result, *this );
1696 maybeAccept ( node->expr , *this );
1697
1698 VISIT_END( node );
1699}
1700
1701template< typename pass_type >
1702Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
1703 MUTATE_START( node );
1704
1705 indexerScopedMutate( node->env , *this );
1706 indexerScopedMutate( node->result, *this );
1707 maybeMutateRef ( node->expr , *this );
1708
1709 MUTATE_END( Expression, node );
1710}
1711
1712template< typename pass_type >
1713void PassVisitor< pass_type >::visit( VoidType * node ) {
1714 VISIT_BODY( node );
1715}
1716
1717template< typename pass_type >
1718void PassVisitor< pass_type >::visit( BasicType * node ) {
1719 VISIT_BODY( node );
1720}
1721
1722template< typename pass_type >
1723void PassVisitor< pass_type >::visit( PointerType * node ) {
1724 VISIT_BODY( node );
1725}
1726
1727template< typename pass_type >
1728void PassVisitor< pass_type >::visit( ArrayType * node ) {
1729 VISIT_BODY( node );
1730}
1731
1732template< typename pass_type >
1733void PassVisitor< pass_type >::visit( ReferenceType * node ) {
1734 VISIT_BODY( node );
1735}
1736
1737template< typename pass_type >
1738void PassVisitor< pass_type >::visit( FunctionType * node ) {
1739 VISIT_BODY( node );
1740}
1741
1742//--------------------------------------------------------------------------
1743// StructInstType
1744template< typename pass_type >
1745void PassVisitor< pass_type >::visit( StructInstType * node ) {
1746 VISIT_START( node );
1747
1748 indexerAddStruct( node->name );
1749
1750 {
1751 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1752 maybeAccept( node->forall , *this );
1753 maybeAccept( node->parameters, *this );
1754 }
1755
1756 VISIT_END( node );
1757}
1758
1759template< typename pass_type >
1760Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
1761 MUTATE_START( node );
1762
1763 indexerAddStruct( node->name );
1764
1765 {
1766 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1767 maybeMutateRef( node->forall , *this );
1768 maybeMutateRef( node->parameters, *this );
1769 }
1770
1771 MUTATE_END( Type, node );
1772}
1773
1774//--------------------------------------------------------------------------
1775// UnionInstType
1776template< typename pass_type >
1777void PassVisitor< pass_type >::visit( UnionInstType * node ) {
1778 VISIT_START( node );
1779
1780 indexerAddStruct( node->name );
1781
1782 {
1783 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1784 maybeAccept( node->forall , *this );
1785 maybeAccept( node->parameters, *this );
1786 }
1787
1788 VISIT_END( node );
1789}
1790
1791template< typename pass_type >
1792Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
1793 MUTATE_START( node );
1794
1795 indexerAddStruct( node->name );
1796
1797 {
1798 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
1799 maybeMutateRef( node->forall , *this );
1800 maybeMutateRef( node->parameters, *this );
1801 }
1802
1803 MUTATE_END( Type, node );
1804}
1805
1806//--------------------------------------------------------------------------
1807// EnumInstType
1808template< typename pass_type >
1809void PassVisitor< pass_type >::visit( EnumInstType * node ) {
1810 VISIT_BODY( node );
1811}
1812
1813template< typename pass_type >
1814Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
1815 MUTATE_BODY( Type, node );
1816}
1817
1818//--------------------------------------------------------------------------
1819// TraitInstType
1820template< typename pass_type >
1821void PassVisitor< pass_type >::visit( TraitInstType * node ) {
1822 VISIT_START( node );
1823
1824 maybeAccept( node->forall , *this );
1825 maybeAccept( node->parameters, *this );
1826
1827 VISIT_END( node );
1828}
1829
1830template< typename pass_type >
1831Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
1832 MUTATE_START( node );
1833
1834 maybeMutateRef( node->forall , *this );
1835 maybeMutateRef( node->parameters, *this );
1836
1837 MUTATE_END( Type, node );
1838}
1839
1840//--------------------------------------------------------------------------
1841// TypeInstType
1842template< typename pass_type >
1843void PassVisitor< pass_type >::visit( TypeInstType * node ) {
1844 VISIT_BODY( node );
1845}
1846
1847template< typename pass_type >
1848void PassVisitor< pass_type >::visit( TupleType * node ) {
1849 VISIT_BODY( node );
1850}
1851
1852template< typename pass_type >
1853void PassVisitor< pass_type >::visit( TypeofType * node ) {
1854 VISIT_BODY( node );
1855}
1856
1857template< typename pass_type >
1858void PassVisitor< pass_type >::visit( AttrType * node ) {
1859 VISIT_BODY( node );
1860}
1861
1862template< typename pass_type >
1863void PassVisitor< pass_type >::visit( VarArgsType * node ) {
1864 VISIT_BODY( node );
1865}
1866
1867template< typename pass_type >
1868void PassVisitor< pass_type >::visit( ZeroType * node ) {
1869 VISIT_BODY( node );
1870}
1871
1872template< typename pass_type >
1873void PassVisitor< pass_type >::visit( OneType * node ) {
1874 VISIT_BODY( node );
1875}
1876
1877//--------------------------------------------------------------------------
1878// SingleInit
1879template< typename pass_type >
1880void PassVisitor< pass_type >::visit( SingleInit * node ) {
1881 VISIT_START( node );
1882
1883 visitExpression( node->get_value() );
1884
1885 VISIT_END( node );
1886}
1887
1888template< typename pass_type >
1889Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
1890 MUTATE_START( node );
1891
1892 node->set_value( mutateExpression( node->get_value() ) );
1893
1894 MUTATE_END( Initializer, node );
1895}
1896
1897template< typename pass_type >
1898void PassVisitor< pass_type >::visit( ListInit * node ) {
1899 VISIT_BODY( node );
1900}
1901
1902template< typename pass_type >
1903void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
1904 VISIT_BODY( node );
1905}
1906
1907template< typename pass_type >
1908void PassVisitor< pass_type >::visit( Subrange * node ) {
1909 VISIT_BODY( node );
1910}
1911
1912template< typename pass_type >
1913void PassVisitor< pass_type >::visit( Constant * node ) {
1914 VISIT_BODY( node );
1915}
1916
1917//---------------------------------------------------------------------------------------------------------------
1918template< typename pass_type >
1919Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
1920 MUTATE_BODY( Type, node );
1921}
1922
1923template< typename pass_type >
1924Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
1925 MUTATE_BODY( Type, node );
1926}
1927
1928template< typename pass_type >
1929Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
1930 MUTATE_BODY( Type, node );
1931}
1932
1933template< typename pass_type >
1934Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
1935 MUTATE_BODY( Type, node );
1936}
1937
1938template< typename pass_type >
1939Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
1940 MUTATE_BODY( Type, node );
1941}
1942
1943template< typename pass_type >
1944Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
1945 MUTATE_BODY( Type, node );
1946}
1947
1948template< typename pass_type >
1949Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
1950 MUTATE_BODY( Type, node );
1951}
1952
1953template< typename pass_type >
1954Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
1955 MUTATE_BODY( Type, node );
1956}
1957
1958template< typename pass_type >
1959Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
1960 MUTATE_BODY( Type, node );
1961}
1962
1963template< typename pass_type >
1964Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
1965 MUTATE_BODY( Type, node );
1966}
1967
1968template< typename pass_type >
1969Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
1970 MUTATE_BODY( Type, node );
1971}
1972
1973template< typename pass_type >
1974Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
1975 MUTATE_BODY( Type, node );
1976}
1977
1978template< typename pass_type >
1979Type * PassVisitor< pass_type >::mutate( OneType * node ) {
1980 MUTATE_BODY( Type, node );
1981}
1982
1983template< typename pass_type >
1984Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
1985 MUTATE_BODY( Initializer, node );
1986}
1987
1988template< typename pass_type >
1989Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
1990 MUTATE_BODY( Initializer, node );
1991}
1992
1993template< typename pass_type >
1994Subrange * PassVisitor< pass_type >::mutate( Subrange * node ) {
1995 MUTATE_BODY( Subrange, node );
1996}
1997
1998template< typename pass_type >
1999Constant * PassVisitor< pass_type >::mutate( Constant * node ) {
2000 MUTATE_BODY( Constant, node );
2001}
Note: See TracBrowser for help on using the repository browser.