source: src/Common/PassVisitor.impl.h @ 296b2be

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 296b2be was 296b2be, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

PassVisitor? now supports features given by PolyMutator?

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