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

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since ab904dc was ab904dc, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

Added mutator capabilities to the pass visitor
  • Property mode set to 100644
File size: 20.0 KB
Line 
1#pragma once
2
3#define VISIT_BODY( node )    \
4        call_previsit( node );  \
5        Visitor::visit( node ); \
6        call_postvisit( node ); \
7
8#define MUTATE_BODY( type, node )                   \
9        call_premutate( node );                       \
10        Mutator::mutate( node );                      \
11        auto ret = call_postmutate< type * >( node ); \
12        return ret;                                   \
13
14
15
16
17template< typename pass_type >
18void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
19        VISIT_BODY( node ); 
20}
21
22template< typename pass_type >
23void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
24        VISIT_BODY( node ); 
25}
26
27template< typename pass_type >
28void PassVisitor< pass_type >::visit( StructDecl * node ) {
29        VISIT_BODY( node ); 
30}
31
32template< typename pass_type >
33void PassVisitor< pass_type >::visit( UnionDecl * node ) {
34        VISIT_BODY( node ); 
35}
36
37template< typename pass_type >
38void PassVisitor< pass_type >::visit( EnumDecl * node ) {
39        VISIT_BODY( node ); 
40}
41
42template< typename pass_type >
43void PassVisitor< pass_type >::visit( TraitDecl * node ) {
44        VISIT_BODY( node ); 
45}
46
47template< typename pass_type >
48void PassVisitor< pass_type >::visit( TypeDecl * node ) {
49        VISIT_BODY( node ); 
50}
51
52template< typename pass_type >
53void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
54        VISIT_BODY( node ); 
55}
56
57template< typename pass_type >
58void PassVisitor< pass_type >::visit( AsmDecl * node ) {
59        VISIT_BODY( node ); 
60}
61
62template< typename pass_type >
63void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
64        VISIT_BODY( node ); 
65}
66
67template< typename pass_type >
68void PassVisitor< pass_type >::visit( ExprStmt * node ) {
69        VISIT_BODY( node ); 
70}
71
72template< typename pass_type >
73void PassVisitor< pass_type >::visit( AsmStmt * node ) {
74        VISIT_BODY( node ); 
75}
76
77template< typename pass_type >
78void PassVisitor< pass_type >::visit( IfStmt * node ) {
79        VISIT_BODY( node ); 
80}
81
82template< typename pass_type >
83void PassVisitor< pass_type >::visit( WhileStmt * node ) {
84        VISIT_BODY( node ); 
85}
86
87template< typename pass_type >
88void PassVisitor< pass_type >::visit( ForStmt * node ) {
89        VISIT_BODY( node ); 
90}
91
92template< typename pass_type >
93void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
94        VISIT_BODY( node ); 
95}
96
97template< typename pass_type >
98void PassVisitor< pass_type >::visit( CaseStmt * node ) {
99        VISIT_BODY( node ); 
100}
101
102template< typename pass_type >
103void PassVisitor< pass_type >::visit( BranchStmt * node ) {
104        VISIT_BODY( node ); 
105}
106
107template< typename pass_type >
108void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
109        VISIT_BODY( node ); 
110}
111
112template< typename pass_type >
113void PassVisitor< pass_type >::visit( TryStmt * node ) {
114        VISIT_BODY( node ); 
115}
116
117template< typename pass_type >
118void PassVisitor< pass_type >::visit( CatchStmt * node ) {
119        VISIT_BODY( node ); 
120}
121
122template< typename pass_type >
123void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
124        VISIT_BODY( node ); 
125}
126
127template< typename pass_type >
128void PassVisitor< pass_type >::visit( NullStmt * node ) {
129        VISIT_BODY( node ); 
130}
131
132template< typename pass_type >
133void PassVisitor< pass_type >::visit( DeclStmt * node ) {
134        VISIT_BODY( node ); 
135}
136
137template< typename pass_type >
138void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
139        VISIT_BODY( node ); 
140}
141
142template< typename pass_type >
143void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
144        VISIT_BODY( node ); 
145}
146
147template< typename pass_type >
148void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
149        VISIT_BODY( node ); 
150}
151
152template< typename pass_type >
153void PassVisitor< pass_type >::visit( NameExpr * node ) {
154        VISIT_BODY( node ); 
155}
156
157template< typename pass_type >
158void PassVisitor< pass_type >::visit( CastExpr * node ) {
159        VISIT_BODY( node ); 
160}
161
162template< typename pass_type >
163void PassVisitor< pass_type >::visit( AddressExpr * node ) {
164        VISIT_BODY( node ); 
165}
166
167template< typename pass_type >
168void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
169        VISIT_BODY( node ); 
170}
171
172template< typename pass_type >
173void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
174        VISIT_BODY( node ); 
175}
176
177template< typename pass_type >
178void PassVisitor< pass_type >::visit( MemberExpr * node ) {
179        VISIT_BODY( node ); 
180}
181
182template< typename pass_type >
183void PassVisitor< pass_type >::visit( VariableExpr * node ) {
184        VISIT_BODY( node ); 
185}
186
187template< typename pass_type >
188void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
189        VISIT_BODY( node ); 
190}
191
192template< typename pass_type >
193void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
194        VISIT_BODY( node ); 
195}
196
197template< typename pass_type >
198void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
199        VISIT_BODY( node ); 
200}
201
202template< typename pass_type >
203void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
204        VISIT_BODY( node ); 
205}
206
207template< typename pass_type >
208void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
209        VISIT_BODY( node ); 
210}
211
212template< typename pass_type >
213void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
214        VISIT_BODY( node ); 
215}
216
217template< typename pass_type >
218void PassVisitor< pass_type >::visit( AttrExpr * node ) {
219        VISIT_BODY( node ); 
220}
221
222template< typename pass_type >
223void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
224        VISIT_BODY( node ); 
225}
226
227template< typename pass_type >
228void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
229        VISIT_BODY( node ); 
230}
231
232template< typename pass_type >
233void PassVisitor< pass_type >::visit( CommaExpr * node ) {
234        VISIT_BODY( node ); 
235}
236
237template< typename pass_type >
238void PassVisitor< pass_type >::visit( TypeExpr * node ) {
239        VISIT_BODY( node ); 
240}
241
242template< typename pass_type >
243void PassVisitor< pass_type >::visit( AsmExpr * node ) {
244        VISIT_BODY( node ); 
245}
246
247template< typename pass_type >
248void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
249        VISIT_BODY( node ); 
250}
251
252template< typename pass_type >
253void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
254        VISIT_BODY( node ); 
255}
256
257template< typename pass_type >
258void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
259        VISIT_BODY( node ); 
260}
261
262template< typename pass_type >
263void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
264        VISIT_BODY( node ); 
265}
266
267template< typename pass_type >
268void PassVisitor< pass_type >::visit( RangeExpr * node ) {
269        VISIT_BODY( node ); 
270}
271
272template< typename pass_type >
273void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
274        VISIT_BODY( node ); 
275}
276
277template< typename pass_type >
278void PassVisitor< pass_type >::visit( TupleExpr * node ) {
279        VISIT_BODY( node ); 
280}
281
282template< typename pass_type >
283void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
284        VISIT_BODY( node ); 
285}
286
287template< typename pass_type >
288void PassVisitor< pass_type >::visit( MemberTupleExpr * node ) {
289        VISIT_BODY( node ); 
290}
291
292template< typename pass_type >
293void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
294        VISIT_BODY( node ); 
295}
296
297template< typename pass_type >
298void PassVisitor< pass_type >::visit( StmtExpr * node ) {
299        VISIT_BODY( node ); 
300}
301
302template< typename pass_type >
303void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
304        VISIT_BODY( node ); 
305}
306
307template< typename pass_type >
308void PassVisitor< pass_type >::visit( VoidType * node ) {
309        VISIT_BODY( node ); 
310}
311
312template< typename pass_type >
313void PassVisitor< pass_type >::visit( BasicType * node ) {
314        VISIT_BODY( node ); 
315}
316
317template< typename pass_type >
318void PassVisitor< pass_type >::visit( PointerType * node ) {
319        VISIT_BODY( node ); 
320}
321
322template< typename pass_type >
323void PassVisitor< pass_type >::visit( ArrayType * node ) {
324        VISIT_BODY( node ); 
325}
326
327template< typename pass_type >
328void PassVisitor< pass_type >::visit( FunctionType * node ) {
329        VISIT_BODY( node ); 
330}
331
332template< typename pass_type >
333void PassVisitor< pass_type >::visit( StructInstType * node ) {
334        VISIT_BODY( node ); 
335}
336
337template< typename pass_type >
338void PassVisitor< pass_type >::visit( UnionInstType * node ) {
339        VISIT_BODY( node ); 
340}
341
342template< typename pass_type >
343void PassVisitor< pass_type >::visit( EnumInstType * node ) {
344        VISIT_BODY( node ); 
345}
346
347template< typename pass_type >
348void PassVisitor< pass_type >::visit( TraitInstType * node ) {
349        VISIT_BODY( node ); 
350}
351
352template< typename pass_type >
353void PassVisitor< pass_type >::visit( TypeInstType * node ) {
354        VISIT_BODY( node ); 
355}
356
357template< typename pass_type >
358void PassVisitor< pass_type >::visit( TupleType * node ) {
359        VISIT_BODY( node ); 
360}
361
362template< typename pass_type >
363void PassVisitor< pass_type >::visit( TypeofType * node ) {
364        VISIT_BODY( node ); 
365}
366
367template< typename pass_type >
368void PassVisitor< pass_type >::visit( AttrType * node ) {
369        VISIT_BODY( node ); 
370}
371
372template< typename pass_type >
373void PassVisitor< pass_type >::visit( VarArgsType * node ) {
374        VISIT_BODY( node ); 
375}
376
377template< typename pass_type >
378void PassVisitor< pass_type >::visit( ZeroType * node ) {
379        VISIT_BODY( node ); 
380}
381
382template< typename pass_type >
383void PassVisitor< pass_type >::visit( OneType * node ) {
384        VISIT_BODY( node ); 
385}
386
387template< typename pass_type >
388void PassVisitor< pass_type >::visit( SingleInit * node ) {
389        VISIT_BODY( node ); 
390}
391
392template< typename pass_type >
393void PassVisitor< pass_type >::visit( ListInit * node ) {
394        VISIT_BODY( node ); 
395}
396
397template< typename pass_type >
398void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
399        VISIT_BODY( node ); 
400}
401
402template< typename pass_type >
403void PassVisitor< pass_type >::visit( Subrange * node ) {
404        VISIT_BODY( node ); 
405}
406
407template< typename pass_type >
408void PassVisitor< pass_type >::visit( Constant * node ) {
409        VISIT_BODY( node ); 
410}
411
412//---------------------------------------------------------------------------------------------------------------
413
414template< typename pass_type >
415DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
416        MUTATE_BODY( DeclarationWithType, node );
417}
418
419template< typename pass_type >
420DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
421        MUTATE_BODY( DeclarationWithType, node );
422}
423
424template< typename pass_type >
425Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
426        MUTATE_BODY( Declaration, node );
427}
428
429template< typename pass_type >
430Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
431        MUTATE_BODY( Declaration, node );
432}
433
434template< typename pass_type >
435Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
436        MUTATE_BODY( Declaration, node );
437}
438
439template< typename pass_type >
440Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
441        MUTATE_BODY( Declaration, node );
442}
443
444template< typename pass_type >
445TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
446        MUTATE_BODY( TypeDecl, node );
447}
448
449template< typename pass_type >
450Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
451        MUTATE_BODY( Declaration, node );
452}
453
454template< typename pass_type >
455AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
456        MUTATE_BODY( AsmDecl, node );
457}
458
459template< typename pass_type >
460CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
461        MUTATE_BODY( CompoundStmt, node );
462}
463
464template< typename pass_type >
465Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
466        MUTATE_BODY( Statement, node );
467}
468
469template< typename pass_type >
470Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
471        MUTATE_BODY( Statement, node );
472}
473
474template< typename pass_type >
475Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
476        MUTATE_BODY( Statement, node );
477}
478
479template< typename pass_type >
480Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
481        MUTATE_BODY( Statement, node );
482}
483
484template< typename pass_type >
485Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
486        MUTATE_BODY( Statement, node );
487}
488
489template< typename pass_type >
490Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
491        MUTATE_BODY( Statement, node );
492}
493
494template< typename pass_type >
495Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
496        MUTATE_BODY( Statement, node );
497}
498
499template< typename pass_type >
500Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
501        MUTATE_BODY( Statement, node );
502}
503
504template< typename pass_type >
505Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
506        MUTATE_BODY( Statement, node );
507}
508
509template< typename pass_type >
510Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
511        MUTATE_BODY( Statement, node );
512}
513
514template< typename pass_type >
515Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
516        MUTATE_BODY( Statement, node );
517}
518
519template< typename pass_type >
520Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
521        MUTATE_BODY( Statement, node );
522}
523
524template< typename pass_type >
525NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
526        MUTATE_BODY( NullStmt, node );
527}
528
529template< typename pass_type >
530Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
531        MUTATE_BODY( Statement, node );
532}
533
534template< typename pass_type >
535Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
536        MUTATE_BODY( Statement, node );
537}
538
539template< typename pass_type >
540Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
541        MUTATE_BODY( Expression, node );
542}
543
544template< typename pass_type >
545Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
546        MUTATE_BODY( Expression, node );
547}
548
549template< typename pass_type >
550Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
551        MUTATE_BODY( Expression, node );
552}
553
554template< typename pass_type >
555Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
556        MUTATE_BODY( Expression, node );
557}
558
559template< typename pass_type >
560Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
561        MUTATE_BODY( Expression, node );
562}
563
564template< typename pass_type >
565Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
566        MUTATE_BODY( Expression, node );
567}
568
569template< typename pass_type >
570Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
571        MUTATE_BODY( Expression, node );
572}
573
574template< typename pass_type >
575Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
576        MUTATE_BODY( Expression, node );
577}
578
579template< typename pass_type >
580Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
581        MUTATE_BODY( Expression, node );
582}
583
584template< typename pass_type >
585Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
586        MUTATE_BODY( Expression, node );
587}
588
589template< typename pass_type >
590Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
591        MUTATE_BODY( Expression, node );
592}
593
594template< typename pass_type >
595Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
596        MUTATE_BODY( Expression, node );
597}
598
599template< typename pass_type >
600Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
601        MUTATE_BODY( Expression, node );
602}
603
604template< typename pass_type >
605Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
606        MUTATE_BODY( Expression, node );
607}
608
609template< typename pass_type >
610Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
611        MUTATE_BODY( Expression, node );
612}
613
614template< typename pass_type >
615Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
616        MUTATE_BODY( Expression, node );
617}
618
619template< typename pass_type >
620Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
621        MUTATE_BODY( Expression, node );
622}
623
624template< typename pass_type >
625Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
626        MUTATE_BODY( Expression, node );
627}
628
629template< typename pass_type >
630Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
631        MUTATE_BODY( Expression, node );
632}
633
634template< typename pass_type >
635Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
636        MUTATE_BODY( Expression, node );
637}
638
639template< typename pass_type >
640Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
641        MUTATE_BODY( Expression, node );
642}
643
644template< typename pass_type >
645Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
646        MUTATE_BODY( Expression, node );
647}
648
649template< typename pass_type >
650Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
651        MUTATE_BODY( Expression, node );
652}
653
654template< typename pass_type >
655Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
656        MUTATE_BODY( Expression, node );
657}
658
659template< typename pass_type >
660Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
661        MUTATE_BODY( Expression, node );
662}
663
664template< typename pass_type >
665Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
666        MUTATE_BODY( Expression, node );
667}
668
669template< typename pass_type >
670Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
671        MUTATE_BODY( Expression, node );
672}
673
674template< typename pass_type >
675Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
676        MUTATE_BODY( Expression, node );
677}
678
679template< typename pass_type >
680Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
681        MUTATE_BODY( Expression, node );
682}
683
684template< typename pass_type >
685Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) {
686        MUTATE_BODY( Expression, node );
687}
688
689template< typename pass_type >
690Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
691        MUTATE_BODY( Expression, node );
692}
693
694template< typename pass_type >
695Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
696        MUTATE_BODY( Expression, node );
697}
698
699template< typename pass_type >
700Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
701        MUTATE_BODY( Expression, node );
702}
703
704template< typename pass_type >
705Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
706        MUTATE_BODY( Type, node );
707}
708
709template< typename pass_type >
710Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
711        MUTATE_BODY( Type, node );
712}
713
714template< typename pass_type >
715Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
716        MUTATE_BODY( Type, node );
717}
718
719template< typename pass_type >
720Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
721        MUTATE_BODY( Type, node );
722}
723
724template< typename pass_type >
725Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
726        MUTATE_BODY( Type, node );
727}
728
729template< typename pass_type >
730Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
731        MUTATE_BODY( Type, node );
732}
733
734template< typename pass_type >
735Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
736        MUTATE_BODY( Type, node );
737}
738
739template< typename pass_type >
740Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
741        MUTATE_BODY( Type, node );
742}
743
744template< typename pass_type >
745Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
746        MUTATE_BODY( Type, node );
747}
748
749template< typename pass_type >
750Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
751        MUTATE_BODY( Type, node );
752}
753
754template< typename pass_type >
755Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
756        MUTATE_BODY( Type, node );
757}
758
759template< typename pass_type >
760Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
761        MUTATE_BODY( Type, node );
762}
763
764template< typename pass_type >
765Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
766        MUTATE_BODY( Type, node );
767}
768
769template< typename pass_type >
770Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
771        MUTATE_BODY( Type, node );
772}
773
774template< typename pass_type >
775Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
776        MUTATE_BODY( Type, node );
777}
778
779template< typename pass_type >
780Type * PassVisitor< pass_type >::mutate( OneType * node ) {
781        MUTATE_BODY( Type, node );
782}
783
784template< typename pass_type >
785Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
786        MUTATE_BODY( Initializer, node );
787}
788
789template< typename pass_type >
790Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
791        MUTATE_BODY( Initializer, node );
792}
793
794template< typename pass_type >
795Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
796        MUTATE_BODY( Initializer, node );
797}
798
799template< typename pass_type >
800Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
801        MUTATE_BODY( Subrange, node );
802}
803
804template< typename pass_type >
805Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
806        MUTATE_BODY( Constant, node );
807}
Note: See TracBrowser for help on using the repository browser.