source: src/Common/PassVisitor.impl.h@ 49c9773

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 49c9773 was 134322e, checked in by Thierry Delisle <tdelisle@…>, 8 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.