Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Mutator.cc

    rcfaf9be r61255ad  
    3333Mutator::~Mutator() {}
    3434
     35DeclarationWithType * 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
     43DeclarationWithType * 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
     50Declaration * Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
     51        mutateAll( aggregateDecl->get_parameters(), *this );
     52        mutateAll( aggregateDecl->get_members(), *this );
     53        return aggregateDecl;
     54}
     55
     56Declaration * Mutator::mutate( StructDecl *aggregateDecl ) {
     57        handleAggregateDecl( aggregateDecl );
     58        return aggregateDecl;
     59}
     60
     61Declaration * Mutator::mutate( UnionDecl *aggregateDecl ) {
     62        handleAggregateDecl( aggregateDecl );
     63        return aggregateDecl;
     64}
     65
     66Declaration * Mutator::mutate( EnumDecl *aggregateDecl ) {
     67        handleAggregateDecl( aggregateDecl );
     68        return aggregateDecl;
     69}
     70
     71Declaration * Mutator::mutate( TraitDecl *aggregateDecl ) {
     72        handleAggregateDecl( aggregateDecl );
     73        return aggregateDecl;
     74}
     75
     76Declaration * 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
     83Declaration * Mutator::mutate( TypeDecl *typeDecl ) {
     84        handleNamedTypeDecl( typeDecl );
     85        typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
     86        return typeDecl;
     87}
     88
     89Declaration * Mutator::mutate( TypedefDecl *typeDecl ) {
     90        handleNamedTypeDecl( typeDecl );
     91        return typeDecl;
     92}
     93
     94AsmDecl * Mutator::mutate( AsmDecl *asmDecl ) {
     95        asmDecl->set_stmt( maybeMutate( asmDecl->get_stmt(), *this ) );
     96        return asmDecl;
     97}
     98
     99
     100CompoundStmt * Mutator::mutate( CompoundStmt *compoundStmt ) {
     101        mutateAll( compoundStmt->get_kids(), *this );
     102        return compoundStmt;
     103}
     104
     105Statement * Mutator::mutate( ExprStmt *exprStmt ) {
     106        exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
     107        return exprStmt;
     108}
     109
     110Statement * 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
     118Statement * 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
     126Statement * 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
     132Statement * 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
     140Statement * Mutator::mutate( SwitchStmt *switchStmt ) {
     141        switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
     142        mutateAll( switchStmt->get_statements(), *this );
     143        return switchStmt;
     144}
     145
     146Statement * 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
     153Statement * Mutator::mutate( BranchStmt *branchStmt ) {
     154        return branchStmt;
     155}
     156
     157Statement * Mutator::mutate( ReturnStmt *returnStmt ) {
     158        returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
     159        return returnStmt;
     160}
     161
     162Statement * 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
     168Statement * 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
     175Statement * 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
     182Statement * Mutator::mutate( FinallyStmt *finalStmt ) {
     183        finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
     184        return finalStmt;
     185}
     186
     187Statement * 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
     205Statement * Mutator::mutate( WithStmt * withStmt ) {
     206        mutateAll( withStmt->exprs, *this );
     207        withStmt->stmt = maybeMutate( withStmt->stmt, *this );
     208        return withStmt;
     209}
     210
     211NullStmt * Mutator::mutate( NullStmt *nullStmt ) {
     212        return nullStmt;
     213}
     214
     215Statement * Mutator::mutate( DeclStmt *declStmt ) {
     216        declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
     217        return declStmt;
     218}
     219
     220Statement * Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
     221        impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
     222        return impCtorDtorStmt;
     223}
     224
     225
     226Expression * 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
     234Expression * 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
     241Expression * 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
     247Expression * 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
     254Expression * 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
     260Expression * 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
     267Expression * 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
     274Expression * 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
     282Expression * 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
     289Expression * 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
     295Expression * 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
     302Expression * 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
     313Expression * 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
     324Expression * 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
     331Expression * 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
     339Expression * 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
     346Expression * 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
     357Expression * 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
     365Expression * 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
     374Expression * 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
     382Expression * 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
     389Expression * 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
     397Expression* 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
     407Expression* 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
     414Expression * 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
     421Expression * 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
     428Expression * 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
     435Expression * 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
     442Expression * 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
     449Expression * 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
     456Expression * 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
     465Expression * 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
     472Expression * 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
     480Expression * 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
     489Type * Mutator::mutate( VoidType *voidType ) {
     490        mutateAll( voidType->get_forall(), *this );
     491        return voidType;
     492}
     493
     494Type * Mutator::mutate( BasicType *basicType ) {
     495        mutateAll( basicType->get_forall(), *this );
     496        return basicType;
     497}
     498
     499Type * Mutator::mutate( PointerType *pointerType ) {
     500        mutateAll( pointerType->get_forall(), *this );
     501        pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
     502        return pointerType;
     503}
     504
     505Type * 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
     512Type * Mutator::mutate( ReferenceType * refType ) {
     513        mutateAll( refType->get_forall(), *this );
     514        refType->set_base( maybeMutate( refType->get_base(), *this ) );
     515        return refType;
     516}
     517
     518Type * 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
     525Type * Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
     526        mutateAll( aggregateUseType->get_forall(), *this );
     527        mutateAll( aggregateUseType->get_parameters(), *this );
     528        return aggregateUseType;
     529}
     530
     531Type * Mutator::mutate( StructInstType *aggregateUseType ) {
     532        handleReferenceToType( aggregateUseType );
     533        return aggregateUseType;
     534}
     535
     536Type * Mutator::mutate( UnionInstType *aggregateUseType ) {
     537        handleReferenceToType( aggregateUseType );
     538        return aggregateUseType;
     539}
     540
     541Type * Mutator::mutate( EnumInstType *aggregateUseType ) {
     542        handleReferenceToType( aggregateUseType );
     543        return aggregateUseType;
     544}
     545
     546Type * Mutator::mutate( TraitInstType *aggregateUseType ) {
     547        handleReferenceToType( aggregateUseType );
     548        return aggregateUseType;
     549}
     550
     551Type * Mutator::mutate( TypeInstType *aggregateUseType ) {
     552        handleReferenceToType( aggregateUseType );
     553        return aggregateUseType;
     554}
     555
    35556Type * Mutator::mutate( TupleType *tupleType ) {
    36557        mutateAll( tupleType->get_forall(), *this );
Note: See TracChangeset for help on using the changeset viewer.