Ignore:
Timestamp:
Aug 12, 2020, 10:31:58 AM (4 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
f8d05ee
Parents:
343d10e
Message:

{pass_t Pass::pass; => core_t Pass::core;} To avoid confusion about which pass we are talking about.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Pass.impl.hpp

    r343d10e r7ff3e522  
    2525        using namespace ast; \
    2626        /* back-up the visit children */ \
    27         __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(pass, 0) ); \
     27        __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
    2828        /* setup the scope for passes that want to run code at exit */ \
    29         __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (pass, 0) ); \
     29        __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (core, 0) ); \
    3030        /* begin tracing memory allocation if requested by this pass */ \
    31         __pass::beginTrace( pass, 0 ); \
     31        __pass::beginTrace( core, 0 ); \
    3232        /* call the implementation of the previsit of this pass */ \
    33         __pass::previsit( pass, node, 0 );
     33        __pass::previsit( core, node, 0 );
    3434
    3535#define VISIT( code... ) \
    … …  
    4242#define VISIT_END( type, node ) \
    4343        /* call the implementation of the postvisit of this pass */ \
    44         auto __return = __pass::postvisit( pass, node, 0 ); \
     44        auto __return = __pass::postvisit( core, node, 0 ); \
    4545        assertf(__return, "post visit should never return null"); \
    4646        /* end tracing memory allocation if requested by this pass */ \
    47         __pass::endTrace( pass, 0 ); \
     47        __pass::endTrace( core, 0 ); \
    4848        return __return;
    4949
    … …  
    123123        }
    124124
    125         template< typename pass_t >
     125        template< typename core_t >
    126126        template< typename node_t >
    127         auto ast::Pass< pass_t >::call_accept( const node_t * node )
     127        auto ast::Pass< core_t >::call_accept( const node_t * node )
    128128                -> typename std::enable_if<
    129129                                !std::is_base_of<ast::Expr, node_t>::value &&
    … …  
    141141        }
    142142
    143         template< typename pass_t >
    144         const ast::Expr * ast::Pass< pass_t >::call_accept( const ast::Expr * expr ) {
     143        template< typename core_t >
     144        const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
    145145                __pedantic_pass_assert( __visit_children() );
    146146                __pedantic_pass_assert( expr );
    147147
    148                 const ast::TypeSubstitution ** env_ptr = __pass::env( pass, 0);
     148                const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0);
    149149                if ( env_ptr && expr->env ) {
    150150                        *env_ptr = expr->env;
    … …  
    154154        }
    155155
    156         template< typename pass_t >
    157         const ast::Stmt * ast::Pass< pass_t >::call_accept( const ast::Stmt * stmt ) {
     156        template< typename core_t >
     157        const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
    158158                __pedantic_pass_assert( __visit_children() );
    159159                __pedantic_pass_assert( stmt );
    … …  
    163163
    164164                // get the stmts/decls that will need to be spliced in
    165                 auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
    166                 auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
    167                 auto decls_before = __pass::declsToAddBefore( pass, 0);
    168                 auto decls_after  = __pass::declsToAddAfter ( pass, 0);
     165                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     166                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
     167                auto decls_before = __pass::declsToAddBefore( core, 0);
     168                auto decls_after  = __pass::declsToAddAfter ( core, 0);
    169169
    170170                // These may be modified by subnode but most be restored once we exit this statemnet.
    171                 ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( pass, 0) );
     171                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( core, 0) );
    172172                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
    173173                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
    … …  
    205205        }
    206206
    207         template< typename pass_t >
     207        template< typename core_t >
    208208        template< template <class...> class container_t >
    209         container_t< ptr<Stmt> > ast::Pass< pass_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
     209        container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
    210210                __pedantic_pass_assert( __visit_children() );
    211211                if( statements.empty() ) return {};
    … …  
    218218
    219219                // get the stmts/decls that will need to be spliced in
    220                 auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
    221                 auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
    222                 auto decls_before = __pass::declsToAddBefore( pass, 0);
    223                 auto decls_after  = __pass::declsToAddAfter ( pass, 0);
     220                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     221                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
     222                auto decls_before = __pass::declsToAddBefore( core, 0);
     223                auto decls_after  = __pass::declsToAddAfter ( core, 0);
    224224
    225225                // These may be modified by subnode but most be restored once we exit this statemnet.
    … …  
    271271        }
    272272
    273         template< typename pass_t >
     273        template< typename core_t >
    274274        template< template <class...> class container_t, typename node_t >
    275         container_t< ast::ptr<node_t> > ast::Pass< pass_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
     275        container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
    276276                __pedantic_pass_assert( __visit_children() );
    277277                if( container.empty() ) return {};
    … …  
    302302        }
    303303
    304         template< typename pass_t >
     304        template< typename core_t >
    305305        template<typename node_t, typename parent_t, typename child_t>
    306         void ast::Pass< pass_t >::maybe_accept(
     306        void ast::Pass< core_t >::maybe_accept(
    307307                const node_t * & parent,
    308308                child_t parent_t::*child
    … …  
    327327
    328328
    329         template< typename pass_t >
     329        template< typename core_t >
    330330        template< typename node_t >
    331         void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) {
    332                 if ( auto subs = __pass::forall::subs( pass, 0 ) ) {
     331        void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
     332                if ( auto subs = __pass::forall::subs( core, 0 ) ) {
    333333                        // tracking TypeDecl substitution, full clone
    334334                        if ( node->forall.empty() ) return;
    … …  
    352352//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    353353
    354 template< typename pass_t >
    355 inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< pass_t > & visitor ) {
     354template< typename core_t >
     355inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
    356356        // We are going to aggregate errors for all these statements
    357357        SemanticErrorException errors;
    … …  
    361361
    362362        // get the stmts/decls that will need to be spliced in
    363         auto decls_before = __pass::declsToAddBefore( visitor.pass, 0);
    364         auto decls_after  = __pass::declsToAddAfter ( visitor.pass, 0);
     363        auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
     364        auto decls_after  = __pass::declsToAddAfter ( visitor.core, 0);
    365365
    366366        // update pass statitistics
    … …  
    411411//--------------------------------------------------------------------------
    412412// ObjectDecl
    413 template< typename pass_t >
    414 const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) {
     413template< typename core_t >
     414const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
    415415        VISIT_START( node );
    416416
    … …  
    425425        )
    426426
    427         __pass::symtab::addId( pass, 0, node );
     427        __pass::symtab::addId( core, 0, node );
    428428
    429429        VISIT_END( DeclWithType, node );
    … …  
    432432//--------------------------------------------------------------------------
    433433// FunctionDecl
    434 template< typename pass_t >
    435 const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::FunctionDecl * node ) {
    436         VISIT_START( node );
    437 
    438         __pass::symtab::addId( pass, 0, node );
     434template< typename core_t >
     435const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
     436        VISIT_START( node );
     437
     438        __pass::symtab::addId( core, 0, node );
    439439
    440440        VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
    … …  
    444444                // shadow with exprs and not the other way around.
    445445                guard_symtab guard { *this };
    446                 __pass::symtab::addWith( pass, 0, node->withExprs, node );
     446                __pass::symtab::addWith( core, 0, node->withExprs, node );
    447447                {
    448448                        guard_symtab guard { *this };
    … …  
    455455                                }
    456456                        } };
    457                         __pass::symtab::addId( pass, 0, func );
     457                        __pass::symtab::addId( core, 0, func );
    458458                        VISIT(
    459459                                maybe_accept( node, &FunctionDecl::type );
    … …  
    473473//--------------------------------------------------------------------------
    474474// StructDecl
    475 template< typename pass_t >
    476 const ast::Decl * ast::Pass< pass_t >::visit( const ast::StructDecl * node ) {
     475template< typename core_t >
     476const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
    477477        VISIT_START( node );
    478478
    479479        // make up a forward declaration and add it before processing the members
    480480        // needs to be on the heap because addStruct saves the pointer
    481         __pass::symtab::addStructFwd( pass, 0, node );
     481        __pass::symtab::addStructFwd( core, 0, node );
    482482
    483483        VISIT({
    … …  
    488488
    489489        // this addition replaces the forward declaration
    490         __pass::symtab::addStruct( pass, 0, node );
     490        __pass::symtab::addStruct( core, 0, node );
    491491
    492492        VISIT_END( Decl, node );
    … …  
    495495//--------------------------------------------------------------------------
    496496// UnionDecl
    497 template< typename pass_t >
    498 const ast::Decl * ast::Pass< pass_t >::visit( const ast::UnionDecl * node ) {
     497template< typename core_t >
     498const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
    499499        VISIT_START( node );
    500500
    501501        // make up a forward declaration and add it before processing the members
    502         __pass::symtab::addUnionFwd( pass, 0, node );
     502        __pass::symtab::addUnionFwd( core, 0, node );
    503503
    504504        VISIT({
    … …  
    508508        })
    509509
    510         __pass::symtab::addUnion( pass, 0, node );
     510        __pass::symtab::addUnion( core, 0, node );
    511511
    512512        VISIT_END( Decl, node );
    … …  
    515515//--------------------------------------------------------------------------
    516516// EnumDecl
    517 template< typename pass_t >
    518 const ast::Decl * ast::Pass< pass_t >::visit( const ast::EnumDecl * node ) {
    519         VISIT_START( node );
    520 
    521         __pass::symtab::addEnum( pass, 0, node );
     517template< typename core_t >
     518const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
     519        VISIT_START( node );
     520
     521        __pass::symtab::addEnum( core, 0, node );
    522522
    523523        VISIT(
    … …  
    532532//--------------------------------------------------------------------------
    533533// TraitDecl
    534 template< typename pass_t >
    535 const ast::Decl * ast::Pass< pass_t >::visit( const ast::TraitDecl * node ) {
     534template< typename core_t >
     535const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
    536536        VISIT_START( node );
    537537
    … …  
    542542        })
    543543
    544         __pass::symtab::addTrait( pass, 0, node );
     544        __pass::symtab::addTrait( core, 0, node );
    545545
    546546        VISIT_END( Decl, node );
    … …  
    549549//--------------------------------------------------------------------------
    550550// TypeDecl
    551 template< typename pass_t >
    552 const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypeDecl * node ) {
     551template< typename core_t >
     552const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
    553553        VISIT_START( node );
    554554
    … …  
    562562        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
    563563        // and may depend on the type itself
    564         __pass::symtab::addType( pass, 0, node );
     564        __pass::symtab::addType( core, 0, node );
    565565
    566566        VISIT(
    … …  
    578578//--------------------------------------------------------------------------
    579579// TypedefDecl
    580 template< typename pass_t >
    581 const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypedefDecl * node ) {
     580template< typename core_t >
     581const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
    582582        VISIT_START( node );
    583583
    … …  
    588588        })
    589589
    590         __pass::symtab::addType( pass, 0, node );
     590        __pass::symtab::addType( core, 0, node );
    591591
    592592        VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
    … …  
    597597//--------------------------------------------------------------------------
    598598// AsmDecl
    599 template< typename pass_t >
    600 const ast::AsmDecl * ast::Pass< pass_t >::visit( const ast::AsmDecl * node ) {
     599template< typename core_t >
     600const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
    601601        VISIT_START( node );
    602602
    … …  
    610610//--------------------------------------------------------------------------
    611611// StaticAssertDecl
    612 template< typename pass_t >
    613 const ast::StaticAssertDecl * ast::Pass< pass_t >::visit( const ast::StaticAssertDecl * node ) {
     612template< typename core_t >
     613const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
    614614        VISIT_START( node );
    615615
    … …  
    624624//--------------------------------------------------------------------------
    625625// CompoundStmt
    626 template< typename pass_t >
    627 const ast::CompoundStmt * ast::Pass< pass_t >::visit( const ast::CompoundStmt * node ) {
     626template< typename core_t >
     627const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
    628628        VISIT_START( node );
    629629        VISIT({
    630630                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
    631631                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
    632                         if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0);
     632                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
    633633                }, [this, inFunctionCpy = this->inFunction]() {
    634                         if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0);
     634                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
    635635                });
    636636                ValueGuard< bool > guard2( inFunction );
    … …  
    644644//--------------------------------------------------------------------------
    645645// ExprStmt
    646 template< typename pass_t >
    647 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ExprStmt * node ) {
     646template< typename core_t >
     647const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
    648648        VISIT_START( node );
    649649
    … …  
    657657//--------------------------------------------------------------------------
    658658// AsmStmt
    659 template< typename pass_t >
    660 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) {
     659template< typename core_t >
     660const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
    661661        VISIT_START( node )
    662662
    … …  
    673673//--------------------------------------------------------------------------
    674674// DirectiveStmt
    675 template< typename pass_t >
    676 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) {
     675template< typename core_t >
     676const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
    677677        VISIT_START( node )
    678678
    … …  
    682682//--------------------------------------------------------------------------
    683683// IfStmt
    684 template< typename pass_t >
    685 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) {
     684template< typename core_t >
     685const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
    686686        VISIT_START( node );
    687687
    … …  
    700700//--------------------------------------------------------------------------
    701701// WhileStmt
    702 template< typename pass_t >
    703 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WhileStmt * node ) {
     702template< typename core_t >
     703const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
    704704        VISIT_START( node );
    705705
    … …  
    717717//--------------------------------------------------------------------------
    718718// ForStmt
    719 template< typename pass_t >
    720 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) {
     719template< typename core_t >
     720const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
    721721        VISIT_START( node );
    722722
    … …  
    735735//--------------------------------------------------------------------------
    736736// SwitchStmt
    737 template< typename pass_t >
    738 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) {
     737template< typename core_t >
     738const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
    739739        VISIT_START( node );
    740740
    … …  
    749749//--------------------------------------------------------------------------
    750750// CaseStmt
    751 template< typename pass_t >
    752 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) {
     751template< typename core_t >
     752const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
    753753        VISIT_START( node );
    754754
    … …  
    763763//--------------------------------------------------------------------------
    764764// BranchStmt
    765 template< typename pass_t >
    766 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) {
     765template< typename core_t >
     766const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
    767767        VISIT_START( node );
    768768        VISIT_END( Stmt, node );
    … …  
    771771//--------------------------------------------------------------------------
    772772// ReturnStmt
    773 template< typename pass_t >
    774 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) {
     773template< typename core_t >
     774const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
    775775        VISIT_START( node );
    776776
    … …  
    784784//--------------------------------------------------------------------------
    785785// ThrowStmt
    786 template< typename pass_t >
    787 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) {
     786template< typename core_t >
     787const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
    788788        VISIT_START( node );
    789789
    … …  
    798798//--------------------------------------------------------------------------
    799799// TryStmt
    800 template< typename pass_t >
    801 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) {
     800template< typename core_t >
     801const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
    802802        VISIT_START( node );
    803803
    … …  
    813813//--------------------------------------------------------------------------
    814814// CatchStmt
    815 template< typename pass_t >
    816 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CatchStmt * node ) {
     815template< typename core_t >
     816const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
    817817        VISIT_START( node );
    818818
    … …  
    830830//--------------------------------------------------------------------------
    831831// FinallyStmt
    832 template< typename pass_t >
    833 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::FinallyStmt * node ) {
     832template< typename core_t >
     833const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
    834834        VISIT_START( node );
    835835
    … …  
    843843//--------------------------------------------------------------------------
    844844// FinallyStmt
    845 template< typename pass_t >
    846 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) {
     845template< typename core_t >
     846const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
    847847        VISIT_START( node );
    848848
    … …  
    856856//--------------------------------------------------------------------------
    857857// WaitForStmt
    858 template< typename pass_t >
    859 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WaitForStmt * node ) {
     858template< typename core_t >
     859const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
    860860        VISIT_START( node );
    861861                // for( auto & clause : node->clauses ) {
    … …  
    925925//--------------------------------------------------------------------------
    926926// WithStmt
    927 template< typename pass_t >
    928 const ast::Decl * ast::Pass< pass_t >::visit( const ast::WithStmt * node ) {
     927template< typename core_t >
     928const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
    929929        VISIT_START( node );
    930930
    … …  
    934934                        // catch statements introduce a level of scope (for the caught exception)
    935935                        guard_symtab guard { *this };
    936                         __pass::symtab::addWith( pass, 0, node->exprs, node );
     936                        __pass::symtab::addWith( core, 0, node->exprs, node );
    937937                        maybe_accept( node, &WithStmt::stmt );
    938938                }
    … …  
    943943//--------------------------------------------------------------------------
    944944// NullStmt
    945 template< typename pass_t >
    946 const ast::NullStmt * ast::Pass< pass_t >::visit( const ast::NullStmt * node ) {
     945template< typename core_t >
     946const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
    947947        VISIT_START( node );
    948948        VISIT_END( NullStmt, node );
    … …  
    951951//--------------------------------------------------------------------------
    952952// DeclStmt
    953 template< typename pass_t >
    954 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DeclStmt * node ) {
     953template< typename core_t >
     954const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
    955955        VISIT_START( node );
    956956
    … …  
    964964//--------------------------------------------------------------------------
    965965// ImplicitCtorDtorStmt
    966 template< typename pass_t >
    967 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
     966template< typename core_t >
     967const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
    968968        VISIT_START( node );
    969969
    … …  
    979979//--------------------------------------------------------------------------
    980980// ApplicationExpr
    981 template< typename pass_t >
    982 const ast::Expr * ast::Pass< pass_t >::visit( const ast::ApplicationExpr * node ) {
     981template< typename core_t >
     982const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
    983983        VISIT_START( node );
    984984
    … …  
    997997//--------------------------------------------------------------------------
    998998// UntypedExpr
    999 template< typename pass_t >
    1000 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedExpr * node ) {
     999template< typename core_t >
     1000const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
    10011001        VISIT_START( node );
    10021002
    … …  
    10151015//--------------------------------------------------------------------------
    10161016// NameExpr
    1017 template< typename pass_t >
    1018 const ast::Expr * ast::Pass< pass_t >::visit( const ast::NameExpr * node ) {
     1017template< typename core_t >
     1018const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
    10191019        VISIT_START( node );
    10201020
    … …  
    10291029//--------------------------------------------------------------------------
    10301030// CastExpr
    1031 template< typename pass_t >
    1032 const ast::Expr * ast::Pass< pass_t >::visit( const ast::CastExpr * node ) {
     1031template< typename core_t >
     1032const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
    10331033        VISIT_START( node );
    10341034
    … …  
    10451045//--------------------------------------------------------------------------
    10461046// KeywordCastExpr
    1047 template< typename pass_t >
    1048 const ast::Expr * ast::Pass< pass_t >::visit( const ast::KeywordCastExpr * node ) {
     1047template< typename core_t >
     1048const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
    10491049        VISIT_START( node );
    10501050
    … …  
    10611061//--------------------------------------------------------------------------
    10621062// VirtualCastExpr
    1063 template< typename pass_t >
    1064 const ast::Expr * ast::Pass< pass_t >::visit( const ast::VirtualCastExpr * node ) {
     1063template< typename core_t >
     1064const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
    10651065        VISIT_START( node );
    10661066
    … …  
    10771077//--------------------------------------------------------------------------
    10781078// AddressExpr
    1079 template< typename pass_t >
    1080 const ast::Expr * ast::Pass< pass_t >::visit( const ast::AddressExpr * node ) {
     1079template< typename core_t >
     1080const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
    10811081        VISIT_START( node );
    10821082
    … …  
    10931093//--------------------------------------------------------------------------
    10941094// LabelAddressExpr
    1095 template< typename pass_t >
    1096 const ast::Expr * ast::Pass< pass_t >::visit( const ast::LabelAddressExpr * node ) {
     1095template< typename core_t >
     1096const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
    10971097        VISIT_START( node );
    10981098
    … …  
    11071107//--------------------------------------------------------------------------
    11081108// UntypedMemberExpr
    1109 template< typename pass_t >
    1110 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedMemberExpr * node ) {
     1109template< typename core_t >
     1110const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
    11111111        VISIT_START( node );
    11121112
    … …  
    11241124//--------------------------------------------------------------------------
    11251125// MemberExpr
    1126 template< typename pass_t >
    1127 const ast::Expr * ast::Pass< pass_t >::visit( const ast::MemberExpr * node ) {
     1126template< typename core_t >
     1127const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
    11281128        VISIT_START( node );
    11291129
    … …  
    11401140//--------------------------------------------------------------------------
    11411141// VariableExpr
    1142 template< typename pass_t >
    1143 const ast::Expr * ast::Pass< pass_t >::visit( const ast::VariableExpr * node ) {
     1142template< typename core_t >
     1143const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
    11441144        VISIT_START( node );
    11451145
    … …  
    11541154//--------------------------------------------------------------------------
    11551155// ConstantExpr
    1156 template< typename pass_t >
    1157 const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstantExpr * node ) {
     1156template< typename core_t >
     1157const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
    11581158        VISIT_START( node );
    11591159
    … …  
    11681168//--------------------------------------------------------------------------
    11691169// SizeofExpr
    1170 template< typename pass_t >
    1171 const ast::Expr * ast::Pass< pass_t >::visit( const ast::SizeofExpr * node ) {
     1170template< typename core_t >
     1171const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
    11721172        VISIT_START( node );
    11731173
    … …  
    11881188//--------------------------------------------------------------------------
    11891189// AlignofExpr
    1190 template< typename pass_t >
    1191 const ast::Expr * ast::Pass< pass_t >::visit( const ast::AlignofExpr * node ) {
     1190template< typename core_t >
     1191const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
    11921192        VISIT_START( node );
    11931193
    … …  
    12081208//--------------------------------------------------------------------------
    12091209// UntypedOffsetofExpr
    1210 template< typename pass_t >
    1211 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedOffsetofExpr * node ) {
     1210template< typename core_t >
     1211const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
    12121212        VISIT_START( node );
    12131213
    … …  
    12241224//--------------------------------------------------------------------------
    12251225// OffsetofExpr
    1226 template< typename pass_t >
    1227 const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetofExpr * node ) {
     1226template< typename core_t >
     1227const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
    12281228        VISIT_START( node );
    12291229
    … …  
    12401240//--------------------------------------------------------------------------
    12411241// OffsetPackExpr
    1242 template< typename pass_t >
    1243 const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetPackExpr * node ) {
     1242template< typename core_t >
     1243const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
    12441244        VISIT_START( node );
    12451245
    … …  
    12561256//--------------------------------------------------------------------------
    12571257// LogicalExpr
    1258 template< typename pass_t >
    1259 const ast::Expr * ast::Pass< pass_t >::visit( const ast::LogicalExpr * node ) {
     1258template< typename core_t >
     1259const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
    12601260        VISIT_START( node );
    12611261
    … …  
    12731273//--------------------------------------------------------------------------
    12741274// ConditionalExpr
    1275 template< typename pass_t >
    1276 const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConditionalExpr * node ) {
     1275template< typename core_t >
     1276const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
    12771277        VISIT_START( node );
    12781278
    … …  
    12911291//--------------------------------------------------------------------------
    12921292// CommaExpr
    1293 template< typename pass_t >
    1294 const ast::Expr * ast::Pass< pass_t >::visit( const ast::CommaExpr * node ) {
     1293template< typename core_t >
     1294const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
    12951295        VISIT_START( node );
    12961296
    … …  
    13081308//--------------------------------------------------------------------------
    13091309// TypeExpr
    1310 template< typename pass_t >
    1311 const ast::Expr * ast::Pass< pass_t >::visit( const ast::TypeExpr * node ) {
     1310template< typename core_t >
     1311const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
    13121312        VISIT_START( node );
    13131313
    … …  
    13241324//--------------------------------------------------------------------------
    13251325// AsmExpr
    1326 template< typename pass_t >
    1327 const ast::Expr * ast::Pass< pass_t >::visit( const ast::AsmExpr * node ) {
     1326template< typename core_t >
     1327const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
    13281328        VISIT_START( node );
    13291329
    … …  
    13411341//--------------------------------------------------------------------------
    13421342// ImplicitCopyCtorExpr
    1343 template< typename pass_t >
    1344 const ast::Expr * ast::Pass< pass_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
     1343template< typename core_t >
     1344const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
    13451345        VISIT_START( node );
    13461346
    … …  
    13571357//--------------------------------------------------------------------------
    13581358// ConstructorExpr
    1359 template< typename pass_t >
    1360 const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstructorExpr * node ) {
     1359template< typename core_t >
     1360const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
    13611361        VISIT_START( node );
    13621362
    … …  
    13731373//--------------------------------------------------------------------------
    13741374// CompoundLiteralExpr
    1375 template< typename pass_t >
    1376 const ast::Expr * ast::Pass< pass_t >::visit( const ast::CompoundLiteralExpr * node ) {
     1375template< typename core_t >
     1376const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
    13771377        VISIT_START( node );
    13781378
    … …  
    13891389//--------------------------------------------------------------------------
    13901390// RangeExpr
    1391 template< typename pass_t >
    1392 const ast::Expr * ast::Pass< pass_t >::visit( const ast::RangeExpr * node ) {
     1391template< typename core_t >
     1392const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
    13931393        VISIT_START( node );
    13941394
    … …  
    14061406//--------------------------------------------------------------------------
    14071407// UntypedTupleExpr
    1408 template< typename pass_t >
    1409 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedTupleExpr * node ) {
     1408template< typename core_t >
     1409const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
    14101410        VISIT_START( node );
    14111411
    … …  
    14221422//--------------------------------------------------------------------------
    14231423// TupleExpr
    1424 template< typename pass_t >
    1425 const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleExpr * node ) {
     1424template< typename core_t >
     1425const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
    14261426        VISIT_START( node );
    14271427
    … …  
    14381438//--------------------------------------------------------------------------
    14391439// TupleIndexExpr
    1440 template< typename pass_t >
    1441 const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleIndexExpr * node ) {
     1440template< typename core_t >
     1441const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
    14421442        VISIT_START( node );
    14431443
    … …  
    14541454//--------------------------------------------------------------------------
    14551455// TupleAssignExpr
    1456 template< typename pass_t >
    1457 const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleAssignExpr * node ) {
     1456template< typename core_t >
     1457const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
    14581458        VISIT_START( node );
    14591459
    … …  
    14701470//--------------------------------------------------------------------------
    14711471// StmtExpr
    1472 template< typename pass_t >
    1473 const ast::Expr * ast::Pass< pass_t >::visit( const ast::StmtExpr * node ) {
     1472template< typename core_t >
     1473const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
    14741474        VISIT_START( node );
    14751475
    14761476        VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
    14771477                // get the stmts that will need to be spliced in
    1478                 auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
    1479                 auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
     1478                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     1479                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
    14801480
    14811481                // These may be modified by subnode but most be restored once we exit this statemnet.
    1482                 ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( pass, 0) );
     1482                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) );
    14831483                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
    14841484                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
    … …  
    14981498//--------------------------------------------------------------------------
    14991499// UniqueExpr
    1500 template< typename pass_t >
    1501 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UniqueExpr * node ) {
     1500template< typename core_t >
     1501const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
    15021502        VISIT_START( node );
    15031503
    … …  
    15141514//--------------------------------------------------------------------------
    15151515// UntypedInitExpr
    1516 template< typename pass_t >
    1517 const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedInitExpr * node ) {
     1516template< typename core_t >
     1517const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
    15181518        VISIT_START( node );
    15191519
    … …  
    15311531//--------------------------------------------------------------------------
    15321532// InitExpr
    1533 template< typename pass_t >
    1534 const ast::Expr * ast::Pass< pass_t >::visit( const ast::InitExpr * node ) {
     1533template< typename core_t >
     1534const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
    15351535        VISIT_START( node );
    15361536
    … …  
    15481548//--------------------------------------------------------------------------
    15491549// DeletedExpr
    1550 template< typename pass_t >
    1551 const ast::Expr * ast::Pass< pass_t >::visit( const ast::DeletedExpr * node ) {
     1550template< typename core_t >
     1551const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
    15521552        VISIT_START( node );
    15531553
    … …  
    15651565//--------------------------------------------------------------------------
    15661566// DefaultArgExpr
    1567 template< typename pass_t >
    1568 const ast::Expr * ast::Pass< pass_t >::visit( const ast::DefaultArgExpr * node ) {
     1567template< typename core_t >
     1568const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
    15691569        VISIT_START( node );
    15701570
    … …  
    15811581//--------------------------------------------------------------------------
    15821582// GenericExpr
    1583 template< typename pass_t >
    1584 const ast::Expr * ast::Pass< pass_t >::visit( const ast::GenericExpr * node ) {
     1583template< typename core_t >
     1584const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
    15851585        VISIT_START( node );
    15861586
    … …  
    16211621//--------------------------------------------------------------------------
    16221622// VoidType
    1623 template< typename pass_t >
    1624 const ast::Type * ast::Pass< pass_t >::visit( const ast::VoidType * node ) {
     1623template< typename core_t >
     1624const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
    16251625        VISIT_START( node );
    16261626
    … …  
    16301630//--------------------------------------------------------------------------
    16311631// BasicType
    1632 template< typename pass_t >
    1633 const ast::Type * ast::Pass< pass_t >::visit( const ast::BasicType * node ) {
     1632template< typename core_t >
     1633const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
    16341634        VISIT_START( node );
    16351635
    … …  
    16391639//--------------------------------------------------------------------------
    16401640// PointerType
    1641 template< typename pass_t >
    1642 const ast::Type * ast::Pass< pass_t >::visit( const ast::PointerType * node ) {
     1641template< typename core_t >
     1642const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
    16431643        VISIT_START( node );
    16441644
    … …  
    16531653//--------------------------------------------------------------------------
    16541654// ArrayType
    1655 template< typename pass_t >
    1656 const ast::Type * ast::Pass< pass_t >::visit( const ast::ArrayType * node ) {
     1655template< typename core_t >
     1656const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
    16571657        VISIT_START( node );
    16581658
    … …  
    16671667//--------------------------------------------------------------------------
    16681668// ReferenceType
    1669 template< typename pass_t >
    1670 const ast::Type * ast::Pass< pass_t >::visit( const ast::ReferenceType * node ) {
     1669template< typename core_t >
     1670const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
    16711671        VISIT_START( node );
    16721672
    … …  
    16801680//--------------------------------------------------------------------------
    16811681// QualifiedType
    1682 template< typename pass_t >
    1683 const ast::Type * ast::Pass< pass_t >::visit( const ast::QualifiedType * node ) {
     1682template< typename core_t >
     1683const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
    16841684        VISIT_START( node );
    16851685
    … …  
    16941694//--------------------------------------------------------------------------
    16951695// FunctionType
    1696 template< typename pass_t >
    1697 const ast::Type * ast::Pass< pass_t >::visit( const ast::FunctionType * node ) {
     1696template< typename core_t >
     1697const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
    16981698        VISIT_START( node );
    16991699
    … …  
    17101710//--------------------------------------------------------------------------
    17111711// StructInstType
    1712 template< typename pass_t >
    1713 const ast::Type * ast::Pass< pass_t >::visit( const ast::StructInstType * node ) {
    1714         VISIT_START( node );
    1715 
    1716         __pass::symtab::addStruct( pass, 0, node->name );
     1712template< typename core_t >
     1713const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
     1714        VISIT_START( node );
     1715
     1716        __pass::symtab::addStruct( core, 0, node->name );
    17171717
    17181718        VISIT({
    … …  
    17281728//--------------------------------------------------------------------------
    17291729// UnionInstType
    1730 template< typename pass_t >
    1731 const ast::Type * ast::Pass< pass_t >::visit( const ast::UnionInstType * node ) {
    1732         VISIT_START( node );
    1733 
    1734         __pass::symtab::addUnion( pass, 0, node->name );
     1730template< typename core_t >
     1731const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
     1732        VISIT_START( node );
     1733
     1734        __pass::symtab::addUnion( core, 0, node->name );
    17351735
    17361736        VISIT({
    … …  
    17461746//--------------------------------------------------------------------------
    17471747// EnumInstType
    1748 template< typename pass_t >
    1749 const ast::Type * ast::Pass< pass_t >::visit( const ast::EnumInstType * node ) {
     1748template< typename core_t >
     1749const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
    17501750        VISIT_START( node );
    17511751
    … …  
    17611761//--------------------------------------------------------------------------
    17621762// TraitInstType
    1763 template< typename pass_t >
    1764 const ast::Type * ast::Pass< pass_t >::visit( const ast::TraitInstType * node ) {
     1763template< typename core_t >
     1764const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
    17651765        VISIT_START( node );
    17661766
    … …  
    17761776//--------------------------------------------------------------------------
    17771777// TypeInstType
    1778 template< typename pass_t >
    1779 const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeInstType * node ) {
     1778template< typename core_t >
     1779const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
    17801780        VISIT_START( node );
    17811781
    … …  
    17871787                }
    17881788                // ensure that base re-bound if doing substitution
    1789                 __pass::forall::replace( pass, 0, node );
     1789                __pass::forall::replace( core, 0, node );
    17901790        )
    17911791
    … …  
    17951795//--------------------------------------------------------------------------
    17961796// TupleType
    1797 template< typename pass_t >
    1798 const ast::Type * ast::Pass< pass_t >::visit( const ast::TupleType * node ) {
     1797template< typename core_t >
     1798const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
    17991799        VISIT_START( node );
    18001800
    … …  
    18091809//--------------------------------------------------------------------------
    18101810// TypeofType
    1811 template< typename pass_t >
    1812 const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeofType * node ) {
     1811template< typename core_t >
     1812const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
    18131813        VISIT_START( node );
    18141814
    … …  
    18221822//--------------------------------------------------------------------------
    18231823// VarArgsType
    1824 template< typename pass_t >
    1825 const ast::Type * ast::Pass< pass_t >::visit( const ast::VarArgsType * node ) {
     1824template< typename core_t >
     1825const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
    18261826        VISIT_START( node );
    18271827
    … …  
    18311831//--------------------------------------------------------------------------
    18321832// ZeroType
    1833 template< typename pass_t >
    1834 const ast::Type * ast::Pass< pass_t >::visit( const ast::ZeroType * node ) {
     1833template< typename core_t >
     1834const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
    18351835        VISIT_START( node );
    18361836
    … …  
    18401840//--------------------------------------------------------------------------
    18411841// OneType
    1842 template< typename pass_t >
    1843 const ast::Type * ast::Pass< pass_t >::visit( const ast::OneType * node ) {
     1842template< typename core_t >
     1843const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
    18441844        VISIT_START( node );
    18451845
    … …  
    18491849//--------------------------------------------------------------------------
    18501850// GlobalScopeType
    1851 template< typename pass_t >
    1852 const ast::Type * ast::Pass< pass_t >::visit( const ast::GlobalScopeType * node ) {
     1851template< typename core_t >
     1852const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
    18531853        VISIT_START( node );
    18541854
    … …  
    18591859//--------------------------------------------------------------------------
    18601860// Designation
    1861 template< typename pass_t >
    1862 const ast::Designation * ast::Pass< pass_t >::visit( const ast::Designation * node ) {
     1861template< typename core_t >
     1862const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
    18631863        VISIT_START( node );
    18641864
    … …  
    18701870//--------------------------------------------------------------------------
    18711871// SingleInit
    1872 template< typename pass_t >
    1873 const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) {
     1872template< typename core_t >
     1873const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
    18741874        VISIT_START( node );
    18751875
    … …  
    18831883//--------------------------------------------------------------------------
    18841884// ListInit
    1885 template< typename pass_t >
    1886 const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) {
     1885template< typename core_t >
     1886const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
    18871887        VISIT_START( node );
    18881888
    … …  
    18971897//--------------------------------------------------------------------------
    18981898// ConstructorInit
    1899 template< typename pass_t >
    1900 const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) {
     1899template< typename core_t >
     1900const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
    19011901        VISIT_START( node );
    19021902
    … …  
    19121912//--------------------------------------------------------------------------
    19131913// Attribute
    1914 template< typename pass_t >
    1915 const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node  )  {
     1914template< typename core_t >
     1915const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node  )  {
    19161916        VISIT_START( node );
    19171917
    … …  
    19251925//--------------------------------------------------------------------------
    19261926// TypeSubstitution
    1927 template< typename pass_t >
    1928 const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) {
     1927template< typename core_t >
     1928const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
    19291929        VISIT_START( node );
    19301930
Note: See TracChangeset for help on using the changeset viewer.