Changeset cfaf9be for src/SynTree/Mutator.cc
 Timestamp:
 Feb 27, 2018, 5:50:22 PM (7 years ago)
 Branches:
 ADT, aaronthesis, armeh, astexperimental, cleanupdtors, deferred_resn, demangler, enum, forallpointerdecay, jacob/cs343translation, jenkinssandbox, master, newast, newastuniqueexpr, newenv, no_list, persistentindexer, pthreademulation, qualifiedEnum, resolvnew, with_gc
 Children:
 4b1be68
 Parents:
 86e84e4
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

src/SynTree/Mutator.cc
r86e84e4 rcfaf9be 32 32 33 33 Mutator::~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 }555 34 556 35 Type * Mutator::mutate( TupleType *tupleType ) {
Note: See TracChangeset
for help on using the changeset viewer.