Ignore:
Timestamp:
Jun 23, 2017, 4:20:33 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
74e58ea3, 7bbba76
Parents:
e1c1829 (diff), 88177cf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Common/PassVisitor.impl.h

    re1c1829 r4c03e63  
    44        __attribute__((unused))                   \
    55        const auto & guard = init_guard();        \
     6        bool visit_children = true;               \
     7        set_visit_children( visit_children );   \
    68        call_previsit( node );                    \
    7         if( visit_children() ) {                  \
    8                 reset_visit();                      \
     9        if( visit_children ) {                    \
    910
    1011#define VISIT_END( node )                       \
     
    1516        __attribute__((unused))                   \
    1617        const auto & guard = init_guard();        \
     18        bool visit_children = true;               \
     19        set_visit_children( visit_children );   \
    1720        call_premutate( node );                   \
    18         if( visit_children() ) {                  \
    19                 reset_visit();                      \
     21        if( visit_children ) {                    \
    2022
    2123#define MUTATE_END( type, node )                \
     
    4244}
    4345
    44 typedef std::list< Statement * > StmtList_t;
    45 
    46 template< typename pass_type >
    47 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
     46typedef std::list< Statement   * > StmtList_t;
     47typedef std::list< Declaration * > DeclList_t;
     48
     49template<typename iterator_t>
     50static inline void splice( iterator_t it, DeclList_t * decls ) {
     51        std::transform(
     52                decls->begin(),
     53                decls->end(),
     54                it,
     55                [](Declaration * decl) -> auto {
     56                        return new DeclStmt( noLabels, decl );
     57                }
     58        );
     59        decls->clear();
     60}
     61
     62template< typename pass_type >
     63static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
     64
     65        DeclList_t* beforeDecls = visitor.get_beforeDecls();
     66        DeclList_t* afterDecls  = visitor.get_afterDecls();
     67
     68        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     69                // splice in new declarations after previous decl
     70                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
     71
     72                if ( i == decls.end() ) break;
     73
     74                // run mutator on declaration
     75                maybeAccept( *i, visitor );
     76
     77                // splice in new declarations before current decl
     78                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
     79        }
     80}
     81
     82template< typename pass_type >
     83static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
     84
     85        DeclList_t* beforeDecls = mutator.get_beforeDecls();
     86        DeclList_t* afterDecls  = mutator.get_afterDecls();
     87
     88        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     89                // splice in new declarations after previous decl
     90                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
     91
     92                if ( i == decls.end() ) break;
     93
     94                // run mutator on declaration
     95                *i = maybeMutate( *i, mutator );
     96
     97                // splice in new declarations before current decl
     98                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
     99        }
     100}
     101
     102template< typename pass_type >
     103template< typename func_t >
     104void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
    48105        SemanticError errors;
    49106
    50107        StmtList_t* beforeStmts = get_beforeStmts();
    51108        StmtList_t* afterStmts  = get_afterStmts();
     109        DeclList_t* beforeDecls = get_beforeDecls();
     110        DeclList_t* afterDecls  = get_afterDecls();
    52111
    53112        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
     113
     114                if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
    54115                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
     116
    55117                try {
    56                         (*i)->accept( *this );
     118                        func( *i );
     119                        assert(( empty( beforeStmts ) && empty( afterStmts ))
     120                            || ( empty( beforeDecls ) && empty( afterDecls )) );
     121
    57122                } catch ( SemanticError &e ) {
    58123                        errors.append( e );
    59124                }
     125
     126                if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
    60127                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
    61128        }
    62129
     130        if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
    63131        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
    64132        if ( !errors.isEmpty() ) { throw errors; }
     
    66134
    67135template< typename pass_type >
     136void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
     137        handleStatementList( statements, [this]( Statement * stmt) {
     138                stmt->accept( *this );
     139        });
     140}
     141
     142template< typename pass_type >
    68143void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
    69         SemanticError errors;
     144        handleStatementList( statements, [this]( Statement *& stmt) {
     145                stmt = stmt->acceptMutator( *this );
     146        });
     147}
     148
     149
     150template< typename pass_type >
     151template< typename func_t >
     152Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
     153        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
     154        ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
     155        ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
     156        ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
     157        ValueGuardPtr< StmtList_t >          oldBeforeStmts( get_beforeStmts() );
     158        ValueGuardPtr< StmtList_t >          oldAfterStmts ( get_afterStmts () );
     159
     160        Statement *newStmt = func( stmt );
    70161
    71162        StmtList_t* beforeStmts = get_beforeStmts();
    72163        StmtList_t* afterStmts  = get_afterStmts();
    73 
    74         for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
    75                 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
    76                 try {
    77                         *i = (*i)->acceptMutator( *this );
    78                 } catch ( SemanticError &e ) {
    79                         errors.append( e );
    80                 }
    81                 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
    82         }
    83 
    84         if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
    85         if ( !errors.isEmpty() ) { throw errors; }
    86 }
    87 
    88 template< typename pass_type >
    89 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
    90         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
    91         ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
    92         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
    93         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    94 
    95         maybeAccept( stmt, *this );
    96 
    97         StmtList_t* beforeStmts = get_beforeStmts();
    98         StmtList_t* afterStmts  = get_afterStmts();
    99 
    100         if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; }
     164        DeclList_t* beforeDecls = get_beforeDecls();
     165        DeclList_t* afterDecls  = get_afterDecls();
     166
     167        if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
     168        assert(( empty( beforeStmts ) && empty( afterStmts ))
     169            || ( empty( beforeDecls ) && empty( afterDecls )) );
    101170
    102171        CompoundStmt *compound = new CompoundStmt( noLabels );
     172        if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
    103173        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    104         compound->get_kids().push_back( stmt );
     174        compound->get_kids().push_back( newStmt );
     175        if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
    105176        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    106177        return compound;
     
    108179
    109180template< typename pass_type >
     181Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
     182        return handleStatement( stmt, [this]( Statement * stmt ) {
     183                maybeAccept( stmt, *this );
     184                return stmt;
     185        });
     186}
     187
     188template< typename pass_type >
    110189Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
    111         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
    112         ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
    113         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
    114         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    115 
    116         Statement *newStmt = maybeMutate( stmt, *this );
    117 
    118         StmtList_t* beforeStmts = get_beforeStmts();
    119         StmtList_t* afterStmts  = get_afterStmts();
    120 
    121         if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
    122 
    123         CompoundStmt *compound = new CompoundStmt( noLabels );
    124         if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    125         compound->get_kids().push_back( newStmt );
    126         if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    127         return compound;
    128 }
    129 
    130 
    131 
    132 template< typename pass_type >
    133 void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
    134         if( !expr ) return;
     190        return handleStatement( stmt, [this]( Statement * stmt ) {
     191                return maybeMutate( stmt, *this );
     192        });
     193}
     194
     195template< typename pass_type >
     196template< typename func_t >
     197Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
     198        if( !expr ) return nullptr;
    135199
    136200        auto env_ptr = get_env_ptr();
     
    138202                *env_ptr = expr->get_env();
    139203        }
    140         // xxx - should env be cloned (or moved) onto the result of the mutate?
    141         expr->accept( *this );
     204
     205        // should env be cloned (or moved) onto the result of the mutate?
     206        return func( expr );
     207}
     208
     209template< typename pass_type >
     210Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
     211        return handleExpression(expr, [this]( Expression * expr ) {
     212                expr->accept( *this );
     213                return expr;
     214        });             
    142215}
    143216
    144217template< typename pass_type >
    145218Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
    146         if( !expr ) return nullptr;
    147 
    148         auto env_ptr = get_env_ptr();
    149         if ( env_ptr && expr->get_env() ) {
    150                 *env_ptr = expr->get_env();
    151         }
    152         // xxx - should env be cloned (or moved) onto the result of the mutate?
    153         return expr->acceptMutator( *this );
    154 }
    155 
     219        return handleExpression(expr, [this]( Expression * expr ) {
     220                return expr->acceptMutator( *this );
     221        });
     222}
    156223
    157224//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     
    159226template< typename pass_type >
    160227void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
    161         VISIT_BODY( node ); 
     228        VISIT_BODY( node );
    162229}
    163230
    164231template< typename pass_type >
    165232void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
    166         VISIT_BODY( node ); 
     233        VISIT_BODY( node );
    167234}
    168235
    169236template< typename pass_type >
    170237void PassVisitor< pass_type >::visit( StructDecl * node ) {
    171         VISIT_BODY( node ); 
     238        VISIT_BODY( node );
    172239}
    173240
    174241template< typename pass_type >
    175242void PassVisitor< pass_type >::visit( UnionDecl * node ) {
    176         VISIT_BODY( node ); 
     243        VISIT_BODY( node );
    177244}
    178245
    179246template< typename pass_type >
    180247void PassVisitor< pass_type >::visit( EnumDecl * node ) {
    181         VISIT_BODY( node ); 
     248        VISIT_BODY( node );
    182249}
    183250
    184251template< typename pass_type >
    185252void PassVisitor< pass_type >::visit( TraitDecl * node ) {
    186         VISIT_BODY( node ); 
     253        VISIT_BODY( node );
    187254}
    188255
    189256template< typename pass_type >
    190257void PassVisitor< pass_type >::visit( TypeDecl * node ) {
    191         VISIT_BODY( node ); 
     258        VISIT_BODY( node );
    192259}
    193260
    194261template< typename pass_type >
    195262void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
    196         VISIT_BODY( node ); 
     263        VISIT_BODY( node );
    197264}
    198265
    199266template< typename pass_type >
    200267void PassVisitor< pass_type >::visit( AsmDecl * node ) {
    201         VISIT_BODY( node ); 
     268        VISIT_BODY( node );
    202269}
    203270
     
    231298void PassVisitor< pass_type >::visit( ExprStmt * node ) {
    232299        VISIT_START( node );
    233         call_beginScope();
    234300
    235301        visitExpression( node->get_expr() );
    236302
    237         call_endScope();
    238303        VISIT_END( node );
    239304}
     
    248313}
    249314
     315//--------------------------------------------------------------------------
     316// AsmStmt
    250317template< typename pass_type >
    251318void PassVisitor< pass_type >::visit( AsmStmt * node ) {
    252         VISIT_BODY( node );
     319        VISIT_BODY( node );
     320}
     321
     322template< typename pass_type >
     323Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
     324        MUTATE_BODY( Statement, node );
    253325}
    254326
     
    257329template< typename pass_type >
    258330void PassVisitor< pass_type >::visit( IfStmt * node ) {
    259         VISIT_START( node ); 
     331        VISIT_START( node );
    260332
    261333        visitExpression( node->get_condition() );
     
    268340template< typename pass_type >
    269341Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
    270         MUTATE_START( node ); 
     342        MUTATE_START( node );
    271343
    272344        node->set_condition( mutateExpression( node->get_condition() ) );
     
    281353template< typename pass_type >
    282354void PassVisitor< pass_type >::visit( WhileStmt * node ) {
    283         VISIT_START( node ); 
     355        VISIT_START( node );
    284356
    285357        visitExpression( node->get_condition() );
     
    291363template< typename pass_type >
    292364Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
    293         MUTATE_START( node ); 
     365        MUTATE_START( node );
    294366
    295367        node->set_condition( mutateExpression( node->get_condition() ) );
     
    300372
    301373//--------------------------------------------------------------------------
    302 // WhileStmt
     374// ForStmt
    303375template< typename pass_type >
    304376void PassVisitor< pass_type >::visit( ForStmt * node ) {
    305         VISIT_START( node ); 
     377        VISIT_START( node );
    306378
    307379        acceptAll( node->get_initialization(), *this );
     
    315387template< typename pass_type >
    316388Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
    317         MUTATE_START( node ); 
     389        MUTATE_START( node );
    318390
    319391        mutateAll( node->get_initialization(), *this );
     
    329401template< typename pass_type >
    330402void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
    331         VISIT_START( node ); 
     403        VISIT_START( node );
    332404
    333405        visitExpression( node->get_condition() );
     
    339411template< typename pass_type >
    340412Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
    341         MUTATE_START( node ); 
    342        
     413        MUTATE_START( node );
     414
    343415        node->set_condition( mutateExpression( node->get_condition() ) );
    344416        mutateStatementList( node->get_statements() );
    345        
     417
    346418        MUTATE_END( Statement, node );
    347419}
    348420
    349421//--------------------------------------------------------------------------
    350 // SwitchStmt
     422// CaseStmt
    351423template< typename pass_type >
    352424void PassVisitor< pass_type >::visit( CaseStmt * node ) {
    353         VISIT_START( node ); 
    354        
     425        VISIT_START( node );
     426
    355427        visitExpression( node->get_condition() );
    356428        visitStatementList( node->get_statements() );
    357        
     429
    358430        VISIT_END( node );
    359431}
     
    361433template< typename pass_type >
    362434Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
    363         MUTATE_START( node ); 
    364        
     435        MUTATE_START( node );
     436
    365437        node->set_condition(  mutateExpression( node->get_condition() ) );
    366438        mutateStatementList( node->get_statements() );
    367        
     439
    368440        MUTATE_END( Statement, node );
    369441}
    370442
     443//--------------------------------------------------------------------------
     444// BranchStmt
    371445template< typename pass_type >
    372446void PassVisitor< pass_type >::visit( BranchStmt * node ) {
    373         VISIT_BODY( node );
     447        VISIT_BODY( node );
     448}
     449
     450template< typename pass_type >
     451Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
     452        MUTATE_BODY( Statement, node );
    374453}
    375454
     
    415494        maybeAccept( node->get_block(), *this );
    416495        acceptAll( node->get_catchers(), *this );
     496        maybeAccept( node->get_finally(), *this );
    417497
    418498        VISIT_END( node );
     
    425505        node->set_block(  maybeMutate( node->get_block(), *this ) );
    426506        mutateAll( node->get_catchers(), *this );
    427        
     507        node->set_finally( maybeMutate( node->get_finally(), *this ) );
     508
    428509        MUTATE_END( Statement, node );
    429510}
     
    435516        VISIT_START( node );
    436517
     518        maybeAccept( node->get_decl(), *this );
     519        node->set_cond( visitExpression( node->get_cond() ) );
    437520        node->set_body( visitStatement( node->get_body() ) );
    438         maybeAccept( node->get_decl(), *this );
    439521
    440522        VISIT_END( node );
     
    444526Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
    445527        MUTATE_START( node );
    446        
    447         node->set_body(  mutateStatement( node->get_body() ) );
    448         node->set_decl(  maybeMutate( node->get_decl(), *this ) );
    449        
     528
     529        node->set_decl( maybeMutate( node->get_decl(), *this ) );
     530        node->set_cond( mutateExpression( node->get_cond() ) );
     531        node->set_body( mutateStatement( node->get_body() ) );
     532
    450533        MUTATE_END( Statement, node );
    451534}
     
    453536template< typename pass_type >
    454537void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
    455         VISIT_BODY( node ); 
     538        VISIT_BODY( node );
    456539}
    457540
    458541template< typename pass_type >
    459542void PassVisitor< pass_type >::visit( NullStmt * node ) {
    460         VISIT_BODY( node ); 
     543        VISIT_BODY( node );
    461544}
    462545
    463546template< typename pass_type >
    464547void PassVisitor< pass_type >::visit( DeclStmt * node ) {
    465         VISIT_BODY( node ); 
     548        VISIT_BODY( node );
    466549}
    467550
    468551template< typename pass_type >
    469552void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
    470         VISIT_BODY( node ); 
     553        VISIT_BODY( node );
    471554}
    472555
    473556template< typename pass_type >
    474557void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
    475         VISIT_BODY( node ); 
     558        VISIT_BODY( node );
    476559}
    477560
     
    502585template< typename pass_type >
    503586void PassVisitor< pass_type >::visit( NameExpr * node ) {
    504         VISIT_BODY( node ); 
     587        VISIT_BODY( node );
    505588}
    506589
    507590template< typename pass_type >
    508591void PassVisitor< pass_type >::visit( CastExpr * node ) {
    509         VISIT_BODY( node ); 
     592        VISIT_BODY( node );
    510593}
    511594
    512595template< typename pass_type >
    513596void PassVisitor< pass_type >::visit( AddressExpr * node ) {
    514         VISIT_BODY( node ); 
     597        VISIT_BODY( node );
    515598}
    516599
    517600template< typename pass_type >
    518601void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
    519         VISIT_BODY( node ); 
     602        VISIT_BODY( node );
    520603}
    521604
    522605template< typename pass_type >
    523606void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
    524         VISIT_BODY( node ); 
     607        VISIT_BODY( node );
    525608}
    526609
    527610template< typename pass_type >
    528611void PassVisitor< pass_type >::visit( MemberExpr * node ) {
    529         VISIT_BODY( node ); 
     612        VISIT_BODY( node );
    530613}
    531614
    532615template< typename pass_type >
    533616void PassVisitor< pass_type >::visit( VariableExpr * node ) {
    534         VISIT_BODY( node ); 
     617        VISIT_BODY( node );
    535618}
    536619
    537620template< typename pass_type >
    538621void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
    539         VISIT_BODY( node ); 
     622        VISIT_BODY( node );
    540623}
    541624
    542625template< typename pass_type >
    543626void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
    544         VISIT_BODY( node ); 
     627        VISIT_BODY( node );
    545628}
    546629
    547630template< typename pass_type >
    548631void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
    549         VISIT_BODY( node ); 
     632        VISIT_BODY( node );
    550633}
    551634
    552635template< typename pass_type >
    553636void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
    554         VISIT_BODY( node ); 
     637        VISIT_BODY( node );
    555638}
    556639
    557640template< typename pass_type >
    558641void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
    559         VISIT_BODY( node ); 
     642        VISIT_BODY( node );
    560643}
    561644
    562645template< typename pass_type >
    563646void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
    564         VISIT_BODY( node ); 
     647        VISIT_BODY( node );
    565648}
    566649
    567650template< typename pass_type >
    568651void PassVisitor< pass_type >::visit( AttrExpr * node ) {
    569         VISIT_BODY( node ); 
     652        VISIT_BODY( node );
    570653}
    571654
    572655template< typename pass_type >
    573656void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
    574         VISIT_BODY( node ); 
     657        VISIT_BODY( node );
    575658}
    576659
    577660template< typename pass_type >
    578661void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
    579         VISIT_BODY( node ); 
     662        VISIT_BODY( node );
    580663}
    581664
    582665template< typename pass_type >
    583666void PassVisitor< pass_type >::visit( CommaExpr * node ) {
    584         VISIT_BODY( node ); 
     667        VISIT_BODY( node );
    585668}
    586669
    587670template< typename pass_type >
    588671void PassVisitor< pass_type >::visit( TypeExpr * node ) {
    589         VISIT_BODY( node ); 
     672        VISIT_BODY( node );
    590673}
    591674
    592675template< typename pass_type >
    593676void PassVisitor< pass_type >::visit( AsmExpr * node ) {
    594         VISIT_BODY( node ); 
     677        VISIT_BODY( node );
    595678}
    596679
    597680template< typename pass_type >
    598681void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
    599         VISIT_BODY( node ); 
     682        VISIT_BODY( node );
    600683}
    601684
    602685template< typename pass_type >
    603686void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
    604         VISIT_BODY( node ); 
     687        VISIT_BODY( node );
    605688}
    606689
    607690template< typename pass_type >
    608691void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
    609         VISIT_BODY( node );
    610 }
    611 
    612 template< typename pass_type >
    613 void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
    614         VISIT_BODY( node );
     692        VISIT_BODY( node );
    615693}
    616694
    617695template< typename pass_type >
    618696void PassVisitor< pass_type >::visit( RangeExpr * node ) {
    619         VISIT_BODY( node ); 
     697        VISIT_BODY( node );
    620698}
    621699
    622700template< typename pass_type >
    623701void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
    624         VISIT_BODY( node ); 
     702        VISIT_BODY( node );
    625703}
    626704
    627705template< typename pass_type >
    628706void PassVisitor< pass_type >::visit( TupleExpr * node ) {
    629         VISIT_BODY( node ); 
     707        VISIT_BODY( node );
    630708}
    631709
    632710template< typename pass_type >
    633711void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
    634         VISIT_BODY( node ); 
     712        VISIT_BODY( node );
    635713}
    636714
    637715template< typename pass_type >
    638716void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
    639         VISIT_BODY( node ); 
     717        VISIT_BODY( node );
    640718}
    641719
     
    659737Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
    660738        MUTATE_START( node );
    661        
     739
    662740        // don't want statements from outer CompoundStmts to be added to this StmtExpr
    663741        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
     
    672750template< typename pass_type >
    673751void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
    674         VISIT_BODY( node ); 
     752        VISIT_BODY( node );
    675753}
    676754
    677755template< typename pass_type >
    678756void PassVisitor< pass_type >::visit( VoidType * node ) {
    679         VISIT_BODY( node ); 
     757        VISIT_BODY( node );
    680758}
    681759
    682760template< typename pass_type >
    683761void PassVisitor< pass_type >::visit( BasicType * node ) {
    684         VISIT_BODY( node ); 
     762        VISIT_BODY( node );
    685763}
    686764
    687765template< typename pass_type >
    688766void PassVisitor< pass_type >::visit( PointerType * node ) {
    689         VISIT_BODY( node ); 
     767        VISIT_BODY( node );
    690768}
    691769
    692770template< typename pass_type >
    693771void PassVisitor< pass_type >::visit( ArrayType * node ) {
    694         VISIT_BODY( node ); 
     772        VISIT_BODY( node );
    695773}
    696774
    697775template< typename pass_type >
    698776void PassVisitor< pass_type >::visit( FunctionType * node ) {
    699         VISIT_BODY( node ); 
     777        VISIT_BODY( node );
    700778}
    701779
    702780template< typename pass_type >
    703781void PassVisitor< pass_type >::visit( StructInstType * node ) {
    704         VISIT_BODY( node ); 
     782        VISIT_BODY( node );
    705783}
    706784
    707785template< typename pass_type >
    708786void PassVisitor< pass_type >::visit( UnionInstType * node ) {
    709         VISIT_BODY( node ); 
     787        VISIT_BODY( node );
    710788}
    711789
    712790template< typename pass_type >
    713791void PassVisitor< pass_type >::visit( EnumInstType * node ) {
    714         VISIT_BODY( node ); 
     792        VISIT_BODY( node );
    715793}
    716794
    717795template< typename pass_type >
    718796void PassVisitor< pass_type >::visit( TraitInstType * node ) {
    719         VISIT_BODY( node ); 
     797        VISIT_BODY( node );
    720798}
    721799
    722800template< typename pass_type >
    723801void PassVisitor< pass_type >::visit( TypeInstType * node ) {
    724         VISIT_BODY( node ); 
     802        VISIT_BODY( node );
    725803}
    726804
    727805template< typename pass_type >
    728806void PassVisitor< pass_type >::visit( TupleType * node ) {
    729         VISIT_BODY( node ); 
     807        VISIT_BODY( node );
    730808}
    731809
    732810template< typename pass_type >
    733811void PassVisitor< pass_type >::visit( TypeofType * node ) {
    734         VISIT_BODY( node ); 
     812        VISIT_BODY( node );
    735813}
    736814
    737815template< typename pass_type >
    738816void PassVisitor< pass_type >::visit( AttrType * node ) {
    739         VISIT_BODY( node ); 
     817        VISIT_BODY( node );
    740818}
    741819
    742820template< typename pass_type >
    743821void PassVisitor< pass_type >::visit( VarArgsType * node ) {
    744         VISIT_BODY( node ); 
     822        VISIT_BODY( node );
    745823}
    746824
    747825template< typename pass_type >
    748826void PassVisitor< pass_type >::visit( ZeroType * node ) {
    749         VISIT_BODY( node ); 
     827        VISIT_BODY( node );
    750828}
    751829
    752830template< typename pass_type >
    753831void PassVisitor< pass_type >::visit( OneType * node ) {
    754         VISIT_BODY( node ); 
     832        VISIT_BODY( node );
    755833}
    756834
     
    777855template< typename pass_type >
    778856void PassVisitor< pass_type >::visit( ListInit * node ) {
    779         VISIT_BODY( node ); 
     857        VISIT_BODY( node );
    780858}
    781859
    782860template< typename pass_type >
    783861void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
    784         VISIT_BODY( node ); 
     862        VISIT_BODY( node );
    785863}
    786864
    787865template< typename pass_type >
    788866void PassVisitor< pass_type >::visit( Subrange * node ) {
    789         VISIT_BODY( node ); 
     867        VISIT_BODY( node );
    790868}
    791869
    792870template< typename pass_type >
    793871void PassVisitor< pass_type >::visit( Constant * node ) {
    794         VISIT_BODY( node ); 
     872        VISIT_BODY( node );
    795873}
    796874
     
    843921
    844922template< typename pass_type >
    845 Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
    846         MUTATE_BODY( Statement, node );
    847 }
    848 
    849 template< typename pass_type >
    850 Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
    851         MUTATE_BODY( Statement, node );
    852 }
    853 
    854 template< typename pass_type >
    855923Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
    856924        MUTATE_BODY( Statement, node );
     
    9881056
    9891057template< typename pass_type >
    990 Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
    991         MUTATE_BODY( Expression, node );
    992 }
    993 
    994 template< typename pass_type >
    9951058Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
    9961059        MUTATE_BODY( Expression, node );
Note: See TracChangeset for help on using the changeset viewer.