Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Mutator.cc

    r61255ad rcfaf9be  
    3232
    3333Mutator::~Mutator() {}
    34 
    35 DeclarationWithType * Mutator::mutate( ObjectDecl *objectDecl ) {
    36         objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
    37         objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
    38         objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) );
    39         mutateAll( objectDecl->attributes, *this );
    40         return objectDecl;
    41 }
    42 
    43 DeclarationWithType * Mutator::mutate( FunctionDecl *functionDecl ) {
    44         functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
    45         functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
    46         mutateAll( functionDecl->attributes, *this );
    47         return functionDecl;
    48 }
    49 
    50 Declaration * Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
    51         mutateAll( aggregateDecl->get_parameters(), *this );
    52         mutateAll( aggregateDecl->get_members(), *this );
    53         return aggregateDecl;
    54 }
    55 
    56 Declaration * Mutator::mutate( StructDecl *aggregateDecl ) {
    57         handleAggregateDecl( aggregateDecl );
    58         return aggregateDecl;
    59 }
    60 
    61 Declaration * Mutator::mutate( UnionDecl *aggregateDecl ) {
    62         handleAggregateDecl( aggregateDecl );
    63         return aggregateDecl;
    64 }
    65 
    66 Declaration * Mutator::mutate( EnumDecl *aggregateDecl ) {
    67         handleAggregateDecl( aggregateDecl );
    68         return aggregateDecl;
    69 }
    70 
    71 Declaration * Mutator::mutate( TraitDecl *aggregateDecl ) {
    72         handleAggregateDecl( aggregateDecl );
    73         return aggregateDecl;
    74 }
    75 
    76 Declaration * Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
    77         mutateAll( typeDecl->get_parameters(), *this );
    78         mutateAll( typeDecl->get_assertions(), *this );
    79         typeDecl->set_base( maybeMutate( typeDecl->get_base(), *this ) );
    80         return typeDecl;
    81 }
    82 
    83 Declaration * Mutator::mutate( TypeDecl *typeDecl ) {
    84         handleNamedTypeDecl( typeDecl );
    85         typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
    86         return typeDecl;
    87 }
    88 
    89 Declaration * Mutator::mutate( TypedefDecl *typeDecl ) {
    90         handleNamedTypeDecl( typeDecl );
    91         return typeDecl;
    92 }
    93 
    94 AsmDecl * Mutator::mutate( AsmDecl *asmDecl ) {
    95         asmDecl->set_stmt( maybeMutate( asmDecl->get_stmt(), *this ) );
    96         return asmDecl;
    97 }
    98 
    99 
    100 CompoundStmt * Mutator::mutate( CompoundStmt *compoundStmt ) {
    101         mutateAll( compoundStmt->get_kids(), *this );
    102         return compoundStmt;
    103 }
    104 
    105 Statement * Mutator::mutate( ExprStmt *exprStmt ) {
    106         exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
    107         return exprStmt;
    108 }
    109 
    110 Statement * Mutator::mutate( AsmStmt *asmStmt ) {
    111         asmStmt->set_instruction( maybeMutate( asmStmt->get_instruction(), *this ) );
    112         mutateAll( asmStmt->get_output(), *this );
    113         mutateAll( asmStmt->get_input(), *this );
    114         mutateAll( asmStmt->get_clobber(), *this );
    115         return asmStmt;
    116 }
    117 
    118 Statement * Mutator::mutate( IfStmt *ifStmt ) {
    119         mutateAll( ifStmt->get_initialization(), *this );
    120         ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
    121         ifStmt->set_thenPart( maybeMutate( ifStmt->get_thenPart(), *this ) );
    122         ifStmt->set_elsePart( maybeMutate( ifStmt->get_elsePart(), *this ) );
    123         return ifStmt;
    124 }
    125 
    126 Statement * Mutator::mutate( WhileStmt *whileStmt ) {
    127         whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
    128         whileStmt->set_body( maybeMutate( whileStmt->get_body(), *this ) );
    129         return whileStmt;
    130 }
    131 
    132 Statement * Mutator::mutate( ForStmt *forStmt ) {
    133         mutateAll( forStmt->get_initialization(), *this );
    134         forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) );
    135         forStmt->set_increment( maybeMutate( forStmt->get_increment(), *this ) );
    136         forStmt->set_body( maybeMutate( forStmt->get_body(), *this ) );
    137         return forStmt;
    138 }
    139 
    140 Statement * Mutator::mutate( SwitchStmt *switchStmt ) {
    141         switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
    142         mutateAll( switchStmt->get_statements(), *this );
    143         return switchStmt;
    144 }
    145 
    146 Statement * Mutator::mutate( CaseStmt *caseStmt ) {
    147         caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
    148         mutateAll (caseStmt->get_statements(), *this );
    149 
    150         return caseStmt;
    151 }
    152 
    153 Statement * Mutator::mutate( BranchStmt *branchStmt ) {
    154         return branchStmt;
    155 }
    156 
    157 Statement * Mutator::mutate( ReturnStmt *returnStmt ) {
    158         returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
    159         return returnStmt;
    160 }
    161 
    162 Statement * Mutator::mutate( ThrowStmt *throwStmt ) {
    163         throwStmt->set_expr( maybeMutate( throwStmt->get_expr(), *this ) );
    164         throwStmt->set_target( maybeMutate( throwStmt->get_target(), *this ) );
    165         return throwStmt;
    166 }
    167 
    168 Statement * Mutator::mutate( TryStmt *tryStmt ) {
    169         tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
    170         mutateAll( tryStmt->get_catchers(), *this );
    171         tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
    172         return tryStmt;
    173 }
    174 
    175 Statement * Mutator::mutate( CatchStmt *catchStmt ) {
    176         catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
    177         catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
    178         catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
    179         return catchStmt;
    180 }
    181 
    182 Statement * Mutator::mutate( FinallyStmt *finalStmt ) {
    183         finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
    184         return finalStmt;
    185 }
    186 
    187 Statement * Mutator::mutate( WaitForStmt *waitforStmt ) {
    188         for( auto & clause : waitforStmt->clauses ) {
    189                 clause.target.function = maybeMutate( clause.target.function, *this );
    190                 mutateAll( clause.target.arguments, *this );
    191 
    192                 clause.statement = maybeMutate( clause.statement, *this );
    193                 clause.condition = maybeMutate( clause.condition, *this );
    194         }
    195 
    196         waitforStmt->timeout.time      = maybeMutate( waitforStmt->timeout.time, *this );
    197         waitforStmt->timeout.statement = maybeMutate( waitforStmt->timeout.statement, *this );
    198         waitforStmt->timeout.condition = maybeMutate( waitforStmt->timeout.condition, *this );
    199         waitforStmt->orelse.statement  = maybeMutate( waitforStmt->orelse.statement, *this );
    200         waitforStmt->orelse.condition  = maybeMutate( waitforStmt->orelse.condition, *this );
    201 
    202         return waitforStmt;
    203 }
    204 
    205 Statement * Mutator::mutate( WithStmt * withStmt ) {
    206         mutateAll( withStmt->exprs, *this );
    207         withStmt->stmt = maybeMutate( withStmt->stmt, *this );
    208         return withStmt;
    209 }
    210 
    211 NullStmt * Mutator::mutate( NullStmt *nullStmt ) {
    212         return nullStmt;
    213 }
    214 
    215 Statement * Mutator::mutate( DeclStmt *declStmt ) {
    216         declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
    217         return declStmt;
    218 }
    219 
    220 Statement * Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
    221         impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
    222         return impCtorDtorStmt;
    223 }
    224 
    225 
    226 Expression * Mutator::mutate( ApplicationExpr *applicationExpr ) {
    227         applicationExpr->set_env( maybeMutate( applicationExpr->get_env(), *this ) );
    228         applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
    229         applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
    230         mutateAll( applicationExpr->get_args(), *this );
    231         return applicationExpr;
    232 }
    233 
    234 Expression * Mutator::mutate( UntypedExpr *untypedExpr ) {
    235         untypedExpr->set_env( maybeMutate( untypedExpr->get_env(), *this ) );
    236         untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
    237         mutateAll( untypedExpr->get_args(), *this );
    238         return untypedExpr;
    239 }
    240 
    241 Expression * Mutator::mutate( NameExpr *nameExpr ) {
    242         nameExpr->set_env( maybeMutate( nameExpr->get_env(), *this ) );
    243         nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
    244         return nameExpr;
    245 }
    246 
    247 Expression * Mutator::mutate( AddressExpr *addressExpr ) {
    248         addressExpr->set_env( maybeMutate( addressExpr->get_env(), *this ) );
    249         addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
    250         addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
    251         return addressExpr;
    252 }
    253 
    254 Expression * Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
    255         labelAddressExpr->set_env( maybeMutate( labelAddressExpr->get_env(), *this ) );
    256         labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
    257         return labelAddressExpr;
    258 }
    259 
    260 Expression * Mutator::mutate( CastExpr *castExpr ) {
    261         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
    262         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
    263         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
    264         return castExpr;
    265 }
    266 
    267 Expression * Mutator::mutate( VirtualCastExpr *castExpr ) {
    268         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
    269         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
    270         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
    271         return castExpr;
    272 }
    273 
    274 Expression * Mutator::mutate( UntypedMemberExpr *memberExpr ) {
    275         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
    276         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
    277         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
    278         memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
    279         return memberExpr;
    280 }
    281 
    282 Expression * Mutator::mutate( MemberExpr *memberExpr ) {
    283         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
    284         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
    285         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
    286         return memberExpr;
    287 }
    288 
    289 Expression * Mutator::mutate( VariableExpr *variableExpr ) {
    290         variableExpr->set_env( maybeMutate( variableExpr->get_env(), *this ) );
    291         variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
    292         return variableExpr;
    293 }
    294 
    295 Expression * Mutator::mutate( ConstantExpr *constantExpr ) {
    296         constantExpr->set_env( maybeMutate( constantExpr->get_env(), *this ) );
    297         constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
    298 //  maybeMutate( constantExpr->get_constant(), *this )
    299         return constantExpr;
    300 }
    301 
    302 Expression * Mutator::mutate( SizeofExpr *sizeofExpr ) {
    303         sizeofExpr->set_env( maybeMutate( sizeofExpr->get_env(), *this ) );
    304         sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
    305         if ( sizeofExpr->get_isType() ) {
    306                 sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
    307         } else {
    308                 sizeofExpr->set_expr( maybeMutate( sizeofExpr->get_expr(), *this ) );
    309         }
    310         return sizeofExpr;
    311 }
    312 
    313 Expression * Mutator::mutate( AlignofExpr *alignofExpr ) {
    314         alignofExpr->set_env( maybeMutate( alignofExpr->get_env(), *this ) );
    315         alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
    316         if ( alignofExpr->get_isType() ) {
    317                 alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
    318         } else {
    319                 alignofExpr->set_expr( maybeMutate( alignofExpr->get_expr(), *this ) );
    320         }
    321         return alignofExpr;
    322 }
    323 
    324 Expression * Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
    325         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
    326         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
    327         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
    328         return offsetofExpr;
    329 }
    330 
    331 Expression * Mutator::mutate( OffsetofExpr *offsetofExpr ) {
    332         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
    333         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
    334         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
    335         offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
    336         return offsetofExpr;
    337 }
    338 
    339 Expression * Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
    340         offsetPackExpr->set_env( maybeMutate( offsetPackExpr->get_env(), *this ) );
    341         offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
    342         offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
    343         return offsetPackExpr;
    344 }
    345 
    346 Expression * Mutator::mutate( AttrExpr *attrExpr ) {
    347         attrExpr->set_env( maybeMutate( attrExpr->get_env(), *this ) );
    348         attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
    349         if ( attrExpr->get_isType() ) {
    350                 attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
    351         } else {
    352                 attrExpr->set_expr( maybeMutate( attrExpr->get_expr(), *this ) );
    353         }
    354         return attrExpr;
    355 }
    356 
    357 Expression * Mutator::mutate( LogicalExpr *logicalExpr ) {
    358         logicalExpr->set_env( maybeMutate( logicalExpr->get_env(), *this ) );
    359         logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
    360         logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
    361         logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
    362         return logicalExpr;
    363 }
    364 
    365 Expression * Mutator::mutate( ConditionalExpr *conditionalExpr ) {
    366         conditionalExpr->set_env( maybeMutate( conditionalExpr->get_env(), *this ) );
    367         conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
    368         conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
    369         conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
    370         conditionalExpr->set_arg3( maybeMutate( conditionalExpr->get_arg3(), *this ) );
    371         return conditionalExpr;
    372 }
    373 
    374 Expression * Mutator::mutate( CommaExpr *commaExpr ) {
    375         commaExpr->set_env( maybeMutate( commaExpr->get_env(), *this ) );
    376         commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
    377         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
    378         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
    379         return commaExpr;
    380 }
    381 
    382 Expression * Mutator::mutate( TypeExpr *typeExpr ) {
    383         typeExpr->set_env( maybeMutate( typeExpr->get_env(), *this ) );
    384         typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
    385         typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
    386         return typeExpr;
    387 }
    388 
    389 Expression * Mutator::mutate( AsmExpr *asmExpr ) {
    390         asmExpr->set_env( maybeMutate( asmExpr->get_env(), *this ) );
    391         asmExpr->set_inout( maybeMutate( asmExpr->get_inout(), *this ) );
    392         asmExpr->set_constraint( maybeMutate( asmExpr->get_constraint(), *this ) );
    393         asmExpr->set_operand( maybeMutate( asmExpr->get_operand(), *this ) );
    394         return asmExpr;
    395 }
    396 
    397 Expression* Mutator::mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    398         impCpCtorExpr->set_env( maybeMutate( impCpCtorExpr->get_env(), *this ) );
    399         impCpCtorExpr->set_result( maybeMutate( impCpCtorExpr->get_result(), *this ) );
    400         impCpCtorExpr->set_callExpr( maybeMutate( impCpCtorExpr->get_callExpr(), *this ) );
    401         mutateAll( impCpCtorExpr->get_tempDecls(), *this );
    402         mutateAll( impCpCtorExpr->get_returnDecls(), *this );
    403         mutateAll( impCpCtorExpr->get_dtors(), *this );
    404         return impCpCtorExpr;
    405 }
    406 
    407 Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
    408         ctorExpr->set_env( maybeMutate( ctorExpr->get_env(), *this ) );
    409         ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
    410         ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
    411         return ctorExpr;
    412 }
    413 
    414 Expression * Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
    415         compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) );
    416         compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
    417         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    418         return compLitExpr;
    419 }
    420 
    421 Expression * Mutator::mutate( RangeExpr *rangeExpr ) {
    422         rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) );
    423         rangeExpr->set_low( maybeMutate( rangeExpr->get_low(), *this ) );
    424         rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
    425         return rangeExpr;
    426 }
    427 
    428 Expression * Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
    429         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
    430         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    431         mutateAll( tupleExpr->get_exprs(), *this );
    432         return tupleExpr;
    433 }
    434 
    435 Expression * Mutator::mutate( TupleExpr *tupleExpr ) {
    436         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
    437         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    438         mutateAll( tupleExpr->get_exprs(), *this );
    439         return tupleExpr;
    440 }
    441 
    442 Expression * Mutator::mutate( TupleIndexExpr *tupleExpr ) {
    443         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
    444         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    445         tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
    446         return tupleExpr;
    447 }
    448 
    449 Expression * Mutator::mutate( TupleAssignExpr *assignExpr ) {
    450         assignExpr->set_env( maybeMutate( assignExpr->get_env(), *this ) );
    451         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
    452         assignExpr->set_stmtExpr( maybeMutate( assignExpr->get_stmtExpr(), *this ) );
    453         return assignExpr;
    454 }
    455 
    456 Expression * Mutator::mutate( StmtExpr *stmtExpr ) {
    457         stmtExpr->set_env( maybeMutate( stmtExpr->get_env(), *this ) );
    458         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
    459         stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
    460         mutateAll( stmtExpr->get_returnDecls(), *this );
    461         mutateAll( stmtExpr->get_dtors(), *this );
    462         return stmtExpr;
    463 }
    464 
    465 Expression * Mutator::mutate( UniqueExpr *uniqueExpr ) {
    466         uniqueExpr->set_env( maybeMutate( uniqueExpr->get_env(), *this ) );
    467         uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
    468         uniqueExpr->set_expr( maybeMutate( uniqueExpr->get_expr(), *this ) );
    469         return uniqueExpr;
    470 }
    471 
    472 Expression * Mutator::mutate( UntypedInitExpr * initExpr ) {
    473         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
    474         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
    475         initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
    476         // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver.
    477         return initExpr;
    478 }
    479 
    480 Expression * Mutator::mutate( InitExpr * initExpr ) {
    481         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
    482         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
    483         initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
    484         initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) );
    485         return initExpr;
    486 }
    487 
    488 
    489 Type * Mutator::mutate( VoidType *voidType ) {
    490         mutateAll( voidType->get_forall(), *this );
    491         return voidType;
    492 }
    493 
    494 Type * Mutator::mutate( BasicType *basicType ) {
    495         mutateAll( basicType->get_forall(), *this );
    496         return basicType;
    497 }
    498 
    499 Type * Mutator::mutate( PointerType *pointerType ) {
    500         mutateAll( pointerType->get_forall(), *this );
    501         pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
    502         return pointerType;
    503 }
    504 
    505 Type * Mutator::mutate( ArrayType *arrayType ) {
    506         mutateAll( arrayType->get_forall(), *this );
    507         arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
    508         arrayType->set_base( maybeMutate( arrayType->get_base(), *this ) );
    509         return arrayType;
    510 }
    511 
    512 Type * Mutator::mutate( ReferenceType * refType ) {
    513         mutateAll( refType->get_forall(), *this );
    514         refType->set_base( maybeMutate( refType->get_base(), *this ) );
    515         return refType;
    516 }
    517 
    518 Type * Mutator::mutate( FunctionType * functionType ) {
    519         mutateAll( functionType->get_forall(), *this );
    520         mutateAll( functionType->get_returnVals(), *this );
    521         mutateAll( functionType->get_parameters(), *this );
    522         return functionType;
    523 }
    524 
    525 Type * Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
    526         mutateAll( aggregateUseType->get_forall(), *this );
    527         mutateAll( aggregateUseType->get_parameters(), *this );
    528         return aggregateUseType;
    529 }
    530 
    531 Type * Mutator::mutate( StructInstType *aggregateUseType ) {
    532         handleReferenceToType( aggregateUseType );
    533         return aggregateUseType;
    534 }
    535 
    536 Type * Mutator::mutate( UnionInstType *aggregateUseType ) {
    537         handleReferenceToType( aggregateUseType );
    538         return aggregateUseType;
    539 }
    540 
    541 Type * Mutator::mutate( EnumInstType *aggregateUseType ) {
    542         handleReferenceToType( aggregateUseType );
    543         return aggregateUseType;
    544 }
    545 
    546 Type * Mutator::mutate( TraitInstType *aggregateUseType ) {
    547         handleReferenceToType( aggregateUseType );
    548         return aggregateUseType;
    549 }
    550 
    551 Type * Mutator::mutate( TypeInstType *aggregateUseType ) {
    552         handleReferenceToType( aggregateUseType );
    553         return aggregateUseType;
    554 }
    55534
    55635Type * Mutator::mutate( TupleType *tupleType ) {
Note: See TracChangeset for help on using the changeset viewer.