source: src/Common/PassVisitor.impl.h @ 3fb9a83

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

Fixed implementation of env, some optim needed

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