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

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 3fb9a83 was 3fb9a83, checked in by Thierry Delisle <tdelisle@…>, 8 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.