Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Common/PassVisitor.impl.h

    r9dcb653 r2065609  
    101101}
    102102
    103 template< typename Container, typename VisitorType >
    104 inline void maybeAccept( Container &container, VisitorType &visitor ) {
    105         SemanticError errors;
    106         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
    107                 try {
    108                         if ( *i ) {
    109                                 (*i)->accept( visitor );
    110                         }
    111                 } catch( SemanticError &e ) {
    112                         e.set_location( (*i)->location );
    113                         errors.append( e );
    114                 }
    115         }
    116         if ( ! errors.isEmpty() ) {
    117                 throw errors;
    118         }
    119 }
    120 
    121 template< typename Container, typename MutatorType >
    122 inline void maybeMutateRef( Container &container, MutatorType &mutator ) {
    123         SemanticError errors;
    124         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
    125                 try {
    126                         if ( *i ) {
    127 ///                 *i = (*i)->acceptMutator( mutator );
    128                                 *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
    129                                 assert( *i );
    130                         } // if
    131                 } catch( SemanticError &e ) {
    132                         e.set_location( (*i)->location );
    133                         errors.append( e );
    134                 } // try
    135         } // for
    136         if ( ! errors.isEmpty() ) {
    137                 throw errors;
    138         } // if
    139 }
    140 
    141103template< typename pass_type >
    142104template< typename func_t >
    … …  
    268230
    269231//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    270 //========================================================================================================================================================================
    271 //========================================================================================================================================================================
    272 //========================================================================================================================================================================
    273 //========================================================================================================================================================================
    274 //========================================================================================================================================================================
    275 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    276 
    277 
    278 //--------------------------------------------------------------------------
    279 // ObjectDecl
     232
    280233template< typename pass_type >
    281234void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
    282         VISIT_START( node );
    283 
    284         indexerScopedAccept( node->type         , *this );
    285         maybeAccept        ( node->init         , *this );
    286         maybeAccept        ( node->bitfieldWidth, *this );
    287 
    288         if ( node->name != "" ) {
    289                 indexerAddId( node );
    290         }
    291 
    292         VISIT_END( node );
    293 }
    294 
    295 template< typename pass_type >
    296 DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
    297         MUTATE_START( node );
    298 
    299         indexerScopedMutate( node->type         , *this );
    300         maybeMutateRef     ( node->init         , *this );
    301         maybeMutateRef     ( node->bitfieldWidth, *this );
    302 
    303         if ( node->name != "" ) {
    304                 indexerAddId( node );
    305         }
    306 
    307         MUTATE_END( DeclarationWithType, node );
    308 }
    309 
    310 //--------------------------------------------------------------------------
    311 // FunctionDecl
     235        VISIT_BODY( node );
     236}
     237
    312238template< typename pass_type >
    313239void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
    314         VISIT_START( node );
    315 
    316         if ( node->name != "" ) {
    317                 indexerAddId( node );
    318         }
    319 
    320         {
    321                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    322                 maybeAccept( node->type, *this );
    323                 maybeAccept( node->statements, *this );
    324         }
    325 
    326         VISIT_END( node );
    327 }
    328 
    329 template< typename pass_type >
    330 DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
    331         MUTATE_START( node );
    332 
    333         if ( node->name != "" ) {
    334                 indexerAddId( node );
    335         }
    336 
    337         {
    338                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    339                 maybeMutateRef( node->type, *this );
    340                 maybeMutateRef( node->statements, *this );
    341         }
    342 
    343         MUTATE_END( DeclarationWithType, node );
    344 }
    345 
    346 //--------------------------------------------------------------------------
    347 // StructDecl
     240        VISIT_BODY( node );
     241}
     242
    348243template< typename pass_type >
    349244void PassVisitor< pass_type >::visit( StructDecl * node ) {
    350         VISIT_START( node );
    351 
    352         // make up a forward declaration and add it before processing the members
    353         // needs to be on the heap because addStruct saves the pointer
    354         indexerAddStructFwd( node );
    355 
    356         {
    357                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    358                 maybeAccept( node->parameters, *this );
    359                 maybeAccept( node->members   , *this );
    360         }
    361 
    362         // this addition replaces the forward declaration
    363         indexerAddStruct( node );
    364 
    365         VISIT_END( node );
    366 }
    367 
    368 template< typename pass_type >
    369 Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
    370         MUTATE_START( node );
    371 
    372         // make up a forward declaration and add it before processing the members
    373         // needs to be on the heap because addStruct saves the pointer
    374         indexerAddStructFwd( node );
    375 
    376         {
    377                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    378                 maybeMutateRef( node->parameters, *this );
    379                 maybeMutateRef( node->members   , *this );
    380         }
    381 
    382         // this addition replaces the forward declaration
    383         indexerAddStruct( node );
    384 
    385         MUTATE_END( Declaration, node );
    386 }
    387 
    388 //--------------------------------------------------------------------------
    389 // UnionDecl
     245        VISIT_BODY( node );
     246}
     247
    390248template< typename pass_type >
    391249void PassVisitor< pass_type >::visit( UnionDecl * node ) {
    392         VISIT_START( node );
    393 
    394         // make up a forward declaration and add it before processing the members
    395         indexerAddUnionFwd( node );
    396 
    397         {
    398                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    399                 maybeAccept( node->parameters, *this );
    400                 maybeAccept( node->members   , *this );
    401         }
    402 
    403         indexerAddUnion( node );
    404 
    405         VISIT_END( node );
    406 }
    407 
    408 template< typename pass_type >
    409 Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
    410         MUTATE_START( node );
    411 
    412         // make up a forward declaration and add it before processing the members
    413         indexerAddUnionFwd( node );
    414 
    415         {
    416                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    417                 maybeMutateRef( node->parameters, *this );
    418                 maybeMutateRef( node->members   , *this );
    419         }
    420 
    421         indexerAddUnion( node );
    422 
    423         MUTATE_END( Declaration, node );
    424 }
    425 
    426 //--------------------------------------------------------------------------
    427 // EnumDecl
     250        VISIT_BODY( node );
     251}
     252
    428253template< typename pass_type >
    429254void PassVisitor< pass_type >::visit( EnumDecl * node ) {
    430         VISIT_START( node );
    431 
    432         indexerAddEnum( node );
    433 
    434         // unlike structs, contexts, and unions, enums inject their members into the global scope
    435         maybeAccept( node->parameters, *this );
    436         maybeAccept( node->members   , *this );
    437 
    438         VISIT_END( node );
    439 }
    440 
    441 template< typename pass_type >
    442 Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
    443         MUTATE_START( node );
    444 
    445         indexerAddEnum( node );
    446 
    447         // unlike structs, contexts, and unions, enums inject their members into the global scope
    448         maybeMutateRef( node->parameters, *this );
    449         maybeMutateRef( node->members   , *this );
    450 
    451         MUTATE_END( Declaration, node );
    452 }
    453 
    454 //--------------------------------------------------------------------------
    455 // TraitDecl
     255        VISIT_BODY( node );
     256}
     257
    456258template< typename pass_type >
    457259void PassVisitor< pass_type >::visit( TraitDecl * node ) {
    458         VISIT_START( node );
    459 
    460         {
    461                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    462                 maybeAccept( node->parameters, *this );
    463                 maybeAccept( node->members   , *this );
    464         }
    465 
    466         indexerAddTrait( node );
    467 
    468         VISIT_END( node );
    469 }
    470 
    471 template< typename pass_type >
    472 Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
    473         MUTATE_START( node );
    474 
    475         {
    476                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    477                 maybeMutateRef( node->parameters, *this );
    478                 maybeMutateRef( node->members   , *this );
    479         }
    480 
    481         indexerAddTrait( node );
    482 
    483         MUTATE_END( Declaration, node );
    484 }
    485 
    486 //--------------------------------------------------------------------------
    487 // TypeDecl
     260        VISIT_BODY( node );
     261}
     262
    488263template< typename pass_type >
    489264void PassVisitor< pass_type >::visit( TypeDecl * node ) {
    490         VISIT_START( node );
    491 
    492         {
    493                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    494                 maybeAccept( node->parameters, *this );
    495                 maybeAccept( node->base      , *this );
    496         }
    497 
    498         indexerAddType( node );
    499 
    500         maybeAccept( node->assertions, *this );
    501 
    502         indexerScopedAccept( node->init, *this );
    503 
    504         VISIT_END( node );
    505 }
    506 
    507 template< typename pass_type >
    508 TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
    509         MUTATE_START( node );
    510 
    511         {
    512                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    513                 maybeMutateRef( node->parameters, *this );
    514                 maybeMutateRef( node->base      , *this );
    515         }
    516 
    517         indexerAddType( node );
    518 
    519         maybeMutateRef( node->assertions, *this );
    520 
    521         indexerScopedMutate( node->init, *this );
    522 
    523         MUTATE_END( TypeDecl, node );
    524 }
    525 
    526 //--------------------------------------------------------------------------
    527 // TypedefDecl
     265        VISIT_BODY( node );
     266}
     267
    528268template< typename pass_type >
    529269void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
    530         VISIT_START( node );
    531 
    532         {
    533                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    534                 maybeAccept( node->parameters, *this );
    535                 maybeAccept( node->base      , *this );
    536         }
    537 
    538         indexerAddType( node );
    539 
    540         maybeAccept( node->assertions, *this );
    541 
    542         VISIT_END( node );
    543 }
    544 
    545 template< typename pass_type >
    546 Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
    547         MUTATE_START( node );
    548 
    549         {
    550                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    551                 maybeMutateRef     ( node->parameters, *this );
    552                 maybeMutateRef( node->base      , *this );
    553         }
    554 
    555         indexerAddType( node );
    556 
    557         maybeMutateRef( node->assertions, *this );
    558 
    559         MUTATE_END( Declaration, node );
    560 }
    561 
    562 //--------------------------------------------------------------------------
    563 // AsmDecl
     270        VISIT_BODY( node );
     271}
     272
    564273template< typename pass_type >
    565274void PassVisitor< pass_type >::visit( AsmDecl * node ) {
    566         VISIT_START( node );
    567 
    568         maybeAccept( node->stmt, *this );
    569 
    570         VISIT_END( node );
    571 }
    572 
    573 template< typename pass_type >
    574 AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
    575         MUTATE_START( node );
    576 
    577         maybeMutateRef( node->stmt, *this );
    578 
    579         MUTATE_END( AsmDecl, node );
     275        VISIT_BODY( node );
    580276}
    581277
    … …  
    585281void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
    586282        VISIT_START( node );
    587         {
    588                 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    589                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
    590                 visitStatementList( node->kids );
    591         }
     283        call_beginScope();
     284
     285        visitStatementList( node->get_kids() );
     286
     287        call_endScope();
    592288        VISIT_END( node );
    593289}
    … …  
    596292CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
    597293        MUTATE_START( node );
    598         {
    599                 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    600                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
    601                 mutateStatementList( node->kids );
    602         }
     294        call_beginScope();
     295
     296        mutateStatementList( node->get_kids() );
     297
     298        call_endScope();
    603299        MUTATE_END( CompoundStmt, node );
    604300}
    … …  
    610306        VISIT_START( node );
    611307
    612         visitExpression( node->expr );
     308        visitExpression( node->get_expr() );
    613309
    614310        VISIT_END( node );
    … …  
    619315        MUTATE_START( node );
    620316
    621         node->expr = mutateExpression( node->expr );
     317        node->set_expr( mutateExpression( node->get_expr() ) );
    622318
    623319        MUTATE_END( Statement, node );
    … …  
    642338        VISIT_START( node );
    643339
    644         visitExpression( node->condition );
    645         node->thenPart = visitStatement( node->thenPart );
    646         node->elsePart = visitStatement( node->elsePart );
     340        visitExpression( node->get_condition() );
     341        node->set_thenPart ( visitStatement( node->get_thenPart() ) );
     342        node->set_elsePart ( visitStatement( node->get_elsePart() ) );
    647343
    648344        VISIT_END( node );
    … …  
    652348Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
    653349        MUTATE_START( node );
    654         {
    655                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    656                 node->condition = mutateExpression( node->condition );
    657                 node->thenPart  = mutateStatement ( node->thenPart  );
    658                 node->elsePart  = mutateStatement ( node->elsePart  );
    659         }
     350
     351        node->set_condition( mutateExpression( node->get_condition() ) );
     352        node->set_thenPart ( mutateStatement ( node->get_thenPart()  ) );
     353        node->set_elsePart ( mutateStatement ( node->get_elsePart()  ) );
     354
    660355        MUTATE_END( Statement, node );
    661356}
    … …  
    667362        VISIT_START( node );
    668363
    669         visitExpression( node->condition );
    670         node->body = visitStatement( node->body );
     364        visitExpression( node->get_condition() );
     365        node->set_body( visitStatement( node->get_body() ) );
    671366
    672367        VISIT_END( node );
    … …  
    677372        MUTATE_START( node );
    678373
    679         node->condition = mutateExpression( node->condition );
    680         node->body      = mutateStatement ( node->body      );
     374        node->set_condition( mutateExpression( node->get_condition() ) );
     375        node->set_body( mutateStatement( node->get_body() ) );
    681376
    682377        MUTATE_END( Statement, node );
    … …  
    688383void PassVisitor< pass_type >::visit( ForStmt * node ) {
    689384        VISIT_START( node );
    690         {
    691                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    692                 maybeAccept( node->initialization, *this );
    693                 visitExpression( node->condition );
    694                 visitExpression( node->increment );
    695                 node->body = visitStatement( node->body );
    696         }
     385
     386        acceptAll( node->get_initialization(), *this );
     387        visitExpression( node->get_condition() );
     388        visitExpression( node->get_increment() );
     389        node->set_body( visitStatement( node->get_body() ) );
     390
    697391        VISIT_END( node );
    698392}
    … …  
    701395Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
    702396        MUTATE_START( node );
    703         {
    704                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    705                 maybeMutateRef( node->initialization, *this );
    706                 node->condition = mutateExpression( node->condition );
    707                 node->increment = mutateExpression( node->increment );
    708                 node->body      = mutateStatement ( node->body      );
    709         }
     397
     398        mutateAll( node->get_initialization(), *this );
     399        node->set_condition( mutateExpression( node->get_condition() ) );
     400        node->set_increment( mutateExpression( node->get_increment() ) );
     401        node->set_body( mutateStatement( node->get_body() ) );
     402
    710403        MUTATE_END( Statement, node );
    711404}
    … …  
    717410        VISIT_START( node );
    718411
    719         visitExpression   ( node->condition );
    720         visitStatementList( node->statements );
     412        visitExpression( node->get_condition() );
     413        visitStatementList( node->get_statements() );
    721414
    722415        VISIT_END( node );
    … …  
    727420        MUTATE_START( node );
    728421
    729         node->condition = mutateExpression( node->condition );
    730         mutateStatementList( node->statements );
     422        node->set_condition( mutateExpression( node->get_condition() ) );
     423        mutateStatementList( node->get_statements() );
    731424
    732425        MUTATE_END( Statement, node );
    … …  
    739432        VISIT_START( node );
    740433
    741         visitExpression   ( node->condition );
    742         visitStatementList( node->stmts    );
     434        visitExpression( node->get_condition() );
     435        visitStatementList( node->get_statements() );
    743436
    744437        VISIT_END( node );
    … …  
    749442        MUTATE_START( node );
    750443
    751         node->condition = mutateExpression( node->condition );
    752         mutateStatementList( node->stmts );
     444        node->set_condition(  mutateExpression( node->get_condition() ) );
     445        mutateStatementList( node->get_statements() );
    753446
    754447        MUTATE_END( Statement, node );
    … …  
    773466        VISIT_START( node );
    774467
    775         visitExpression( node->expr );
     468        visitExpression( node->get_expr() );
    776469
    777470        VISIT_END( node );
    … …  
    782475        MUTATE_START( node );
    783476
    784         node->expr = mutateExpression( node->expr );
     477        node->set_expr( mutateExpression( node->get_expr() ) );
    785478
    786479        MUTATE_END( Statement, node );
    … …  
    806499        VISIT_START( node );
    807500
    808         maybeAccept( node->block       , *this );
    809         maybeAccept( node->handlers    , *this );
    810         maybeAccept( node->finallyBlock, *this );
     501        maybeAccept( node->get_block(), *this );
     502        acceptAll( node->get_catchers(), *this );
     503        maybeAccept( node->get_finally(), *this );
    811504
    812505        VISIT_END( node );
    … …  
    817510        MUTATE_START( node );
    818511
    819         maybeMutateRef( node->block       , *this );
    820         maybeMutateRef( node->handlers    , *this );
    821         maybeMutateRef( node->finallyBlock, *this );
     512        node->set_block(  maybeMutate( node->get_block(), *this ) );
     513        mutateAll( node->get_catchers(), *this );
     514        node->set_finally( maybeMutate( node->get_finally(), *this ) );
    822515
    823516        MUTATE_END( Statement, node );
    … …  
    829522void PassVisitor< pass_type >::visit( CatchStmt * node ) {
    830523        VISIT_START( node );
    831         {
    832                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    833                 maybeAccept( node->decl, *this );
    834                 node->cond = visitExpression( node->cond );
    835                 node->body = visitStatement ( node->body );
    836         }
     524
     525        maybeAccept( node->get_decl(), *this );
     526        node->set_cond( visitExpression( node->get_cond() ) );
     527        node->set_body( visitStatement( node->get_body() ) );
     528
    837529        VISIT_END( node );
    838530}
    … …  
    841533Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
    842534        MUTATE_START( node );
    843         {
    844                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    845                 maybeMutateRef( node->decl, *this );
    846                 node->cond = mutateExpression( node->cond );
    847                 node->body = mutateStatement ( node->body );
    848         }
     535
     536        node->set_decl( maybeMutate( node->get_decl(), *this ) );
     537        node->set_cond( mutateExpression( node->get_cond() ) );
     538        node->set_body( mutateStatement( node->get_body() ) );
     539
    849540        MUTATE_END( Statement, node );
    850541}
    … …  
    914605template< typename pass_type >
    915606void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
    916         VISIT_START( node );
    917 
    918         indexerScopedAccept( node->result  , *this );
    919         maybeAccept        ( node->function, *this );
    920         maybeAccept        ( node->args    , *this );
    921 
    922         VISIT_END( node );
     607        VISIT_BODY( node );
    923608}
    924609
    925610template< typename pass_type >
    926611Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
    927         MUTATE_START( node );
    928 
    929         indexerScopedMutate( node->env     , *this );
    930         indexerScopedMutate( node->result  , *this );
    931         maybeMutateRef     ( node->function, *this );
    932         maybeMutateRef     ( node->args    , *this );
    933 
    934         MUTATE_END( Expression, node );
     612        MUTATE_BODY( Expression, node );
    935613}
    936614
    … …  
    942620
    943621        // maybeAccept( node->get_env(), *this );
    944         indexerScopedAccept( node->result, *this );
    945 
    946         for ( auto expr : node->args ) {
     622        maybeAccept( node->get_result(), *this );
     623
     624        for ( auto expr : node->get_args() ) {
    947625                visitExpression( expr );
    948626        }
    … …  
    955633        MUTATE_START( node );
    956634
    957         indexerScopedMutate( node->env   , *this );
    958         indexerScopedMutate( node->result, *this );
    959 
    960         for ( auto& expr : node->args ) {
     635        node->set_env( maybeMutate( node->get_env(), *this ) );
     636        node->set_result( maybeMutate( node->get_result(), *this ) );
     637
     638        for ( auto& expr : node->get_args() ) {
    961639                expr = mutateExpression( expr );
    962640        }
    … …  
    965643}
    966644
    967 //--------------------------------------------------------------------------
    968 // NameExpr
    969645template< typename pass_type >
    970646void PassVisitor< pass_type >::visit( NameExpr * node ) {
    971         VISIT_START( node );
    972 
    973         indexerScopedAccept( node->result, *this );
    974 
    975         VISIT_END( node );
    976 }
    977 
    978 template< typename pass_type >
    979 Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
    980         MUTATE_START( node );
    981 
    982         indexerScopedMutate( node->env   , *this );
    983         indexerScopedMutate( node->result, *this );
    984 
    985         MUTATE_END( Expression, node );
    986 }
    987 
    988 //--------------------------------------------------------------------------
    989 // CastExpr
     647        VISIT_BODY( node );
     648}
     649
    990650template< typename pass_type >
    991651void PassVisitor< pass_type >::visit( CastExpr * node ) {
    992         VISIT_START( node );
    993 
    994         indexerScopedAccept( node->result, *this );
    995         maybeAccept        ( node->arg   , *this );
    996 
    997         VISIT_END( node );
    998 }
    999 
    1000 template< typename pass_type >
    1001 Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
    1002         MUTATE_START( node );
    1003 
    1004         indexerScopedMutate( node->env   , *this );
    1005         indexerScopedMutate( node->result, *this );
    1006         maybeMutateRef     ( node->arg   , *this );
    1007 
    1008         MUTATE_END( Expression, node );
    1009 }
    1010 
    1011 //--------------------------------------------------------------------------
    1012 // VirtualCastExpr
     652        VISIT_BODY( node );
     653}
     654
    1013655template< typename pass_type >
    1014656void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
    1015         VISIT_START( node );
    1016 
    1017         indexerScopedAccept( node->result, *this );
    1018         maybeAccept( node->arg, *this );
    1019 
    1020         VISIT_END( node );
    1021 }
    1022 
    1023 template< typename pass_type >
    1024 Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
    1025         MUTATE_START( node );
    1026 
    1027         indexerScopedMutate( node->env   , *this );
    1028         indexerScopedMutate( node->result, *this );
    1029         maybeMutateRef     ( node->arg   , *this );
    1030 
    1031         MUTATE_END( Expression, node );
    1032 }
    1033 
    1034 //--------------------------------------------------------------------------
    1035 // AddressExpr
     657        VISIT_BODY( node );
     658}
     659
    1036660template< typename pass_type >
    1037661void PassVisitor< pass_type >::visit( AddressExpr * node ) {
    1038         VISIT_START( node );
    1039 
    1040         indexerScopedAccept( node->result, *this );
    1041         maybeAccept        ( node->arg   , *this );
    1042 
    1043         VISIT_END( node );
    1044 }
    1045 
    1046 template< typename pass_type >
    1047 Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
    1048         MUTATE_START( node );
    1049 
    1050         indexerScopedMutate( node->env   , *this );
    1051         indexerScopedMutate( node->result, *this );
    1052         maybeMutateRef     ( node->arg   , *this );
    1053 
    1054         MUTATE_END( Expression, node );
    1055 }
    1056 
    1057 //--------------------------------------------------------------------------
    1058 // LabelAddressExpr
     662        VISIT_BODY( node );
     663}
     664
    1059665template< typename pass_type >
    1060666void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
    1061         VISIT_START( node );
    1062 
    1063         indexerScopedAccept( node->result, *this );
    1064 
    1065         VISIT_END( node );
    1066 }
    1067 
    1068 template< typename pass_type >
    1069 Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
    1070         MUTATE_START( node );
    1071 
    1072         indexerScopedMutate( node->env   , *this );
    1073         indexerScopedMutate( node->result, *this );
    1074 
    1075         MUTATE_END( Expression, node );
    1076 }
    1077 
    1078 //--------------------------------------------------------------------------
    1079 // UntypedMemberExpr
     667        VISIT_BODY( node );
     668}
     669
    1080670template< typename pass_type >
    1081671void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
    1082         VISIT_START( node );
    1083 
    1084         indexerScopedAccept( node->result   , *this );
    1085         maybeAccept        ( node->aggregate, *this );
    1086         maybeAccept        ( node->member   , *this );
    1087 
    1088         VISIT_END( node );
    1089 }
    1090 
    1091 template< typename pass_type >
    1092 Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
    1093         MUTATE_START( node );
    1094 
    1095         indexerScopedMutate( node->env      , *this );
    1096         indexerScopedMutate( node->result   , *this );
    1097         maybeMutateRef     ( node->aggregate, *this );
    1098         maybeMutateRef     ( node->member   , *this );
    1099 
    1100         MUTATE_END( Expression, node );
    1101 }
    1102 
    1103 //--------------------------------------------------------------------------
    1104 // MemberExpr
     672        VISIT_BODY( node );
     673}
     674
    1105675template< typename pass_type >
    1106676void PassVisitor< pass_type >::visit( MemberExpr * node ) {
    1107         VISIT_START( node );
    1108 
    1109         indexerScopedAccept( node->result   , *this );
    1110         maybeAccept        ( node->aggregate, *this );
    1111 
    1112         VISIT_END( node );
    1113 }
    1114 
    1115 template< typename pass_type >
    1116 Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
    1117         MUTATE_START( node );
    1118 
    1119         indexerScopedMutate( node->env      , *this );
    1120         indexerScopedMutate( node->result   , *this );
    1121         maybeMutateRef     ( node->aggregate, *this );
    1122 
    1123         MUTATE_END( Expression, node );
    1124 }
    1125 
    1126 //--------------------------------------------------------------------------
    1127 // VariableExpr
     677        VISIT_BODY( node );
     678}
     679
    1128680template< typename pass_type >
    1129681void PassVisitor< pass_type >::visit( VariableExpr * node ) {
    1130         VISIT_START( node );
    1131 
    1132         indexerScopedAccept( node->result, *this );
    1133 
    1134         VISIT_END( node );
    1135 }
    1136 
    1137 template< typename pass_type >
    1138 Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
    1139         MUTATE_START( node );
    1140 
    1141         indexerScopedMutate( node->env   , *this );
    1142         indexerScopedMutate( node->result, *this );
    1143 
    1144         MUTATE_END( Expression, node );
    1145 }
    1146 
    1147 //--------------------------------------------------------------------------
    1148 // ConstantExpr
     682        VISIT_BODY( node );
     683}
     684
    1149685template< typename pass_type >
    1150686void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
    1151         VISIT_START( node );
    1152 
    1153         indexerScopedAccept( node->result   , *this );
    1154         maybeAccept        ( &node->constant, *this );
    1155 
    1156         VISIT_END( node );
    1157 }
    1158 
    1159 template< typename pass_type >
    1160 Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
    1161         MUTATE_START( node );
    1162 
    1163         indexerScopedMutate( node->env   , *this );
    1164         indexerScopedMutate( node->result, *this );
    1165         node->constant = *maybeMutate( &node->constant, *this );
    1166 
    1167         MUTATE_END( Expression, node );
    1168 }
    1169 
    1170 //--------------------------------------------------------------------------
    1171 // SizeofExpr
     687        VISIT_BODY( node );
     688}
     689
    1172690template< typename pass_type >
    1173691void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
    1174         VISIT_START( node );
    1175 
    1176         indexerScopedAccept( node->result, *this );
    1177         if ( node->get_isType() ) {
    1178                 maybeAccept( node->type, *this );
    1179         } else {
    1180                 maybeAccept( node->expr, *this );
    1181         }
    1182 
    1183         VISIT_END( node );
    1184 }
    1185 
    1186 template< typename pass_type >
    1187 Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
    1188         MUTATE_START( node );
    1189 
    1190         indexerScopedMutate( node->env   , *this );
    1191         indexerScopedMutate( node->result, *this );
    1192         if ( node->get_isType() ) {
    1193                 maybeMutateRef( node->type, *this );
    1194         } else {
    1195                 maybeMutateRef( node->expr, *this );
    1196         }
    1197 
    1198         MUTATE_END( Expression, node );
    1199 }
    1200 
    1201 //--------------------------------------------------------------------------
    1202 // AlignofExpr
     692        VISIT_BODY( node );
     693}
     694
    1203695template< typename pass_type >
    1204696void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
    1205         VISIT_START( node );
    1206 
    1207         indexerScopedAccept( node->result, *this );
    1208         if ( node->get_isType() ) {
    1209                 maybeAccept( node->type, *this );
    1210         } else {
    1211                 maybeAccept( node->expr, *this );
    1212         }
    1213 
    1214         VISIT_END( node );
    1215 }
    1216 
    1217 template< typename pass_type >
    1218 Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
    1219         MUTATE_START( node );
    1220 
    1221         indexerScopedMutate( node->env   , *this );
    1222         indexerScopedMutate( node->result, *this );
    1223         if ( node->get_isType() ) {
    1224                 maybeMutateRef( node->type, *this );
    1225         } else {
    1226                 maybeMutateRef( node->expr, *this );
    1227         }
    1228 
    1229         MUTATE_END( Expression, node );
    1230 }
    1231 
    1232 //--------------------------------------------------------------------------
    1233 // UntypedOffsetofExpr
     697        VISIT_BODY( node );
     698}
     699
    1234700template< typename pass_type >
    1235701void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
    1236         VISIT_START( node );
    1237 
    1238         indexerScopedAccept( node->result, *this );
    1239         maybeAccept        ( node->type  , *this );
    1240 
    1241         VISIT_END( node );
    1242 }
    1243 
    1244 template< typename pass_type >
    1245 Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
    1246         MUTATE_START( node );
    1247 
    1248         indexerScopedMutate( node->env   , *this );
    1249         indexerScopedMutate( node->result, *this );
    1250         maybeMutateRef     ( node->type  , *this );
    1251 
    1252         MUTATE_END( Expression, node );
    1253 }
    1254 
    1255 //--------------------------------------------------------------------------
    1256 // OffsetofExpr
     702        VISIT_BODY( node );
     703}
     704
    1257705template< typename pass_type >
    1258706void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
    1259         VISIT_START( node );
    1260 
    1261         indexerScopedAccept( node->result, *this );
    1262         maybeAccept        ( node->type  , *this );
    1263         maybeAccept        ( node->member, *this );
    1264 
    1265         VISIT_END( node );
    1266 }
    1267 
    1268 template< typename pass_type >
    1269 Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
    1270         MUTATE_START( node );
    1271 
    1272         indexerScopedMutate( node->env   , *this );
    1273         indexerScopedMutate( node->result, *this );
    1274         maybeMutateRef     ( node->type  , *this );
    1275         maybeMutateRef     ( node->member, *this );
    1276 
    1277         MUTATE_END( Expression, node );
    1278 }
    1279 
    1280 //--------------------------------------------------------------------------
    1281 // OffsetPackExpr
     707        VISIT_BODY( node );
     708}
     709
    1282710template< typename pass_type >
    1283711void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
    1284         VISIT_START( node );
    1285 
    1286         indexerScopedAccept( node->result, *this );
    1287         maybeAccept        ( node->type  , *this );
    1288 
    1289         VISIT_END( node );
    1290 }
    1291 
    1292 template< typename pass_type >
    1293 Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
    1294         MUTATE_START( node );
    1295 
    1296         indexerScopedMutate( node->env   , *this );
    1297         indexerScopedMutate( node->result, *this );
    1298         maybeMutateRef     ( node->type  , *this );
    1299 
    1300         MUTATE_END( Expression, node );
    1301 }
    1302 
    1303 //--------------------------------------------------------------------------
    1304 // AttrExpr
     712        VISIT_BODY( node );
     713}
     714
    1305715template< typename pass_type >
    1306716void PassVisitor< pass_type >::visit( AttrExpr * node ) {
    1307         VISIT_START( node );
    1308 
    1309         indexerScopedAccept( node->result, *this );
    1310         if ( node->get_isType() ) {
    1311                 maybeAccept( node->type, *this );
    1312         } else {
    1313                 maybeAccept( node->expr, *this );
    1314         }
    1315 
    1316         VISIT_END( node );
    1317 }
    1318 
    1319 template< typename pass_type >
    1320 Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
    1321         MUTATE_START( node );
    1322 
    1323         indexerScopedMutate( node->env   , *this );
    1324         indexerScopedMutate( node->result, *this );
    1325         if ( node->get_isType() ) {
    1326                 maybeMutateRef( node->type, *this );
    1327         } else {
    1328                 maybeMutateRef( node->expr, *this );
    1329         }
    1330 
    1331         MUTATE_END( Expression, node );
    1332 }
    1333 
    1334 //--------------------------------------------------------------------------
    1335 // LogicalExpr
     717        VISIT_BODY( node );
     718}
     719
    1336720template< typename pass_type >
    1337721void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
    1338         VISIT_START( node );
    1339 
    1340         indexerScopedAccept( node->result, *this );
    1341         maybeAccept        ( node->arg1  , *this );
    1342         maybeAccept        ( node->arg2  , *this );
    1343 
    1344         VISIT_END( node );
    1345 }
    1346 
    1347 template< typename pass_type >
    1348 Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
    1349         MUTATE_START( node );
    1350 
    1351         indexerScopedMutate( node->env   , *this );
    1352         indexerScopedMutate( node->result, *this );
    1353         maybeMutateRef     ( node->arg1  , *this );
    1354         maybeMutateRef     ( node->arg2  , *this );
    1355 
    1356         MUTATE_END( Expression, node );
    1357 }
    1358 
    1359 //--------------------------------------------------------------------------
    1360 // ConditionalExpr
     722        VISIT_BODY( node );
     723}
     724
    1361725template< typename pass_type >
    1362726void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
    1363         VISIT_START( node );
    1364 
    1365         indexerScopedAccept( node->result, *this );
    1366         maybeAccept        ( node->arg1  , *this );
    1367         maybeAccept        ( node->arg2  , *this );
    1368         maybeAccept        ( node->arg3  , *this );
    1369 
    1370         VISIT_END( node );
    1371 }
    1372 
    1373 template< typename pass_type >
    1374 Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
    1375         MUTATE_START( node );
    1376 
    1377         indexerScopedMutate( node->env   , *this );
    1378         indexerScopedMutate( node->result, *this );
    1379         maybeMutateRef     ( node->arg1  , *this );
    1380         maybeMutateRef     ( node->arg2  , *this );
    1381         maybeMutateRef     ( node->arg3  , *this );
    1382 
    1383         MUTATE_END( Expression, node );
    1384 }
    1385 
    1386 //--------------------------------------------------------------------------
    1387 // CommaExpr
     727        VISIT_BODY( node );
     728}
     729
    1388730template< typename pass_type >
    1389731void PassVisitor< pass_type >::visit( CommaExpr * node ) {
    1390         VISIT_START( node );
    1391 
    1392         indexerScopedAccept( node->result, *this );
    1393         maybeAccept        ( node->arg1  , *this );
    1394         maybeAccept        ( node->arg2  , *this );
    1395 
    1396         VISIT_END( node );
    1397 }
    1398 
    1399 template< typename pass_type >
    1400 Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
    1401         MUTATE_START( node );
    1402 
    1403         indexerScopedMutate( node->env   , *this );
    1404         indexerScopedMutate( node->result, *this );
    1405         maybeMutateRef     ( node->arg1  , *this );
    1406         maybeMutateRef     ( node->arg2  , *this );
    1407 
    1408         MUTATE_END( Expression, node );
    1409 }
    1410 
    1411 //--------------------------------------------------------------------------
    1412 // TypeExpr
     732        VISIT_BODY( node );
     733}
     734
    1413735template< typename pass_type >
    1414736void PassVisitor< pass_type >::visit( TypeExpr * node ) {
    1415         VISIT_START( node );
    1416 
    1417         indexerScopedAccept( node->result, *this );
    1418         maybeAccept        ( node->type, *this );
    1419 
    1420         VISIT_END( node );
    1421 }
    1422 
    1423 template< typename pass_type >
    1424 Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
    1425         MUTATE_START( node );
    1426 
    1427         indexerScopedMutate( node->env   , *this );
    1428         indexerScopedMutate( node->result, *this );
    1429         maybeMutateRef     ( node->type  , *this );
    1430 
    1431         MUTATE_END( Expression, node );
    1432 }
    1433 
    1434 //--------------------------------------------------------------------------
    1435 // AsmExpr
     737        VISIT_BODY( node );
     738}
     739
    1436740template< typename pass_type >
    1437741void PassVisitor< pass_type >::visit( AsmExpr * node ) {
    1438         VISIT_START( node );
    1439 
    1440         indexerScopedAccept( node->result    , *this );
    1441         maybeAccept        ( node->inout     , *this );
    1442         maybeAccept        ( node->constraint, *this );
    1443         maybeAccept        ( node->operand   , *this );
    1444 
    1445         VISIT_END( node );
    1446 }
    1447 
    1448 template< typename pass_type >
    1449 Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
    1450         MUTATE_START( node );
    1451 
    1452         indexerScopedMutate( node->env       , *this );
    1453         indexerScopedMutate( node->result    , *this );
    1454         maybeMutateRef     ( node->inout     , *this );
    1455         maybeMutateRef     ( node->constraint, *this );
    1456         maybeMutateRef     ( node->operand   , *this );
    1457 
    1458         MUTATE_END( Expression, node );
    1459 }
    1460 
    1461 //--------------------------------------------------------------------------
    1462 // ImplicitCopyCtorExpr
     742        VISIT_BODY( node );
     743}
     744
    1463745template< typename pass_type >
    1464746void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
    1465         VISIT_START( node );
    1466 
    1467         indexerScopedAccept( node->result     , *this );
    1468         maybeAccept        ( node->callExpr   , *this );
    1469         maybeAccept        ( node->tempDecls  , *this );
    1470         maybeAccept        ( node->returnDecls, *this );
    1471         maybeAccept        ( node->dtors      , *this );
    1472 
    1473         VISIT_END( node );
    1474 }
    1475 
    1476 template< typename pass_type >
    1477 Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
    1478         MUTATE_START( node );
    1479 
    1480         indexerScopedMutate( node->env        , *this );
    1481         indexerScopedMutate( node->result     , *this );
    1482         maybeMutateRef     ( node->callExpr   , *this );
    1483         maybeMutateRef     ( node->tempDecls  , *this );
    1484         maybeMutateRef     ( node->returnDecls, *this );
    1485         maybeMutateRef     ( node->dtors      , *this );
    1486 
    1487         MUTATE_END( Expression, node );
    1488 }
    1489 
    1490 //--------------------------------------------------------------------------
    1491 // ConstructorExpr
     747        VISIT_BODY( node );
     748}
     749
    1492750template< typename pass_type >
    1493751void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
    1494         VISIT_START( node );
    1495 
    1496         indexerScopedAccept( node->result  , *this );
    1497         maybeAccept        ( node->callExpr, *this );
    1498 
    1499         VISIT_END( node );
    1500 }
    1501 
    1502 template< typename pass_type >
    1503 Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
    1504         MUTATE_START( node );
    1505 
    1506         indexerScopedMutate( node->env     , *this );
    1507         indexerScopedMutate( node->result  , *this );
    1508         maybeMutateRef     ( node->callExpr, *this );
    1509 
    1510         MUTATE_END( Expression, node );
    1511 }
    1512 
    1513 //--------------------------------------------------------------------------
    1514 // CompoundLiteralExpr
     752        VISIT_BODY( node );
     753}
     754
    1515755template< typename pass_type >
    1516756void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
    1517         VISIT_START( node );
    1518 
    1519         indexerScopedAccept( node->result     , *this );
    1520         maybeAccept        ( node->initializer, *this );
    1521 
    1522         VISIT_END( node );
    1523 }
    1524 
    1525 template< typename pass_type >
    1526 Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
    1527         MUTATE_START( node );
    1528 
    1529         indexerScopedMutate( node->env        , *this );
    1530         indexerScopedMutate( node->result     , *this );
    1531         maybeMutateRef     ( node->initializer, *this );
    1532 
    1533         MUTATE_END( Expression, node );
    1534 }
    1535 
    1536 //--------------------------------------------------------------------------
    1537 // RangeExpr
     757        VISIT_BODY( node );
     758}
     759
    1538760template< typename pass_type >
    1539761void PassVisitor< pass_type >::visit( RangeExpr * node ) {
    1540         VISIT_START( node );
    1541 
    1542         indexerScopedAccept( node->result, *this );
    1543         maybeAccept        ( node->low   , *this );
    1544         maybeAccept        ( node->high  , *this );
    1545 
    1546         VISIT_END( node );
    1547 }
    1548 
    1549 template< typename pass_type >
    1550 Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
    1551         MUTATE_START( node );
    1552 
    1553         indexerScopedMutate( node->env   , *this );
    1554         indexerScopedMutate( node->result, *this );
    1555         maybeMutateRef     ( node->low   , *this );
    1556         maybeMutateRef     ( node->high  , *this );
    1557 
    1558         MUTATE_END( Expression, node );
    1559 }
    1560 
    1561 //--------------------------------------------------------------------------
    1562 // UntypedTupleExpr
     762        VISIT_BODY( node );
     763}
     764
    1563765template< typename pass_type >
    1564766void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
    1565         VISIT_START( node );
    1566 
    1567         indexerScopedAccept( node->result, *this );
    1568         maybeAccept        ( node->exprs , *this );
    1569 
    1570         VISIT_END( node );
    1571 }
    1572 
    1573 template< typename pass_type >
    1574 Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
    1575         MUTATE_START( node );
    1576 
    1577         indexerScopedMutate( node->env   , *this );
    1578         indexerScopedMutate( node->result, *this );
    1579         maybeMutateRef     ( node->exprs , *this );
    1580 
    1581         MUTATE_END( Expression, node );
    1582 }
    1583 
    1584 //--------------------------------------------------------------------------
    1585 // TupleExpr
     767        VISIT_BODY( node );
     768}
     769
    1586770template< typename pass_type >
    1587771void PassVisitor< pass_type >::visit( TupleExpr * node ) {
    1588         VISIT_START( node );
    1589 
    1590         indexerScopedAccept( node->result, *this );
    1591         maybeAccept          ( node->exprs , *this );
    1592 
    1593         VISIT_END( node );
    1594 }
    1595 
    1596 template< typename pass_type >
    1597 Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
    1598         MUTATE_START( node );
    1599 
    1600         indexerScopedMutate( node->env   , *this );
    1601         indexerScopedMutate( node->result, *this );
    1602         maybeMutateRef     ( node->exprs , *this );
    1603 
    1604         MUTATE_END( Expression, node );
    1605 }
    1606 
    1607 //--------------------------------------------------------------------------
    1608 // TupleIndexExpr
     772        VISIT_BODY( node );
     773}
     774
    1609775template< typename pass_type >
    1610776void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
    1611         VISIT_START( node );
    1612 
    1613         indexerScopedAccept( node->result, *this );
    1614         maybeAccept        ( node->tuple , *this );
    1615 
    1616         VISIT_END( node );
    1617 }
    1618 
    1619 template< typename pass_type >
    1620 Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
    1621         MUTATE_START( node );
    1622 
    1623         indexerScopedMutate( node->env   , *this );
    1624         indexerScopedMutate( node->result, *this );
    1625         maybeMutateRef     ( node->tuple , *this );
    1626 
    1627         MUTATE_END( Expression, node );
    1628 }
    1629 
    1630 //--------------------------------------------------------------------------
    1631 // TupleAssignExpr
     777        VISIT_BODY( node );
     778}
     779
    1632780template< typename pass_type >
    1633781void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
    1634         VISIT_START( node );
    1635 
    1636         indexerScopedAccept( node->result  , *this );
    1637         maybeAccept        ( node->stmtExpr, *this );
    1638 
    1639         VISIT_END( node );
    1640 }
    1641 
    1642 template< typename pass_type >
    1643 Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
    1644         MUTATE_START( node );
    1645 
    1646         indexerScopedMutate( node->env     , *this );
    1647         indexerScopedMutate( node->result  , *this );
    1648         maybeMutateRef     ( node->stmtExpr, *this );
    1649 
    1650         MUTATE_END( Expression, node );
    1651 }
    1652 
    1653 //--------------------------------------------------------------------------
    1654 // StmtExpr
     782        VISIT_BODY( node );
     783}
     784
     785//--------------------------------------------------------------------------
     786// UntypedExpr
    1655787template< typename pass_type >
    1656788void PassVisitor< pass_type >::visit( StmtExpr * node ) {
    … …  
    1662794        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    1663795
    1664         indexerScopedAccept( node->result     , *this );
    1665         maybeAccept        ( node->statements , *this );
    1666         maybeAccept        ( node->returnDecls, *this );
    1667         maybeAccept        ( node->dtors      , *this );
     796        Visitor::visit( node );
    1668797
    1669798        VISIT_END( node );
    … …  
    1679808        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    1680809
    1681         indexerScopedMutate( node->result     , *this );
    1682         maybeMutateRef     ( node->statements , *this );
    1683         maybeMutateRef     ( node->returnDecls, *this );
    1684         maybeMutateRef     ( node->dtors      , *this );
     810        Mutator::mutate( node );
    1685811
    1686812        MUTATE_END( Expression, node );
    1687813}
    1688814
    1689 //--------------------------------------------------------------------------
    1690 // UniqueExpr
    1691815template< typename pass_type >
    1692816void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
    1693         VISIT_START( node );
    1694 
    1695         indexerScopedAccept( node->result, *this );
    1696         maybeAccept        ( node->expr  , *this );
    1697 
    1698         VISIT_END( node );
    1699 }
    1700 
    1701 template< typename pass_type >
    1702 Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
    1703         MUTATE_START( node );
    1704 
    1705         indexerScopedMutate( node->env   , *this );
    1706         indexerScopedMutate( node->result, *this );
    1707         maybeMutateRef     ( node->expr  , *this );
    1708 
    1709         MUTATE_END( Expression, node );
     817        VISIT_BODY( node );
    1710818}
    1711819
    … …  
    1740848}
    1741849
    1742 //--------------------------------------------------------------------------
    1743 // StructInstType
    1744850template< typename pass_type >
    1745851void PassVisitor< pass_type >::visit( StructInstType * node ) {
    1746         VISIT_START( node );
    1747 
    1748         indexerAddStruct( node->name );
    1749 
    1750         {
    1751                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1752                 maybeAccept( node->forall    , *this );
    1753                 maybeAccept( node->parameters, *this );
    1754         }
    1755 
    1756         VISIT_END( node );
    1757 }
    1758 
    1759 template< typename pass_type >
    1760 Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
    1761         MUTATE_START( node );
    1762 
    1763         indexerAddStruct( node->name );
    1764 
    1765         {
    1766                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1767                 maybeMutateRef( node->forall    , *this );
    1768                 maybeMutateRef( node->parameters, *this );
    1769         }
    1770 
    1771         MUTATE_END( Type, node );
    1772 }
    1773 
    1774 //--------------------------------------------------------------------------
    1775 // UnionInstType
     852        VISIT_BODY( node );
     853}
     854
    1776855template< typename pass_type >
    1777856void PassVisitor< pass_type >::visit( UnionInstType * node ) {
    1778         VISIT_START( node );
    1779 
    1780         indexerAddStruct( node->name );
    1781 
    1782         {
    1783                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1784                 maybeAccept( node->forall    , *this );
    1785                 maybeAccept( node->parameters, *this );
    1786         }
    1787 
    1788         VISIT_END( node );
    1789 }
    1790 
    1791 template< typename pass_type >
    1792 Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
    1793         MUTATE_START( node );
    1794 
    1795         indexerAddStruct( node->name );
    1796 
    1797         {
    1798                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1799                 maybeMutateRef( node->forall    , *this );
    1800                 maybeMutateRef( node->parameters, *this );
    1801         }
    1802 
    1803         MUTATE_END( Type, node );
    1804 }
    1805 
    1806 //--------------------------------------------------------------------------
    1807 // EnumInstType
     857        VISIT_BODY( node );
     858}
     859
    1808860template< typename pass_type >
    1809861void PassVisitor< pass_type >::visit( EnumInstType * node ) {
    … …  
    1812864
    1813865template< typename pass_type >
    1814 Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
    1815         MUTATE_BODY( Type, node );
    1816 }
    1817 
    1818 //--------------------------------------------------------------------------
    1819 // TraitInstType
    1820 template< typename pass_type >
    1821866void PassVisitor< pass_type >::visit( TraitInstType * node ) {
    1822         VISIT_START( node );
    1823 
    1824         maybeAccept( node->forall    , *this );
    1825         maybeAccept( node->parameters, *this );
    1826 
    1827         VISIT_END( node );
    1828 }
    1829 
    1830 template< typename pass_type >
    1831 Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
    1832         MUTATE_START( node );
    1833 
    1834         maybeMutateRef( node->forall    , *this );
    1835         maybeMutateRef( node->parameters, *this );
    1836 
    1837         MUTATE_END( Type, node );
    1838 }
    1839 
    1840 //--------------------------------------------------------------------------
    1841 // TypeInstType
     867        VISIT_BODY( node );
     868}
     869
    1842870template< typename pass_type >
    1843871void PassVisitor< pass_type >::visit( TypeInstType * node ) {
    … …  
    1876904
    1877905//--------------------------------------------------------------------------
    1878 // SingleInit
     906// UntypedExpr
    1879907template< typename pass_type >
    1880908void PassVisitor< pass_type >::visit( SingleInit * node ) {
    … …  
    1916944
    1917945//---------------------------------------------------------------------------------------------------------------
     946
     947template< typename pass_type >
     948DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
     949        MUTATE_BODY( DeclarationWithType, node );
     950}
     951
     952template< typename pass_type >
     953DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
     954        MUTATE_BODY( DeclarationWithType, node );
     955}
     956
     957template< typename pass_type >
     958Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
     959        MUTATE_BODY( Declaration, node );
     960}
     961
     962template< typename pass_type >
     963Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
     964        MUTATE_BODY( Declaration, node );
     965}
     966
     967template< typename pass_type >
     968Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
     969        MUTATE_BODY( Declaration, node );
     970}
     971
     972template< typename pass_type >
     973Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
     974        MUTATE_BODY( Declaration, node );
     975}
     976
     977template< typename pass_type >
     978TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
     979        MUTATE_BODY( TypeDecl, node );
     980}
     981
     982template< typename pass_type >
     983Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
     984        MUTATE_BODY( Declaration, node );
     985}
     986
     987template< typename pass_type >
     988AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
     989        MUTATE_BODY( AsmDecl, node );
     990}
     991
     992template< typename pass_type >
     993Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
     994        MUTATE_BODY( Expression, node );
     995}
     996
     997template< typename pass_type >
     998Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
     999        MUTATE_BODY( Expression, node );
     1000}
     1001
     1002template< typename pass_type >
     1003Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
     1004        MUTATE_BODY( Expression, node );
     1005}
     1006
     1007template< typename pass_type >
     1008Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
     1009        MUTATE_BODY( Expression, node );
     1010}
     1011
     1012template< typename pass_type >
     1013Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
     1014        MUTATE_BODY( Expression, node );
     1015}
     1016
     1017template< typename pass_type >
     1018Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
     1019        MUTATE_BODY( Expression, node );
     1020}
     1021
     1022template< typename pass_type >
     1023Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
     1024        MUTATE_BODY( Expression, node );
     1025}
     1026
     1027template< typename pass_type >
     1028Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
     1029        MUTATE_BODY( Expression, node );
     1030}
     1031
     1032template< typename pass_type >
     1033Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
     1034        MUTATE_BODY( Expression, node );
     1035}
     1036
     1037template< typename pass_type >
     1038Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
     1039        MUTATE_BODY( Expression, node );
     1040}
     1041
     1042template< typename pass_type >
     1043Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
     1044        MUTATE_BODY( Expression, node );
     1045}
     1046
     1047template< typename pass_type >
     1048Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
     1049        MUTATE_BODY( Expression, node );
     1050}
     1051
     1052template< typename pass_type >
     1053Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
     1054        MUTATE_BODY( Expression, node );
     1055}
     1056
     1057template< typename pass_type >
     1058Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
     1059        MUTATE_BODY( Expression, node );
     1060}
     1061
     1062template< typename pass_type >
     1063Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
     1064        MUTATE_BODY( Expression, node );
     1065}
     1066
     1067template< typename pass_type >
     1068Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
     1069        MUTATE_BODY( Expression, node );
     1070}
     1071
     1072template< typename pass_type >
     1073Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
     1074        MUTATE_BODY( Expression, node );
     1075}
     1076
     1077template< typename pass_type >
     1078Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
     1079        MUTATE_BODY( Expression, node );
     1080}
     1081
     1082template< typename pass_type >
     1083Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
     1084        MUTATE_BODY( Expression, node );
     1085}
     1086
     1087template< typename pass_type >
     1088Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
     1089        MUTATE_BODY( Expression, node );
     1090}
     1091
     1092template< typename pass_type >
     1093Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
     1094        MUTATE_BODY( Expression, node );
     1095}
     1096
     1097template< typename pass_type >
     1098Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
     1099        MUTATE_BODY( Expression, node );
     1100}
     1101
     1102template< typename pass_type >
     1103Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
     1104        MUTATE_BODY( Expression, node );
     1105}
     1106
     1107template< typename pass_type >
     1108Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
     1109        MUTATE_BODY( Expression, node );
     1110}
     1111
     1112template< typename pass_type >
     1113Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
     1114        MUTATE_BODY( Expression, node );
     1115}
     1116
     1117template< typename pass_type >
     1118Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
     1119        MUTATE_BODY( Expression, node );
     1120}
     1121
     1122template< typename pass_type >
     1123Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
     1124        MUTATE_BODY( Expression, node );
     1125}
     1126
     1127template< typename pass_type >
     1128Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
     1129        MUTATE_BODY( Expression, node );
     1130}
     1131
     1132template< typename pass_type >
     1133Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
     1134        MUTATE_BODY( Expression, node );
     1135}
     1136
    19181137template< typename pass_type >
    19191138Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
    … …  
    19431162template< typename pass_type >
    19441163Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
     1164        MUTATE_BODY( Type, node );
     1165}
     1166
     1167template< typename pass_type >
     1168Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
     1169        MUTATE_BODY( Type, node );
     1170}
     1171
     1172template< typename pass_type >
     1173Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
     1174        MUTATE_BODY( Type, node );
     1175}
     1176
     1177template< typename pass_type >
     1178Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
     1179        MUTATE_BODY( Type, node );
     1180}
     1181
     1182template< typename pass_type >
     1183Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
    19451184        MUTATE_BODY( Type, node );
    19461185}
Note: See TracChangeset for help on using the changeset viewer.