Changeset e3d7f9f


Ignore:
Timestamp:
Jul 12, 2019, 5:42:33 PM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
ce12e2b
Parents:
6f096d2
Message:

Const PassVisitor? now supports the indexer

Location:
src/Common
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • src/Common/PassVisitor.h

    r6f096d2 re3d7f9f  
    410410        void indexerScopeEnter  ()                                    { indexer_impl_enterScope  ( pass, 0       ); }
    411411        void indexerScopeLeave  ()                                    { indexer_impl_leaveScope  ( pass, 0       ); }
    412         void indexerAddId       ( DeclarationWithType      * node  ) { indexer_impl_addId       ( pass, 0, node ); }
    413         void indexerAddType     ( NamedTypeDecl             * node  ) { indexer_impl_addType     ( pass, 0, node ); }
     412        void indexerAddId       ( const DeclarationWithType * node  ) { indexer_impl_addId       ( pass, 0, node ); }
     413        void indexerAddType     ( const NamedTypeDecl       * node  ) { indexer_impl_addType     ( pass, 0, node ); }
    414414        void indexerAddStruct   ( const std::string         & id    ) { indexer_impl_addStruct   ( pass, 0, id   ); }
    415         void indexerAddStruct   ( StructDecl                * node  ) { indexer_impl_addStruct   ( pass, 0, node ); }
    416         void indexerAddStructFwd( StructDecl                * node  ) { indexer_impl_addStructFwd( pass, 0, node ); }
    417         void indexerAddEnum     ( EnumDecl                  * node  ) { indexer_impl_addEnum     ( pass, 0, node ); }
     415        void indexerAddStruct   ( const StructDecl          * node  ) { indexer_impl_addStruct   ( pass, 0, node ); }
     416        void indexerAddStructFwd( const StructDecl          * node  ) { indexer_impl_addStructFwd( pass, 0, node ); }
     417        void indexerAddEnum     ( const EnumDecl            * node  ) { indexer_impl_addEnum     ( pass, 0, node ); }
    418418        void indexerAddUnion    ( const std::string         & id    ) { indexer_impl_addUnion    ( pass, 0, id   ); }
    419         void indexerAddUnion    ( UnionDecl                 * node  ) { indexer_impl_addUnion    ( pass, 0, node ); }
    420         void indexerAddUnionFwd ( UnionDecl                 * node  ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
    421         void indexerAddTrait    ( TraitDecl                 * node  ) { indexer_impl_addTrait    ( pass, 0, node ); }
    422         void indexerAddWith     ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith( pass, 0, exprs, withStmt ); }
     419        void indexerAddUnion    ( const UnionDecl           * node  ) { indexer_impl_addUnion    ( pass, 0, node ); }
     420        void indexerAddUnionFwd ( const UnionDecl           * node  ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
     421        void indexerAddTrait    ( const TraitDecl           * node  ) { indexer_impl_addTrait    ( pass, 0, node ); }
     422        void indexerAddWith     ( const std::list< Expression * > & exprs, const BaseSyntaxNode * withStmt ) { indexer_impl_addWith( pass, 0, exprs, withStmt ); }
    423423
    424424
    425425        template< typename TreeType, typename VisitorType >
    426         friend inline void indexerScopedAccept( TreeType * tree, VisitorType &visitor );
     426        friend inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor );
    427427
    428428        template< typename TreeType, typename VisitorType >
    429         friend inline void indexerScopedMutate( TreeType *& tree, VisitorType &visitor );
     429        friend inline void indexerScopedAccept( const TreeType * tree, VisitorType & visitor );
     430
     431        template< typename TreeType, typename VisitorType >
     432        friend inline void indexerScopedMutate( TreeType *& tree, VisitorType & visitor );
    430433};
    431434
  • src/Common/PassVisitor.impl.h

    r6f096d2 re3d7f9f  
    548548        VISIT_START( node );
    549549
     550        indexerAddId( node );
     551
    550552        maybeAccept_impl( node->withExprs, *this );
    551553        {
    552                 // implicit add __func__ identifier as specified in the C manual 6.4.2.2
    553                 static ObjectDecl func(
    554                         "__func__", noStorageClasses, LinkageSpec::C, nullptr,
    555                         new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
    556                         nullptr
    557                 );
    558                 maybeAccept_impl( node->type, *this );
    559                 // function body needs to have the same scope as parameters - CompoundStmt will not enter
    560                 // a new scope if inFunction is true
    561                 ValueGuard< bool > oldInFunction( inFunction );
    562                 inFunction = true;
    563                 maybeAccept_impl( node->statements, *this );
    564                 maybeAccept_impl( node->attributes, *this );
     554                // with clause introduces a level of scope (for the with expression members).
     555                // with clause exprs are added to the indexer before parameters so that parameters
     556                // shadow with exprs and not the other way around.
     557                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     558                indexerAddWith( node->withExprs, node );
     559                {
     560                        auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     561                        // implicit add __func__ identifier as specified in the C manual 6.4.2.2
     562                        static ObjectDecl func(
     563                                "__func__", noStorageClasses, LinkageSpec::C, nullptr,
     564                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
     565                                nullptr
     566                        );
     567                        indexerAddId( &func );
     568                        maybeAccept_impl( node->type, *this );
     569                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
     570                        // a new scope if inFunction is true
     571                        ValueGuard< bool > oldInFunction( inFunction );
     572                        inFunction = true;
     573                        maybeAccept_impl( node->statements, *this );
     574                        maybeAccept_impl( node->attributes, *this );
     575                }
    565576        }
    566577
     
    628639        VISIT_START( node );
    629640
    630         maybeAccept_impl( node->parameters, *this );
    631         maybeAccept_impl( node->members   , *this );
    632 
    633         VISIT_END( node );
    634 }
    635 
    636 template< typename pass_type >
    637 Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
    638         MUTATE_START( node );
    639 
    640641        // make up a forward declaration and add it before processing the members
    641642        // needs to be on the heap because addStruct saves the pointer
     
    644645        {
    645646                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     647                maybeAccept_impl( node->parameters, *this );
     648                maybeAccept_impl( node->members   , *this );
     649        }
     650
     651        // this addition replaces the forward declaration
     652        indexerAddStruct( node );
     653
     654        VISIT_END( node );
     655}
     656
     657template< typename pass_type >
     658Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
     659        MUTATE_START( node );
     660
     661        // make up a forward declaration and add it before processing the members
     662        // needs to be on the heap because addStruct saves the pointer
     663        indexerAddStructFwd( node );
     664
     665        {
     666                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    646667                maybeMutate_impl( node->parameters, *this );
    647668                maybeMutate_impl( node->members   , *this );
     
    677698        VISIT_START( node );
    678699
    679         maybeAccept_impl( node->parameters, *this );
    680         maybeAccept_impl( node->members   , *this );
     700        // make up a forward declaration and add it before processing the members
     701        indexerAddUnionFwd( node );
     702
     703        {
     704                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     705                maybeAccept_impl( node->parameters, *this );
     706                maybeAccept_impl( node->members   , *this );
     707        }
     708
     709        indexerAddUnion( node );
    681710
    682711        VISIT_END( node );
     
    720749        VISIT_START( node );
    721750
     751        indexerAddEnum( node );
     752
    722753        // unlike structs, traits, and unions, enums inject their members into the global scope
    723754        maybeAccept_impl( node->parameters, *this );
     
    761792        VISIT_START( node );
    762793
    763         maybeAccept_impl( node->parameters, *this );
    764         maybeAccept_impl( node->members   , *this );
     794        {
     795                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     796                maybeAccept_impl( node->parameters, *this );
     797                maybeAccept_impl( node->members   , *this );
     798        }
     799
     800        indexerAddTrait( node );
    765801
    766802        VISIT_END( node );
     
    811847        VISIT_START( node );
    812848
    813         maybeAccept_impl( node->parameters, *this );
    814         maybeAccept_impl( node->base      , *this );
    815         maybeAccept_impl( node->assertions, *this );
    816 
    817         VISIT_END( node );
    818 }
    819 
    820 template< typename pass_type >
    821 Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
    822         MUTATE_START( node );
    823 
    824849        {
    825850                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    826                 maybeMutate_impl( node->parameters, *this );
    827                 maybeMutate_impl( node->base      , *this );
     851                maybeAccept_impl( node->parameters, *this );
     852                maybeAccept_impl( node->base      , *this );
    828853        }
    829854
     
    833858        indexerAddType( node );
    834859
     860        maybeAccept_impl( node->assertions, *this );
     861
     862        indexerScopedAccept( node->init, *this );
     863
     864        VISIT_END( node );
     865}
     866
     867template< typename pass_type >
     868Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
     869        MUTATE_START( node );
     870
     871        {
     872                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     873                maybeMutate_impl( node->parameters, *this );
     874                maybeMutate_impl( node->base      , *this );
     875        }
     876
     877        // see A NOTE ON THE ORDER OF TRAVERSAL, above
     878        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
     879        // and may depend on the type itself
     880        indexerAddType( node );
     881
    835882        maybeMutate_impl( node->assertions, *this );
    836883
     
    863910        VISIT_START( node );
    864911
    865         maybeAccept_impl( node->parameters, *this );
    866         maybeAccept_impl( node->base      , *this );
     912        {
     913                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     914                maybeAccept_impl( node->parameters, *this );
     915                maybeAccept_impl( node->base      , *this );
     916        }
     917
     918        indexerAddType( node );
     919
    867920        maybeAccept_impl( node->assertions, *this );
    868921
     
    11011154void PassVisitor< pass_type >::visit( const IfStmt * node ) {
    11021155        VISIT_START( node );
    1103 
    1104         maybeAccept_impl( node->initialization, *this );
    1105         visitExpression ( node->condition );
    1106         visitStatement( node->thenPart );
    1107         visitStatement( node->elsePart );
    1108 
     1156        {
     1157                // if statements introduce a level of scope (for the initialization)
     1158                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1159                maybeAccept_impl( node->initialization, *this );
     1160                visitExpression ( node->condition );
     1161                visitStatement  ( node->thenPart );
     1162                visitStatement  ( node->elsePart );
     1163        }
    11091164        VISIT_END( node );
    11101165}
     
    11451200        VISIT_START( node );
    11461201
    1147         maybeAccept_impl( node->initialization, *this );
    1148         visitExpression ( node->condition );
    1149         visitStatement( node->body );
     1202        {
     1203                // while statements introduce a level of scope (for the initialization)
     1204                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1205                maybeAccept_impl( node->initialization, *this );
     1206                visitExpression ( node->condition );
     1207                visitStatement  ( node->body );
     1208        }
    11501209
    11511210        VISIT_END( node );
     
    11871246void PassVisitor< pass_type >::visit( const ForStmt * node ) {
    11881247        VISIT_START( node );
    1189 
    1190         maybeAccept_impl( node->initialization, *this );
    1191         visitExpression( node->condition );
    1192         visitExpression( node->increment );
    1193         visitStatement( node->body );
    1194 
     1248        {
     1249                // for statements introduce a level of scope (for the initialization)
     1250                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1251                maybeAccept_impl( node->initialization, *this );
     1252                visitExpression( node->condition );
     1253                visitExpression( node->increment );
     1254                visitStatement ( node->body );
     1255        }
    11951256        VISIT_END( node );
    11961257}
     
    14081469void PassVisitor< pass_type >::visit( const CatchStmt * node ) {
    14091470        VISIT_START( node );
    1410 
    1411         maybeAccept_impl( node->decl, *this );
    1412         visitExpression( node->cond );
    1413         visitStatement ( node->body );
    1414 
     1471        {
     1472                // catch statements introduce a level of scope (for the caught exception)
     1473                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1474                maybeAccept_impl( node->decl, *this );
     1475                visitExpression ( node->cond );
     1476                visitStatement  ( node->body );
     1477        }
    14151478        VISIT_END( node );
    14161479}
     
    15431606void PassVisitor< pass_type >::visit( const WithStmt * node ) {
    15441607        VISIT_START( node );
    1545 
    15461608        maybeAccept_impl( node->exprs, *this );
    1547         maybeAccept_impl( node->stmt, *this );
    1548 
     1609        {
     1610                // catch statements introduce a level of scope (for the caught exception)
     1611                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1612                indexerAddWith( node->exprs, node );
     1613                maybeAccept_impl( node->stmt, *this );
     1614        }
    15491615        VISIT_END( node );
    15501616}
     
    16481714
    16491715        indexerScopedAccept( node->result  , *this );
    1650         maybeAccept_impl        ( node->function, *this );
    1651         maybeAccept_impl        ( node->args    , *this );
     1716        maybeAccept_impl   ( node->function, *this );
     1717        maybeAccept_impl   ( node->args    , *this );
    16521718
    16531719        VISIT_END( node );
     
    16581724        VISIT_START( node );
    16591725
    1660         maybeAccept_impl( node->result  , *this );
    1661         maybeAccept_impl( node->function, *this );
    1662         maybeAccept_impl( node->args    , *this );
     1726        indexerScopedAccept( node->result  , *this );
     1727        maybeAccept_impl   ( node->function, *this );
     1728        maybeAccept_impl   ( node->args    , *this );
    16631729
    16641730        VISIT_END( node );
     
    16971763        VISIT_START( node );
    16981764
    1699         maybeAccept_impl( node->result, *this );
     1765        indexerScopedAccept( node->result, *this );
    17001766
    17011767        for ( auto expr : node->args ) {
     
    17351801        VISIT_START( node );
    17361802
    1737         maybeAccept_impl( node->result, *this );
     1803        indexerScopedAccept( node->result, *this );
    17381804
    17391805        VISIT_END( node );
     
    17571823
    17581824        indexerScopedAccept( node->result, *this );
    1759         maybeAccept_impl        ( node->arg   , *this );
     1825        maybeAccept_impl   ( node->arg   , *this );
    17601826
    17611827        VISIT_END( node );
     
    17661832        VISIT_START( node );
    17671833
    1768         maybeAccept_impl( node->result, *this );
    1769         maybeAccept_impl( node->arg   , *this );
     1834        indexerScopedAccept( node->result, *this );
     1835        maybeAccept_impl   ( node->arg   , *this );
    17701836
    17711837        VISIT_END( node );
     
    17991865        VISIT_START( node );
    18001866
    1801         maybeAccept_impl( node->result, *this );
    1802         maybeAccept_impl( node->arg   , *this );
     1867        indexerScopedAccept( node->result, *this );
     1868        maybeAccept_impl   ( node->arg   , *this );
    18031869
    18041870        VISIT_END( node );
     
    18231889
    18241890        indexerScopedAccept( node->result, *this );
    1825         maybeAccept_impl( node->arg, *this );
     1891        maybeAccept_impl   ( node->arg, *this );
    18261892
    18271893        VISIT_END( node );
     
    18321898        VISIT_START( node );
    18331899
    1834         maybeAccept_impl( node->result, *this );
    1835         maybeAccept_impl( node->arg, *this );
     1900        indexerScopedAccept( node->result, *this );
     1901        maybeAccept_impl   ( node->arg, *this );
    18361902
    18371903        VISIT_END( node );
     
    18651931        VISIT_START( node );
    18661932
    1867         maybeAccept_impl( node->result, *this );
    1868         maybeAccept_impl( node->arg   , *this );
     1933        indexerScopedAccept( node->result, *this );
     1934        maybeAccept_impl   ( node->arg   , *this );
    18691935
    18701936        VISIT_END( node );
     
    18971963        VISIT_START( node );
    18981964
    1899         maybeAccept_impl( node->result, *this );
     1965        indexerScopedAccept( node->result, *this );
    19001966
    19011967        VISIT_END( node );
     
    19291995        VISIT_START( node );
    19301996
    1931         maybeAccept_impl( node->result   , *this );
    1932         maybeAccept_impl( node->aggregate, *this );
    1933         maybeAccept_impl( node->member   , *this );
     1997        indexerScopedAccept( node->result   , *this );
     1998        maybeAccept_impl   ( node->aggregate, *this );
     1999        maybeAccept_impl   ( node->member   , *this );
    19342000
    19352001        VISIT_END( node );
     
    19642030        VISIT_START( node );
    19652031
    1966         maybeAccept_impl( node->result   , *this );
    1967         maybeAccept_impl( node->aggregate, *this );
     2032        indexerScopedAccept( node->result   , *this );
     2033        maybeAccept_impl   ( node->aggregate, *this );
    19682034
    19692035        VISIT_END( node );
     
    19962062        VISIT_START( node );
    19972063
    1998         maybeAccept_impl( node->result, *this );
     2064        indexerScopedAccept( node->result, *this );
    19992065
    20002066        VISIT_END( node );
     
    20272093        VISIT_START( node );
    20282094
    2029         maybeAccept_impl( node->result   , *this );
    2030         maybeAccept_impl( &node->constant, *this );
     2095        indexerScopedAccept( node->result   , *this );
     2096        maybeAccept_impl   ( &node->constant, *this );
    20312097
    20322098        VISIT_END( node );
     
    20662132        VISIT_START( node );
    20672133
    2068         maybeAccept_impl( node->result, *this );
     2134        indexerScopedAccept( node->result, *this );
    20692135        if ( node->get_isType() ) {
    20702136                maybeAccept_impl( node->type, *this );
     
    21112177        VISIT_START( node );
    21122178
    2113         maybeAccept_impl( node->result, *this );
     2179        indexerScopedAccept( node->result, *this );
    21142180        if ( node->get_isType() ) {
    21152181                maybeAccept_impl( node->type, *this );
     
    21522218        VISIT_START( node );
    21532219
    2154         maybeAccept_impl( node->result, *this );
    2155         maybeAccept_impl( node->type  , *this );
     2220        indexerScopedAccept( node->result, *this );
     2221        maybeAccept_impl   ( node->type  , *this );
    21562222
    21572223        VISIT_END( node );
     
    21852251        VISIT_START( node );
    21862252
    2187         maybeAccept_impl( node->result, *this );
    2188         maybeAccept_impl( node->type  , *this );
     2253        indexerScopedAccept( node->result, *this );
     2254        maybeAccept_impl   ( node->type  , *this );
    21892255
    21902256        VISIT_END( node );
     
    22182284        VISIT_START( node );
    22192285
    2220         maybeAccept_impl( node->result, *this );
    2221         maybeAccept_impl( node->type  , *this );
     2286        indexerScopedAccept( node->result, *this );
     2287        maybeAccept_impl   ( node->type  , *this );
    22222288
    22232289        VISIT_END( node );
     
    22552321        VISIT_START( node );
    22562322
    2257         maybeAccept_impl( node->result, *this );
     2323        indexerScopedAccept( node->result, *this );
    22582324        if ( node->get_isType() ) {
    22592325                maybeAccept_impl( node->type, *this );
     
    22972363        VISIT_START( node );
    22982364
    2299         maybeAccept_impl( node->result, *this );
    2300         maybeAccept_impl( node->arg1  , *this );
    2301         maybeAccept_impl( node->arg2  , *this );
     2365        indexerScopedAccept( node->result, *this );
     2366        maybeAccept_impl   ( node->arg1  , *this );
     2367        maybeAccept_impl   ( node->arg2  , *this );
    23022368
    23032369        VISIT_END( node );
     
    23342400        VISIT_START( node );
    23352401
    2336         maybeAccept_impl( node->result, *this );
    2337         maybeAccept_impl( node->arg1  , *this );
    2338         maybeAccept_impl( node->arg2  , *this );
    2339         maybeAccept_impl( node->arg3  , *this );
     2402        indexerScopedAccept( node->result, *this );
     2403        maybeAccept_impl   ( node->arg1  , *this );
     2404        maybeAccept_impl   ( node->arg2  , *this );
     2405        maybeAccept_impl   ( node->arg3  , *this );
    23402406
    23412407        VISIT_END( node );
     
    23722438        VISIT_START( node );
    23732439
    2374         maybeAccept_impl( node->result, *this );
    2375         maybeAccept_impl( node->arg1  , *this );
    2376         maybeAccept_impl( node->arg2  , *this );
     2440        indexerScopedAccept( node->result, *this );
     2441        maybeAccept_impl   ( node->arg1  , *this );
     2442        maybeAccept_impl   ( node->arg2  , *this );
    23772443
    23782444        VISIT_END( node );
     
    24072473        VISIT_START( node );
    24082474
    2409         maybeAccept_impl( node->result, *this );
    2410         maybeAccept_impl( node->type, *this );
     2475        indexerScopedAccept( node->result, *this );
     2476        maybeAccept_impl   ( node->type, *this );
    24112477
    24122478        VISIT_END( node );
     
    24422508        VISIT_START( node );
    24432509
    2444         maybeAccept_impl( node->result    , *this );
    2445         maybeAccept_impl( node->inout     , *this );
    2446         maybeAccept_impl( node->constraint, *this );
    2447         maybeAccept_impl( node->operand   , *this );
     2510        indexerScopedAccept( node->result    , *this );
     2511        maybeAccept_impl   ( node->inout     , *this );
     2512        maybeAccept_impl   ( node->constraint, *this );
     2513        maybeAccept_impl   ( node->operand   , *this );
    24482514
    24492515        VISIT_END( node );
     
    24792545        VISIT_START( node );
    24802546
    2481         maybeAccept_impl( node->result    , *this );
    2482         maybeAccept_impl( node->callExpr  , *this );
     2547        indexerScopedAccept( node->result    , *this );
     2548        maybeAccept_impl   ( node->callExpr  , *this );
    24832549
    24842550        VISIT_END( node );
     
    25122578        VISIT_START( node );
    25132579
    2514         maybeAccept_impl( node->result  , *this );
    2515         maybeAccept_impl( node->callExpr, *this );
     2580        indexerScopedAccept( node->result  , *this );
     2581        maybeAccept_impl   ( node->callExpr, *this );
    25162582
    25172583        VISIT_END( node );
     
    25452611        VISIT_START( node );
    25462612
    2547         maybeAccept_impl( node->result     , *this );
    2548         maybeAccept_impl( node->initializer, *this );
     2613        indexerScopedAccept( node->result     , *this );
     2614        maybeAccept_impl   ( node->initializer, *this );
    25492615
    25502616        VISIT_END( node );
     
    25792645        VISIT_START( node );
    25802646
    2581         maybeAccept_impl( node->result, *this );
    2582         maybeAccept_impl( node->low   , *this );
    2583         maybeAccept_impl( node->high  , *this );
     2647        indexerScopedAccept( node->result, *this );
     2648        maybeAccept_impl   ( node->low   , *this );
     2649        maybeAccept_impl   ( node->high  , *this );
    25842650
    25852651        VISIT_END( node );
     
    26142680        VISIT_START( node );
    26152681
    2616         maybeAccept_impl( node->result, *this );
    2617         maybeAccept_impl( node->exprs , *this );
     2682        indexerScopedAccept( node->result, *this );
     2683        maybeAccept_impl   ( node->exprs , *this );
    26182684
    26192685        VISIT_END( node );
     
    26472713        VISIT_START( node );
    26482714
    2649         maybeAccept_impl( node->result, *this );
    2650         maybeAccept_impl( node->exprs , *this );
     2715        indexerScopedAccept( node->result, *this );
     2716        maybeAccept_impl   ( node->exprs , *this );
    26512717
    26522718        VISIT_END( node );
     
    26802746        VISIT_START( node );
    26812747
    2682         maybeAccept_impl( node->result, *this );
    2683         maybeAccept_impl( node->tuple , *this );
     2748        indexerScopedAccept( node->result, *this );
     2749        maybeAccept_impl   ( node->tuple , *this );
    26842750
    26852751        VISIT_END( node );
     
    27132779        VISIT_START( node );
    27142780
    2715         maybeAccept_impl( node->result  , *this );
     2781        indexerScopedAccept( node->result  , *this );
    27162782        maybeAccept_impl( node->stmtExpr, *this );
    27172783
     
    27532819        VISIT_START( node );
    27542820
    2755         maybeAccept_impl( node->result     , *this );
    2756         maybeAccept_impl( node->statements , *this );
    2757         maybeAccept_impl( node->returnDecls, *this );
    2758         maybeAccept_impl( node->dtors      , *this );
    2759 
    2760         VISIT_END( node );
    2761 }
    2762 
    2763 template< typename pass_type >
    2764 Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
    2765         MUTATE_START( node );
    2766 
    27672821        // don't want statements from outer CompoundStmts to be added to this StmtExpr
    27682822        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
     
    27702824        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    27712825
     2826        indexerScopedAccept( node->result     , *this );
     2827        maybeAccept_impl   ( node->statements , *this );
     2828        maybeAccept_impl   ( node->returnDecls, *this );
     2829        maybeAccept_impl   ( node->dtors      , *this );
     2830
     2831        VISIT_END( node );
     2832}
     2833
     2834template< typename pass_type >
     2835Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
     2836        MUTATE_START( node );
     2837
     2838        // don't want statements from outer CompoundStmts to be added to this StmtExpr
     2839        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
     2840        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
     2841        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
     2842
    27722843        indexerScopedMutate( node->result     , *this );
    27732844        maybeMutate_impl   ( node->statements , *this );
     
    27942865        VISIT_START( node );
    27952866
    2796         maybeAccept_impl( node->result, *this );
    2797         maybeAccept_impl( node->expr  , *this );
     2867        indexerScopedAccept( node->result, *this );
     2868        maybeAccept_impl   ( node->expr  , *this );
    27982869
    27992870        VISIT_END( node );
     
    28282899        VISIT_START( node );
    28292900
    2830         maybeAccept_impl( node->result, *this );
    2831         maybeAccept_impl( node->expr  , *this );
     2901        indexerScopedAccept( node->result, *this );
     2902        maybeAccept_impl   ( node->expr  , *this );
    28322903        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
    28332904
     
    28642935        VISIT_START( node );
    28652936
    2866         maybeAccept_impl( node->result, *this );
    2867         maybeAccept_impl( node->expr  , *this );
    2868         maybeAccept_impl( node->designation, *this );
     2937        indexerScopedAccept( node->result, *this );
     2938        maybeAccept_impl   ( node->expr  , *this );
     2939        maybeAccept_impl   ( node->designation, *this );
    28692940
    28702941        VISIT_END( node );
     
    28902961
    28912962        indexerScopedAccept( node->result, *this );
    2892         maybeAccept_impl( node->expr, *this );
     2963        maybeAccept_impl   ( node->expr, *this );
    28932964        // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
    28942965
     
    29002971        VISIT_START( node );
    29012972
    2902         maybeAccept_impl( node->result, *this );
    2903         maybeAccept_impl( node->expr, *this );
     2973        indexerScopedAccept( node->result, *this );
     2974        maybeAccept_impl   ( node->expr, *this );
    29042975        // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
    29052976
     
    29252996
    29262997        indexerScopedAccept( node->result, *this );
    2927         maybeAccept_impl( node->expr, *this );
     2998        maybeAccept_impl   ( node->expr, *this );
    29282999
    29293000        VISIT_END( node );
     
    29343005        VISIT_START( node );
    29353006
    2936         maybeAccept_impl( node->result, *this );
    2937         maybeAccept_impl( node->expr, *this );
     3007        indexerScopedAccept( node->result, *this );
     3008        maybeAccept_impl   ( node->expr, *this );
    29383009
    29393010        VISIT_END( node );
     
    29713042        VISIT_START( node );
    29723043
    2973         maybeAccept_impl( node->result, *this );
     3044        indexerScopedAccept( node->result, *this );
    29743045        maybeAccept_impl( node->control, *this );
    29753046        for ( const GenericExpr::Association & assoc : node->associations ) {
    2976                 maybeAccept_impl( assoc.type, *this );
     3047                indexerScopedAccept( assoc.type, *this );
    29773048                maybeAccept_impl( assoc.expr, *this );
    29783049        }
     
    32473318        VISIT_START( node );
    32483319
    3249         maybeAccept_impl( node->forall    , *this );
    3250         maybeAccept_impl( node->parameters, *this );
     3320        indexerAddStruct( node->name );
     3321
     3322        {
     3323                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     3324                maybeAccept_impl( node->forall    , *this );
     3325                maybeAccept_impl( node->parameters, *this );
     3326        }
    32513327
    32523328        VISIT_END( node );
     
    32893365        VISIT_START( node );
    32903366
    3291         maybeAccept_impl( node->forall    , *this );
    3292         maybeAccept_impl( node->parameters, *this );
     3367        indexerAddStruct( node->name );
     3368
     3369        {
     3370                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     3371                maybeAccept_impl( node->forall    , *this );
     3372                maybeAccept_impl( node->parameters, *this );
     3373        }
    32933374
    32943375        VISIT_END( node );
  • src/Common/PassVisitor.proto.h

    r6f096d2 re3d7f9f  
    229229
    230230
    231 INDEXER_FUNC1( addId     , DeclarationWithType *       );
    232 INDEXER_FUNC1( addType   , NamedTypeDecl *             );
    233 INDEXER_FUNC1( addStruct , StructDecl *                );
    234 INDEXER_FUNC1( addEnum   , EnumDecl *                  );
    235 INDEXER_FUNC1( addUnion  , UnionDecl *                 );
    236 INDEXER_FUNC1( addTrait  , TraitDecl *                 );
    237 INDEXER_FUNC2( addWith   , std::list< Expression * > &, BaseSyntaxNode * );
     231INDEXER_FUNC1( addId     , const DeclarationWithType *       );
     232INDEXER_FUNC1( addType   , const NamedTypeDecl *             );
     233INDEXER_FUNC1( addStruct , const StructDecl *                );
     234INDEXER_FUNC1( addEnum   , const EnumDecl *                  );
     235INDEXER_FUNC1( addUnion  , const UnionDecl *                 );
     236INDEXER_FUNC1( addTrait  , const TraitDecl *                 );
     237INDEXER_FUNC2( addWith   , const std::list< Expression * > &, const BaseSyntaxNode * );
    238238
    239239#undef INDEXER_FUNC1
     
    241241
    242242template<typename pass_type>
    243 static inline auto indexer_impl_addStructFwd( pass_type & pass, int, StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
     243static inline auto indexer_impl_addStructFwd( pass_type & pass, int, const StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
    244244        StructDecl * fwd = new StructDecl( decl->name );
    245245        cloneAll( decl->parameters, fwd->parameters );
     
    251251
    252252template<typename pass_type>
    253 static inline auto indexer_impl_addUnionFwd( pass_type & pass, int, UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
     253static inline auto indexer_impl_addUnionFwd( pass_type & pass, int, const UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
    254254        UnionDecl * fwd = new UnionDecl( decl->name );
    255255        cloneAll( decl->parameters, fwd->parameters );
Note: See TracChangeset for help on using the changeset viewer.