source: src/Common/PassVisitor.impl.h @ 134322e

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 134322e was 134322e, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Refactored PassVisitor? to properly support env and statements to add

  • Property mode set to 100644
File size: 26.2 KB
Line 
1#pragma once
2
3#define MUTATE_START( node )  \
4        call_premutate( node ); \
5
6
7#define MUTATE_END( type, node )                \
8        return call_postmutate< type * >( node ); \
9
10
11#define VISIT_BODY( node )    \
12        call_previsit( node );  \
13        Visitor::visit( node ); \
14        call_postvisit( node ); \
15
16
17#define MUTATE_BODY( type, node ) \
18        MUTATE_START( node );       \
19        Mutator::mutate( node );    \
20        MUTATE_END( type, node );   \
21
22
23
24template<typename T>
25static inline bool empty( T * ptr ) {
26        return !ptr || ptr->empty();
27}
28
29typedef std::list< Statement * > StmtList_t;
30
31template< typename pass_type >
32void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
33        SemanticError errors;
34
35        StmtList_t* beforeStmts = get_beforeStmts();
36        StmtList_t* afterStmts  = get_afterStmts();
37
38        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
39                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
40                try {
41                        *i = (*i)->accept( *this );
42                } catch ( SemanticError &e ) {
43                        errors.append( e );
44                }
45                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
46        }
47
48        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
49        if ( !errors.isEmpty() ) { throw errors; }
50}
51
52template< typename pass_type >
53void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
54        SemanticError errors;
55
56        StmtList_t* beforeStmts = get_beforeStmts();
57        StmtList_t* afterStmts  = get_afterStmts();
58
59        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
60                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
61                try {
62                        *i = (*i)->acceptMutator( *this );
63                } catch ( SemanticError &e ) {
64                        errors.append( e );
65                }
66                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
67        }
68
69        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
70        if ( !errors.isEmpty() ) { throw errors; }
71}
72
73template< typename pass_type >
74Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
75        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
76        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
77        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
78        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
79
80        Statement *newStmt = maybeVisit( stmt, *this );
81
82        StmtList_t* beforeStmts = get_beforeStmts();
83        StmtList_t* afterStmts  = get_afterStmts();
84
85        if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
86
87        CompoundStmt *compound = new CompoundStmt( noLabels );
88        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
89        compound->get_kids().push_back( newStmt );
90        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
91        return compound;
92}
93
94template< typename pass_type >
95Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
96        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
97        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
98        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
99        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
100
101        Statement *newStmt = maybeMutate( stmt, *this );
102
103        StmtList_t* beforeStmts = get_beforeStmts();
104        StmtList_t* afterStmts  = get_afterStmts();
105
106        if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
107
108        CompoundStmt *compound = new CompoundStmt( noLabels );
109        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
110        compound->get_kids().push_back( newStmt );
111        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
112        return compound;
113}
114
115
116
117template< typename pass_type >
118void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
119        if( !expr ) return;
120
121        auto env_ptr = get_env_ptr();
122        if ( env_ptr && expr->get_env() ) {
123                *env_ptr = expr->get_env();
124        }
125        // xxx - should env be cloned (or moved) onto the result of the mutate?
126        expr->accept( *this );
127}
128
129template< typename pass_type >
130Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
131        if( !expr ) return nullptr;
132
133        auto env_ptr = get_env_ptr();
134        if ( env_ptr && expr->get_env() ) {
135                *env_ptr = expr->get_env();
136        }
137        // xxx - should env be cloned (or moved) onto the result of the mutate?
138        return expr->acceptMutator( *this );
139}
140
141
142//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
143
144template< typename pass_type >
145void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
146        VISIT_BODY( node ); 
147}
148
149template< typename pass_type >
150void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
151        VISIT_BODY( node ); 
152}
153
154template< typename pass_type >
155void PassVisitor< pass_type >::visit( StructDecl * node ) {
156        VISIT_BODY( node ); 
157}
158
159template< typename pass_type >
160void PassVisitor< pass_type >::visit( UnionDecl * node ) {
161        VISIT_BODY( node ); 
162}
163
164template< typename pass_type >
165void PassVisitor< pass_type >::visit( EnumDecl * node ) {
166        VISIT_BODY( node ); 
167}
168
169template< typename pass_type >
170void PassVisitor< pass_type >::visit( TraitDecl * node ) {
171        VISIT_BODY( node ); 
172}
173
174template< typename pass_type >
175void PassVisitor< pass_type >::visit( TypeDecl * node ) {
176        VISIT_BODY( node ); 
177}
178
179template< typename pass_type >
180void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
181        VISIT_BODY( node ); 
182}
183
184template< typename pass_type >
185void PassVisitor< pass_type >::visit( AsmDecl * node ) {
186        VISIT_BODY( node ); 
187}
188
189template< typename pass_type >
190void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
191        VISIT_BODY( node ); 
192}
193
194template< typename pass_type >
195CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
196        MUTATE_START( node );
197        call_beginScope();
198
199        mutateStatementList( node->get_kids() );
200
201        call_endScope();
202        MUTATE_END( CompoundStmt, node );
203}
204
205template< typename pass_type >
206void PassVisitor< pass_type >::visit( ExprStmt * node ) {
207        VISIT_BODY( node ); 
208}
209
210template< typename pass_type >
211Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
212        MUTATE_START( node );
213
214        node->set_expr( mutateExpression( node->get_expr() ) );
215
216        MUTATE_END( Statement, node );
217}
218
219template< typename pass_type >
220void PassVisitor< pass_type >::visit( AsmStmt * node ) {
221        VISIT_BODY( node ); 
222}
223
224template< typename pass_type >
225void PassVisitor< pass_type >::visit( IfStmt * node ) {
226        VISIT_BODY( node ); 
227}
228
229template< typename pass_type >
230Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
231        MUTATE_START( node ); 
232
233        node->set_condition( mutateExpression( node->get_condition() ) );
234        node->set_thenPart ( mutateStatement ( node->get_thenPart()  ) );
235        node->set_elsePart ( mutateStatement ( node->get_elsePart()  ) );
236
237        MUTATE_END( Statement, node );
238}
239
240template< typename pass_type >
241void PassVisitor< pass_type >::visit( WhileStmt * node ) {
242        VISIT_BODY( node ); 
243}
244
245template< typename pass_type >
246Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
247        MUTATE_START( node ); 
248
249        node->set_condition( mutateExpression( node->get_condition() ) );
250        node->set_body( mutateStatement( node->get_body() ) );
251
252        MUTATE_END( Statement, node );
253}
254
255
256template< typename pass_type >
257void PassVisitor< pass_type >::visit( ForStmt * node ) {
258        VISIT_BODY( node ); 
259}
260
261template< typename pass_type >
262Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
263        MUTATE_START( node ); 
264
265        mutateAll( node->get_initialization(), *this );
266        node->set_condition(  mutateExpression( node->get_condition() ) );
267        node->set_increment(  mutateExpression( node->get_increment() ) );
268        node->set_body(  mutateStatement( node->get_body() ) );
269
270        MUTATE_END( Statement, node );
271}
272
273template< typename pass_type >
274void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
275        VISIT_BODY( node ); 
276}
277
278template< typename pass_type >
279Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
280        MUTATE_START( node ); 
281       
282        node->set_condition( mutateExpression( node->get_condition() ) );
283        mutateStatementList( node->get_statements() );
284       
285        MUTATE_END( Statement, node );
286}
287
288template< typename pass_type >
289void PassVisitor< pass_type >::visit( CaseStmt * node ) {
290        VISIT_BODY( node ); 
291}
292
293template< typename pass_type >
294Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
295        MUTATE_START( node ); 
296       
297        node->set_condition(  mutateExpression( node->get_condition() ) );
298        mutateStatementList( node->get_statements() );
299       
300        MUTATE_END( Statement, node );
301}
302
303template< typename pass_type >
304void PassVisitor< pass_type >::visit( BranchStmt * node ) {
305        VISIT_BODY( node ); 
306}
307
308template< typename pass_type >
309void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
310        VISIT_BODY( node ); 
311}
312
313template< typename pass_type >
314Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
315        MUTATE_START( node );
316
317        node->set_expr( mutateExpression( node->get_expr() ) );
318
319        MUTATE_END( Statement, node );
320}
321
322template< typename pass_type >
323void PassVisitor< pass_type >::visit( TryStmt * node ) {
324        VISIT_BODY( node ); 
325}
326
327template< typename pass_type >
328Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
329        MUTATE_START( node );
330
331        node->set_block(  maybeMutate( node->get_block(), *this ) );
332        mutateAll( node->get_catchers(), *this );
333       
334        MUTATE_END( Statement, node );
335}
336
337template< typename pass_type >
338void PassVisitor< pass_type >::visit( CatchStmt * node ) {
339        VISIT_BODY( node ); 
340}
341
342template< typename pass_type >
343Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
344        MUTATE_START( node );
345       
346        node->set_body(  mutateStatement( node->get_body() ) );
347        node->set_decl(  maybeMutate( node->get_decl(), *this ) );
348       
349        MUTATE_END( Statement, node );
350}
351
352template< typename pass_type >
353void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
354        VISIT_BODY( node ); 
355}
356
357template< typename pass_type >
358void PassVisitor< pass_type >::visit( NullStmt * node ) {
359        VISIT_BODY( node ); 
360}
361
362template< typename pass_type >
363void PassVisitor< pass_type >::visit( DeclStmt * node ) {
364        VISIT_BODY( node ); 
365}
366
367template< typename pass_type >
368void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
369        VISIT_BODY( node ); 
370}
371
372template< typename pass_type >
373void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
374        VISIT_BODY( node ); 
375}
376
377template< typename pass_type >
378void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
379        VISIT_BODY( node ); 
380}
381
382template< typename pass_type >
383Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
384        MUTATE_START( node );
385
386        for ( auto& expr : node->get_args() ) {
387                expr = mutateExpression( expr );
388        }
389
390        MUTATE_END( Expression, node );
391}
392
393template< typename pass_type >
394void PassVisitor< pass_type >::visit( NameExpr * node ) {
395        VISIT_BODY( node ); 
396}
397
398template< typename pass_type >
399void PassVisitor< pass_type >::visit( CastExpr * node ) {
400        VISIT_BODY( node ); 
401}
402
403template< typename pass_type >
404void PassVisitor< pass_type >::visit( AddressExpr * node ) {
405        VISIT_BODY( node ); 
406}
407
408template< typename pass_type >
409void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
410        VISIT_BODY( node ); 
411}
412
413template< typename pass_type >
414void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
415        VISIT_BODY( node ); 
416}
417
418template< typename pass_type >
419void PassVisitor< pass_type >::visit( MemberExpr * node ) {
420        VISIT_BODY( node ); 
421}
422
423template< typename pass_type >
424void PassVisitor< pass_type >::visit( VariableExpr * node ) {
425        VISIT_BODY( node ); 
426}
427
428template< typename pass_type >
429void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
430        VISIT_BODY( node ); 
431}
432
433template< typename pass_type >
434void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
435        VISIT_BODY( node ); 
436}
437
438template< typename pass_type >
439void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
440        VISIT_BODY( node ); 
441}
442
443template< typename pass_type >
444void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
445        VISIT_BODY( node ); 
446}
447
448template< typename pass_type >
449void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
450        VISIT_BODY( node ); 
451}
452
453template< typename pass_type >
454void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
455        VISIT_BODY( node ); 
456}
457
458template< typename pass_type >
459void PassVisitor< pass_type >::visit( AttrExpr * node ) {
460        VISIT_BODY( node ); 
461}
462
463template< typename pass_type >
464void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
465        VISIT_BODY( node ); 
466}
467
468template< typename pass_type >
469void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
470        VISIT_BODY( node ); 
471}
472
473template< typename pass_type >
474void PassVisitor< pass_type >::visit( CommaExpr * node ) {
475        VISIT_BODY( node ); 
476}
477
478template< typename pass_type >
479void PassVisitor< pass_type >::visit( TypeExpr * node ) {
480        VISIT_BODY( node ); 
481}
482
483template< typename pass_type >
484void PassVisitor< pass_type >::visit( AsmExpr * node ) {
485        VISIT_BODY( node ); 
486}
487
488template< typename pass_type >
489void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
490        VISIT_BODY( node ); 
491}
492
493template< typename pass_type >
494void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
495        VISIT_BODY( node ); 
496}
497
498template< typename pass_type >
499void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
500        VISIT_BODY( node ); 
501}
502
503template< typename pass_type >
504void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
505        VISIT_BODY( node ); 
506}
507
508template< typename pass_type >
509void PassVisitor< pass_type >::visit( RangeExpr * node ) {
510        VISIT_BODY( node ); 
511}
512
513template< typename pass_type >
514void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
515        VISIT_BODY( node ); 
516}
517
518template< typename pass_type >
519void PassVisitor< pass_type >::visit( TupleExpr * node ) {
520        VISIT_BODY( node ); 
521}
522
523template< typename pass_type >
524void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
525        VISIT_BODY( node ); 
526}
527
528template< typename pass_type >
529void PassVisitor< pass_type >::visit( MemberTupleExpr * node ) {
530        VISIT_BODY( node ); 
531}
532
533template< typename pass_type >
534void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
535        VISIT_BODY( node ); 
536}
537
538template< typename pass_type >
539void PassVisitor< pass_type >::visit( StmtExpr * node ) {
540        VISIT_BODY( node ); 
541}
542
543template< typename pass_type >
544Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
545        MUTATE_START( node );
546       
547        // don't want statements from outer CompoundStmts to be added to this StmtExpr
548        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
549        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
550        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
551
552        Mutator::mutate( node );
553
554        MUTATE_END( Expression, node );
555}
556
557template< typename pass_type >
558void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
559        VISIT_BODY( node ); 
560}
561
562template< typename pass_type >
563void PassVisitor< pass_type >::visit( VoidType * node ) {
564        VISIT_BODY( node ); 
565}
566
567template< typename pass_type >
568void PassVisitor< pass_type >::visit( BasicType * node ) {
569        VISIT_BODY( node ); 
570}
571
572template< typename pass_type >
573void PassVisitor< pass_type >::visit( PointerType * node ) {
574        VISIT_BODY( node ); 
575}
576
577template< typename pass_type >
578void PassVisitor< pass_type >::visit( ArrayType * node ) {
579        VISIT_BODY( node ); 
580}
581
582template< typename pass_type >
583void PassVisitor< pass_type >::visit( FunctionType * node ) {
584        VISIT_BODY( node ); 
585}
586
587template< typename pass_type >
588void PassVisitor< pass_type >::visit( StructInstType * node ) {
589        VISIT_BODY( node ); 
590}
591
592template< typename pass_type >
593void PassVisitor< pass_type >::visit( UnionInstType * node ) {
594        VISIT_BODY( node ); 
595}
596
597template< typename pass_type >
598void PassVisitor< pass_type >::visit( EnumInstType * node ) {
599        VISIT_BODY( node ); 
600}
601
602template< typename pass_type >
603void PassVisitor< pass_type >::visit( TraitInstType * node ) {
604        VISIT_BODY( node ); 
605}
606
607template< typename pass_type >
608void PassVisitor< pass_type >::visit( TypeInstType * node ) {
609        VISIT_BODY( node ); 
610}
611
612template< typename pass_type >
613void PassVisitor< pass_type >::visit( TupleType * node ) {
614        VISIT_BODY( node ); 
615}
616
617template< typename pass_type >
618void PassVisitor< pass_type >::visit( TypeofType * node ) {
619        VISIT_BODY( node ); 
620}
621
622template< typename pass_type >
623void PassVisitor< pass_type >::visit( AttrType * node ) {
624        VISIT_BODY( node ); 
625}
626
627template< typename pass_type >
628void PassVisitor< pass_type >::visit( VarArgsType * node ) {
629        VISIT_BODY( node ); 
630}
631
632template< typename pass_type >
633void PassVisitor< pass_type >::visit( ZeroType * node ) {
634        VISIT_BODY( node ); 
635}
636
637template< typename pass_type >
638void PassVisitor< pass_type >::visit( OneType * node ) {
639        VISIT_BODY( node ); 
640}
641
642template< typename pass_type >
643void PassVisitor< pass_type >::visit( SingleInit * node ) {
644        VISIT_BODY( node ); 
645}
646
647template< typename pass_type >
648Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
649        MUTATE_START( node );
650
651        node->set_value( mutateExpression( node->get_value() ) );
652
653        MUTATE_END( Initializer, node );
654}
655
656template< typename pass_type >
657void PassVisitor< pass_type >::visit( ListInit * node ) {
658        VISIT_BODY( node ); 
659}
660
661template< typename pass_type >
662void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
663        VISIT_BODY( node ); 
664}
665
666template< typename pass_type >
667void PassVisitor< pass_type >::visit( Subrange * node ) {
668        VISIT_BODY( node ); 
669}
670
671template< typename pass_type >
672void PassVisitor< pass_type >::visit( Constant * node ) {
673        VISIT_BODY( node ); 
674}
675
676//---------------------------------------------------------------------------------------------------------------
677
678template< typename pass_type >
679DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
680        MUTATE_BODY( DeclarationWithType, node );
681}
682
683template< typename pass_type >
684DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
685        MUTATE_BODY( DeclarationWithType, node );
686}
687
688template< typename pass_type >
689Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
690        MUTATE_BODY( Declaration, node );
691}
692
693template< typename pass_type >
694Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
695        MUTATE_BODY( Declaration, node );
696}
697
698template< typename pass_type >
699Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
700        MUTATE_BODY( Declaration, node );
701}
702
703template< typename pass_type >
704Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
705        MUTATE_BODY( Declaration, node );
706}
707
708template< typename pass_type >
709TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
710        MUTATE_BODY( TypeDecl, node );
711}
712
713template< typename pass_type >
714Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
715        MUTATE_BODY( Declaration, node );
716}
717
718template< typename pass_type >
719AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
720        MUTATE_BODY( AsmDecl, node );
721}
722
723template< typename pass_type >
724Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
725        MUTATE_BODY( Statement, node );
726}
727
728template< typename pass_type >
729Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
730        MUTATE_BODY( Statement, node );
731}
732
733template< typename pass_type >
734Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
735        MUTATE_BODY( Statement, node );
736}
737
738template< typename pass_type >
739NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
740        MUTATE_BODY( NullStmt, node );
741}
742
743template< typename pass_type >
744Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
745        MUTATE_BODY( Statement, node );
746}
747
748template< typename pass_type >
749Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
750        MUTATE_BODY( Statement, node );
751}
752
753template< typename pass_type >
754Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
755        MUTATE_BODY( Expression, node );
756}
757
758template< typename pass_type >
759Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
760        MUTATE_BODY( Expression, node );
761}
762
763template< typename pass_type >
764Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
765        MUTATE_BODY( Expression, node );
766}
767
768template< typename pass_type >
769Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
770        MUTATE_BODY( Expression, node );
771}
772
773template< typename pass_type >
774Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
775        MUTATE_BODY( Expression, node );
776}
777
778template< typename pass_type >
779Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
780        MUTATE_BODY( Expression, node );
781}
782
783template< typename pass_type >
784Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
785        MUTATE_BODY( Expression, node );
786}
787
788template< typename pass_type >
789Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
790        MUTATE_BODY( Expression, node );
791}
792
793template< typename pass_type >
794Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
795        MUTATE_BODY( Expression, node );
796}
797
798template< typename pass_type >
799Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
800        MUTATE_BODY( Expression, node );
801}
802
803template< typename pass_type >
804Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
805        MUTATE_BODY( Expression, node );
806}
807
808template< typename pass_type >
809Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
810        MUTATE_BODY( Expression, node );
811}
812
813template< typename pass_type >
814Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
815        MUTATE_BODY( Expression, node );
816}
817
818template< typename pass_type >
819Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
820        MUTATE_BODY( Expression, node );
821}
822
823template< typename pass_type >
824Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
825        MUTATE_BODY( Expression, node );
826}
827
828template< typename pass_type >
829Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
830        MUTATE_BODY( Expression, node );
831}
832
833template< typename pass_type >
834Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
835        MUTATE_BODY( Expression, node );
836}
837
838template< typename pass_type >
839Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
840        MUTATE_BODY( Expression, node );
841}
842
843template< typename pass_type >
844Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
845        MUTATE_BODY( Expression, node );
846}
847
848template< typename pass_type >
849Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
850        MUTATE_BODY( Expression, node );
851}
852
853template< typename pass_type >
854Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
855        MUTATE_BODY( Expression, node );
856}
857
858template< typename pass_type >
859Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
860        MUTATE_BODY( Expression, node );
861}
862
863template< typename pass_type >
864Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
865        MUTATE_BODY( Expression, node );
866}
867
868template< typename pass_type >
869Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
870        MUTATE_BODY( Expression, node );
871}
872
873template< typename pass_type >
874Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
875        MUTATE_BODY( Expression, node );
876}
877
878template< typename pass_type >
879Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
880        MUTATE_BODY( Expression, node );
881}
882
883template< typename pass_type >
884Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
885        MUTATE_BODY( Expression, node );
886}
887
888template< typename pass_type >
889Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
890        MUTATE_BODY( Expression, node );
891}
892
893template< typename pass_type >
894Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) {
895        MUTATE_BODY( Expression, node );
896}
897
898template< typename pass_type >
899Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
900        MUTATE_BODY( Expression, node );
901}
902
903template< typename pass_type >
904Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
905        MUTATE_BODY( Expression, node );
906}
907
908template< typename pass_type >
909Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
910        MUTATE_BODY( Type, node );
911}
912
913template< typename pass_type >
914Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
915        MUTATE_BODY( Type, node );
916}
917
918template< typename pass_type >
919Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
920        MUTATE_BODY( Type, node );
921}
922
923template< typename pass_type >
924Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
925        MUTATE_BODY( Type, node );
926}
927
928template< typename pass_type >
929Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
930        MUTATE_BODY( Type, node );
931}
932
933template< typename pass_type >
934Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
935        MUTATE_BODY( Type, node );
936}
937
938template< typename pass_type >
939Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
940        MUTATE_BODY( Type, node );
941}
942
943template< typename pass_type >
944Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
945        MUTATE_BODY( Type, node );
946}
947
948template< typename pass_type >
949Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
950        MUTATE_BODY( Type, node );
951}
952
953template< typename pass_type >
954Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
955        MUTATE_BODY( Type, node );
956}
957
958template< typename pass_type >
959Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
960        MUTATE_BODY( Type, node );
961}
962
963template< typename pass_type >
964Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
965        MUTATE_BODY( Type, node );
966}
967
968template< typename pass_type >
969Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
970        MUTATE_BODY( Type, node );
971}
972
973template< typename pass_type >
974Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
975        MUTATE_BODY( Type, node );
976}
977
978template< typename pass_type >
979Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
980        MUTATE_BODY( Type, node );
981}
982
983template< typename pass_type >
984Type * PassVisitor< pass_type >::mutate( OneType * node ) {
985        MUTATE_BODY( Type, node );
986}
987
988template< typename pass_type >
989Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
990        MUTATE_BODY( Initializer, node );
991}
992
993template< typename pass_type >
994Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
995        MUTATE_BODY( Initializer, node );
996}
997
998template< typename pass_type >
999Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
1000        MUTATE_BODY( Subrange, node );
1001}
1002
1003template< typename pass_type >
1004Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
1005        MUTATE_BODY( Constant, node );
1006}
Note: See TracBrowser for help on using the repository browser.