Index: src/AST/Copy.hpp =================================================================== --- src/AST/Copy.hpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/Copy.hpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -121,5 +121,5 @@ Pass< DeepCopyCore > dc; node_t const * newRoot = localRoot->accept( dc ); - dc.pass.readonlyUpdates(); + dc.core.readonlyUpdates(); return const_cast< node_t * >( newRoot ); } Index: src/AST/GenericSubstitution.cpp =================================================================== --- src/AST/GenericSubstitution.cpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/GenericSubstitution.cpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -62,5 +62,5 @@ Pass builder; maybe_accept( ty, builder ); - return std::move(builder.pass.sub); + return std::move(builder.core.sub); } Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/Pass.hpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -66,18 +66,20 @@ // | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation //------------------------------------------------------------------------------------------------- -template< typename pass_t > +template< typename core_t > class Pass final : public ast::Visitor { public: + using core_type = core_t; + using type = Pass; + /// Forward any arguments to the pass constructor /// Propagate 'this' if necessary template< typename... Args > Pass( Args &&... args) - : pass( std::forward( args )... ) + : core( std::forward( args )... ) { // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor - typedef Pass this_t; - this_t * const * visitor = __pass::visitor(pass, 0); + type * const * visitor = __pass::visitor(core, 0); if(visitor) { - *const_cast( visitor ) = this; + *const_cast( visitor ) = this; } } @@ -88,10 +90,10 @@ template< typename... Args > static void run( std::list< ptr > & decls, Args &&... args ) { - Pass visitor( std::forward( args )... ); + Pass visitor( std::forward( args )... ); accept_all( decls, visitor ); } /// Storage for the actual pass - pass_t pass; + core_t core; /// Visit function declarations @@ -189,9 +191,9 @@ const ast::TypeSubstitution * visit( const ast::TypeSubstitution * ) override final; - template - friend void accept_all( std::list< ptr > & decls, Pass& visitor ); + template + friend void accept_all( std::list< ptr > & decls, Pass& visitor ); private: - bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; } + bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; } private: @@ -224,22 +226,22 @@ /// Internal RAII guard for symbol table features struct guard_symtab { - guard_symtab( Pass & pass ): pass( pass ) { __pass::symtab::enter(pass.pass, 0); } - ~guard_symtab() { __pass::symtab::leave(pass.pass, 0); } - Pass & pass; + guard_symtab( Pass & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); } + ~guard_symtab() { __pass::symtab::leave(pass.core, 0); } + Pass & pass; }; /// Internal RAII guard for scope features struct guard_scope { - guard_scope( Pass & pass ): pass( pass ) { __pass::scope::enter(pass.pass, 0); } - ~guard_scope() { __pass::scope::leave(pass.pass, 0); } - Pass & pass; + guard_scope( Pass & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); } + ~guard_scope() { __pass::scope::leave(pass.core, 0); } + Pass & pass; }; /// Internal RAII guard for forall substitutions struct guard_forall_subs { - guard_forall_subs( Pass & pass, const ParameterizedType * type ) - : pass( pass ), type( type ) { __pass::forall::enter(pass.pass, 0, type ); } - ~guard_forall_subs() { __pass::forall::leave(pass.pass, 0, type ); } - Pass & pass; + guard_forall_subs( Pass & pass, const ParameterizedType * type ) + : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); } + ~guard_forall_subs() { __pass::forall::leave(pass.core, 0, type ); } + Pass & pass; const ParameterizedType * type; }; @@ -250,6 +252,6 @@ /// Apply a pass to an entire translation unit -template -void accept_all( std::list< ast::ptr > &, ast::Pass & visitor ); +template +void accept_all( std::list< ast::ptr > &, ast::Pass & visitor ); //------------------------------------------------------------------------------------------------- @@ -291,6 +293,6 @@ }; - template< typename pass_t> - friend auto __pass::at_cleanup( pass_t & pass, int ) -> decltype( &pass.at_cleanup ); + template< typename core_t> + friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup ); public: @@ -328,7 +330,7 @@ /// Used to get a pointer to the pass with its wrapped type -template +template struct WithVisitorRef { - Pass * const visitor = nullptr; + Pass * const visitor = nullptr; }; Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/Pass.impl.hpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -25,11 +25,11 @@ using namespace ast; \ /* back-up the visit children */ \ - __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(pass, 0) ); \ + __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \ /* setup the scope for passes that want to run code at exit */ \ - __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (pass, 0) ); \ + __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \ /* begin tracing memory allocation if requested by this pass */ \ - __pass::beginTrace( pass, 0 ); \ + __pass::beginTrace( core, 0 ); \ /* call the implementation of the previsit of this pass */ \ - __pass::previsit( pass, node, 0 ); + __pass::previsit( core, node, 0 ); #define VISIT( code... ) \ @@ -42,8 +42,8 @@ #define VISIT_END( type, node ) \ /* call the implementation of the postvisit of this pass */ \ - auto __return = __pass::postvisit( pass, node, 0 ); \ + auto __return = __pass::postvisit( core, node, 0 ); \ assertf(__return, "post visit should never return null"); \ /* end tracing memory allocation if requested by this pass */ \ - __pass::endTrace( pass, 0 ); \ + __pass::endTrace( core, 0 ); \ return __return; @@ -123,7 +123,7 @@ } - template< typename pass_t > + template< typename core_t > template< typename node_t > - auto ast::Pass< pass_t >::call_accept( const node_t * node ) + auto ast::Pass< core_t >::call_accept( const node_t * node ) -> typename std::enable_if< !std::is_base_of::value && @@ -141,10 +141,10 @@ } - template< typename pass_t > - const ast::Expr * ast::Pass< pass_t >::call_accept( const ast::Expr * expr ) { + template< typename core_t > + const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( expr ); - const ast::TypeSubstitution ** env_ptr = __pass::env( pass, 0); + const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0); if ( env_ptr && expr->env ) { *env_ptr = expr->env; @@ -154,6 +154,6 @@ } - template< typename pass_t > - const ast::Stmt * ast::Pass< pass_t >::call_accept( const ast::Stmt * stmt ) { + template< typename core_t > + const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( stmt ); @@ -163,11 +163,11 @@ // get the stmts/decls that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); - auto decls_before = __pass::declsToAddBefore( pass, 0); - auto decls_after = __pass::declsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); + auto decls_before = __pass::declsToAddBefore( core, 0); + auto decls_after = __pass::declsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. - ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::env( pass, 0) ); + ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::env( core, 0) ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after ); @@ -205,7 +205,7 @@ } - template< typename pass_t > + template< typename core_t > template< template class container_t > - container_t< ptr > ast::Pass< pass_t >::call_accept( const container_t< ptr > & statements ) { + container_t< ptr > ast::Pass< core_t >::call_accept( const container_t< ptr > & statements ) { __pedantic_pass_assert( __visit_children() ); if( statements.empty() ) return {}; @@ -218,8 +218,8 @@ // get the stmts/decls that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); - auto decls_before = __pass::declsToAddBefore( pass, 0); - auto decls_after = __pass::declsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); + auto decls_before = __pass::declsToAddBefore( core, 0); + auto decls_after = __pass::declsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. @@ -271,7 +271,7 @@ } - template< typename pass_t > + template< typename core_t > template< template class container_t, typename node_t > - container_t< ast::ptr > ast::Pass< pass_t >::call_accept( const container_t< ast::ptr > & container ) { + container_t< ast::ptr > ast::Pass< core_t >::call_accept( const container_t< ast::ptr > & container ) { __pedantic_pass_assert( __visit_children() ); if( container.empty() ) return {}; @@ -302,7 +302,7 @@ } - template< typename pass_t > + template< typename core_t > template - void ast::Pass< pass_t >::maybe_accept( + void ast::Pass< core_t >::maybe_accept( const node_t * & parent, child_t parent_t::*child @@ -327,8 +327,8 @@ - template< typename pass_t > + template< typename core_t > template< typename node_t > - void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) { - if ( auto subs = __pass::forall::subs( pass, 0 ) ) { + void ast::Pass< core_t >::mutate_forall( const node_t *& node ) { + if ( auto subs = __pass::forall::subs( core, 0 ) ) { // tracking TypeDecl substitution, full clone if ( node->forall.empty() ) return; @@ -352,6 +352,6 @@ //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -template< typename pass_t > -inline void ast::accept_all( std::list< ast::ptr > & decls, ast::Pass< pass_t > & visitor ) { +template< typename core_t > +inline void ast::accept_all( std::list< ast::ptr > & decls, ast::Pass< core_t > & visitor ) { // We are going to aggregate errors for all these statements SemanticErrorException errors; @@ -361,6 +361,6 @@ // get the stmts/decls that will need to be spliced in - auto decls_before = __pass::declsToAddBefore( visitor.pass, 0); - auto decls_after = __pass::declsToAddAfter ( visitor.pass, 0); + auto decls_before = __pass::declsToAddBefore( visitor.core, 0); + auto decls_after = __pass::declsToAddAfter ( visitor.core, 0); // update pass statitistics @@ -411,6 +411,6 @@ //-------------------------------------------------------------------------- // ObjectDecl -template< typename pass_t > -const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) { +template< typename core_t > +const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) { VISIT_START( node ); @@ -425,5 +425,5 @@ ) - __pass::symtab::addId( pass, 0, node ); + __pass::symtab::addId( core, 0, node ); VISIT_END( DeclWithType, node ); @@ -432,9 +432,9 @@ //-------------------------------------------------------------------------- // FunctionDecl -template< typename pass_t > -const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::FunctionDecl * node ) { - VISIT_START( node ); - - __pass::symtab::addId( pass, 0, node ); +template< typename core_t > +const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) { + VISIT_START( node ); + + __pass::symtab::addId( core, 0, node ); VISIT(maybe_accept( node, &FunctionDecl::withExprs );) @@ -444,5 +444,5 @@ // shadow with exprs and not the other way around. guard_symtab guard { *this }; - __pass::symtab::addWith( pass, 0, node->withExprs, node ); + __pass::symtab::addWith( core, 0, node->withExprs, node ); { guard_symtab guard { *this }; @@ -455,5 +455,5 @@ } } }; - __pass::symtab::addId( pass, 0, func ); + __pass::symtab::addId( core, 0, func ); VISIT( maybe_accept( node, &FunctionDecl::type ); @@ -473,11 +473,11 @@ //-------------------------------------------------------------------------- // StructDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::StructDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) { VISIT_START( node ); // make up a forward declaration and add it before processing the members // needs to be on the heap because addStruct saves the pointer - __pass::symtab::addStructFwd( pass, 0, node ); + __pass::symtab::addStructFwd( core, 0, node ); VISIT({ @@ -488,5 +488,5 @@ // this addition replaces the forward declaration - __pass::symtab::addStruct( pass, 0, node ); + __pass::symtab::addStruct( core, 0, node ); VISIT_END( Decl, node ); @@ -495,10 +495,10 @@ //-------------------------------------------------------------------------- // UnionDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::UnionDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) { VISIT_START( node ); // make up a forward declaration and add it before processing the members - __pass::symtab::addUnionFwd( pass, 0, node ); + __pass::symtab::addUnionFwd( core, 0, node ); VISIT({ @@ -508,5 +508,5 @@ }) - __pass::symtab::addUnion( pass, 0, node ); + __pass::symtab::addUnion( core, 0, node ); VISIT_END( Decl, node ); @@ -515,9 +515,9 @@ //-------------------------------------------------------------------------- // EnumDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::EnumDecl * node ) { - VISIT_START( node ); - - __pass::symtab::addEnum( pass, 0, node ); +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) { + VISIT_START( node ); + + __pass::symtab::addEnum( core, 0, node ); VISIT( @@ -532,6 +532,6 @@ //-------------------------------------------------------------------------- // TraitDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TraitDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) { VISIT_START( node ); @@ -542,5 +542,5 @@ }) - __pass::symtab::addTrait( pass, 0, node ); + __pass::symtab::addTrait( core, 0, node ); VISIT_END( Decl, node ); @@ -549,6 +549,6 @@ //-------------------------------------------------------------------------- // TypeDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypeDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) { VISIT_START( node ); @@ -562,5 +562,5 @@ // note that assertions come after the type is added to the symtab, since they are not part of the type proper // and may depend on the type itself - __pass::symtab::addType( pass, 0, node ); + __pass::symtab::addType( core, 0, node ); VISIT( @@ -578,6 +578,6 @@ //-------------------------------------------------------------------------- // TypedefDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypedefDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) { VISIT_START( node ); @@ -588,5 +588,5 @@ }) - __pass::symtab::addType( pass, 0, node ); + __pass::symtab::addType( core, 0, node ); VISIT( maybe_accept( node, &TypedefDecl::assertions ); ) @@ -597,6 +597,6 @@ //-------------------------------------------------------------------------- // AsmDecl -template< typename pass_t > -const ast::AsmDecl * ast::Pass< pass_t >::visit( const ast::AsmDecl * node ) { +template< typename core_t > +const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) { VISIT_START( node ); @@ -610,6 +610,6 @@ //-------------------------------------------------------------------------- // StaticAssertDecl -template< typename pass_t > -const ast::StaticAssertDecl * ast::Pass< pass_t >::visit( const ast::StaticAssertDecl * node ) { +template< typename core_t > +const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) { VISIT_START( node ); @@ -624,13 +624,13 @@ //-------------------------------------------------------------------------- // CompoundStmt -template< typename pass_t > -const ast::CompoundStmt * ast::Pass< pass_t >::visit( const ast::CompoundStmt * node ) { +template< typename core_t > +const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) { VISIT_START( node ); VISIT({ // do not enter a new scope if inFunction is true - needs to check old state before the assignment auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() { - if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0); + if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0); }, [this, inFunctionCpy = this->inFunction]() { - if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0); + if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0); }); ValueGuard< bool > guard2( inFunction ); @@ -644,6 +644,6 @@ //-------------------------------------------------------------------------- // ExprStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ExprStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) { VISIT_START( node ); @@ -657,6 +657,6 @@ //-------------------------------------------------------------------------- // AsmStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) { VISIT_START( node ) @@ -673,6 +673,6 @@ //-------------------------------------------------------------------------- // DirectiveStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) { VISIT_START( node ) @@ -682,6 +682,6 @@ //-------------------------------------------------------------------------- // IfStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) { VISIT_START( node ); @@ -700,6 +700,6 @@ //-------------------------------------------------------------------------- // WhileStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WhileStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) { VISIT_START( node ); @@ -717,6 +717,6 @@ //-------------------------------------------------------------------------- // ForStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) { VISIT_START( node ); @@ -735,6 +735,6 @@ //-------------------------------------------------------------------------- // SwitchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) { VISIT_START( node ); @@ -749,6 +749,6 @@ //-------------------------------------------------------------------------- // CaseStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) { VISIT_START( node ); @@ -763,6 +763,6 @@ //-------------------------------------------------------------------------- // BranchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) { VISIT_START( node ); VISIT_END( Stmt, node ); @@ -771,6 +771,6 @@ //-------------------------------------------------------------------------- // ReturnStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) { VISIT_START( node ); @@ -784,6 +784,6 @@ //-------------------------------------------------------------------------- // ThrowStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) { VISIT_START( node ); @@ -798,6 +798,6 @@ //-------------------------------------------------------------------------- // TryStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) { VISIT_START( node ); @@ -813,6 +813,6 @@ //-------------------------------------------------------------------------- // CatchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CatchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) { VISIT_START( node ); @@ -830,6 +830,6 @@ //-------------------------------------------------------------------------- // FinallyStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::FinallyStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) { VISIT_START( node ); @@ -843,6 +843,6 @@ //-------------------------------------------------------------------------- // FinallyStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) { VISIT_START( node ); @@ -856,6 +856,6 @@ //-------------------------------------------------------------------------- // WaitForStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WaitForStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) { VISIT_START( node ); // for( auto & clause : node->clauses ) { @@ -925,6 +925,6 @@ //-------------------------------------------------------------------------- // WithStmt -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::WithStmt * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) { VISIT_START( node ); @@ -934,5 +934,5 @@ // catch statements introduce a level of scope (for the caught exception) guard_symtab guard { *this }; - __pass::symtab::addWith( pass, 0, node->exprs, node ); + __pass::symtab::addWith( core, 0, node->exprs, node ); maybe_accept( node, &WithStmt::stmt ); } @@ -943,6 +943,6 @@ //-------------------------------------------------------------------------- // NullStmt -template< typename pass_t > -const ast::NullStmt * ast::Pass< pass_t >::visit( const ast::NullStmt * node ) { +template< typename core_t > +const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) { VISIT_START( node ); VISIT_END( NullStmt, node ); @@ -951,6 +951,6 @@ //-------------------------------------------------------------------------- // DeclStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DeclStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) { VISIT_START( node ); @@ -964,6 +964,6 @@ //-------------------------------------------------------------------------- // ImplicitCtorDtorStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ImplicitCtorDtorStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) { VISIT_START( node ); @@ -979,6 +979,6 @@ //-------------------------------------------------------------------------- // ApplicationExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ApplicationExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) { VISIT_START( node ); @@ -997,6 +997,6 @@ //-------------------------------------------------------------------------- // UntypedExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) { VISIT_START( node ); @@ -1015,6 +1015,6 @@ //-------------------------------------------------------------------------- // NameExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::NameExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) { VISIT_START( node ); @@ -1029,6 +1029,6 @@ //-------------------------------------------------------------------------- // CastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) { VISIT_START( node ); @@ -1045,6 +1045,6 @@ //-------------------------------------------------------------------------- // KeywordCastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::KeywordCastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) { VISIT_START( node ); @@ -1061,6 +1061,6 @@ //-------------------------------------------------------------------------- // VirtualCastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::VirtualCastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) { VISIT_START( node ); @@ -1077,6 +1077,6 @@ //-------------------------------------------------------------------------- // AddressExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AddressExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) { VISIT_START( node ); @@ -1093,6 +1093,6 @@ //-------------------------------------------------------------------------- // LabelAddressExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::LabelAddressExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) { VISIT_START( node ); @@ -1107,6 +1107,6 @@ //-------------------------------------------------------------------------- // UntypedMemberExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedMemberExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) { VISIT_START( node ); @@ -1124,6 +1124,6 @@ //-------------------------------------------------------------------------- // MemberExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::MemberExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) { VISIT_START( node ); @@ -1140,6 +1140,6 @@ //-------------------------------------------------------------------------- // VariableExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::VariableExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) { VISIT_START( node ); @@ -1154,6 +1154,6 @@ //-------------------------------------------------------------------------- // ConstantExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstantExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) { VISIT_START( node ); @@ -1168,6 +1168,6 @@ //-------------------------------------------------------------------------- // SizeofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::SizeofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) { VISIT_START( node ); @@ -1188,6 +1188,6 @@ //-------------------------------------------------------------------------- // AlignofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AlignofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) { VISIT_START( node ); @@ -1208,6 +1208,6 @@ //-------------------------------------------------------------------------- // UntypedOffsetofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedOffsetofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) { VISIT_START( node ); @@ -1224,6 +1224,6 @@ //-------------------------------------------------------------------------- // OffsetofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) { VISIT_START( node ); @@ -1240,6 +1240,6 @@ //-------------------------------------------------------------------------- // OffsetPackExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetPackExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) { VISIT_START( node ); @@ -1256,6 +1256,6 @@ //-------------------------------------------------------------------------- // LogicalExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::LogicalExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) { VISIT_START( node ); @@ -1273,6 +1273,6 @@ //-------------------------------------------------------------------------- // ConditionalExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConditionalExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) { VISIT_START( node ); @@ -1291,6 +1291,6 @@ //-------------------------------------------------------------------------- // CommaExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CommaExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) { VISIT_START( node ); @@ -1308,6 +1308,6 @@ //-------------------------------------------------------------------------- // TypeExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TypeExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) { VISIT_START( node ); @@ -1324,6 +1324,6 @@ //-------------------------------------------------------------------------- // AsmExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AsmExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) { VISIT_START( node ); @@ -1341,6 +1341,6 @@ //-------------------------------------------------------------------------- // ImplicitCopyCtorExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ImplicitCopyCtorExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) { VISIT_START( node ); @@ -1357,6 +1357,6 @@ //-------------------------------------------------------------------------- // ConstructorExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstructorExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) { VISIT_START( node ); @@ -1373,6 +1373,6 @@ //-------------------------------------------------------------------------- // CompoundLiteralExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CompoundLiteralExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) { VISIT_START( node ); @@ -1389,6 +1389,6 @@ //-------------------------------------------------------------------------- // RangeExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::RangeExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) { VISIT_START( node ); @@ -1406,6 +1406,6 @@ //-------------------------------------------------------------------------- // UntypedTupleExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedTupleExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) { VISIT_START( node ); @@ -1422,6 +1422,6 @@ //-------------------------------------------------------------------------- // TupleExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) { VISIT_START( node ); @@ -1438,6 +1438,6 @@ //-------------------------------------------------------------------------- // TupleIndexExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleIndexExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) { VISIT_START( node ); @@ -1454,6 +1454,6 @@ //-------------------------------------------------------------------------- // TupleAssignExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleAssignExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) { VISIT_START( node ); @@ -1470,15 +1470,15 @@ //-------------------------------------------------------------------------- // StmtExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::StmtExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) { VISIT_START( node ); VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr // get the stmts that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. - ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( pass, 0) ); + ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after ); @@ -1498,6 +1498,6 @@ //-------------------------------------------------------------------------- // UniqueExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UniqueExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) { VISIT_START( node ); @@ -1514,6 +1514,6 @@ //-------------------------------------------------------------------------- // UntypedInitExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedInitExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) { VISIT_START( node ); @@ -1531,6 +1531,6 @@ //-------------------------------------------------------------------------- // InitExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::InitExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) { VISIT_START( node ); @@ -1548,6 +1548,6 @@ //-------------------------------------------------------------------------- // DeletedExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::DeletedExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) { VISIT_START( node ); @@ -1565,6 +1565,6 @@ //-------------------------------------------------------------------------- // DefaultArgExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::DefaultArgExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) { VISIT_START( node ); @@ -1581,6 +1581,6 @@ //-------------------------------------------------------------------------- // GenericExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::GenericExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) { VISIT_START( node ); @@ -1621,6 +1621,6 @@ //-------------------------------------------------------------------------- // VoidType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::VoidType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) { VISIT_START( node ); @@ -1630,6 +1630,6 @@ //-------------------------------------------------------------------------- // BasicType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::BasicType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) { VISIT_START( node ); @@ -1639,6 +1639,6 @@ //-------------------------------------------------------------------------- // PointerType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::PointerType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) { VISIT_START( node ); @@ -1653,6 +1653,6 @@ //-------------------------------------------------------------------------- // ArrayType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ArrayType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) { VISIT_START( node ); @@ -1667,6 +1667,6 @@ //-------------------------------------------------------------------------- // ReferenceType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ReferenceType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) { VISIT_START( node ); @@ -1680,6 +1680,6 @@ //-------------------------------------------------------------------------- // QualifiedType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::QualifiedType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) { VISIT_START( node ); @@ -1694,6 +1694,6 @@ //-------------------------------------------------------------------------- // FunctionType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::FunctionType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) { VISIT_START( node ); @@ -1710,9 +1710,9 @@ //-------------------------------------------------------------------------- // StructInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::StructInstType * node ) { - VISIT_START( node ); - - __pass::symtab::addStruct( pass, 0, node->name ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) { + VISIT_START( node ); + + __pass::symtab::addStruct( core, 0, node->name ); VISIT({ @@ -1728,9 +1728,9 @@ //-------------------------------------------------------------------------- // UnionInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::UnionInstType * node ) { - VISIT_START( node ); - - __pass::symtab::addUnion( pass, 0, node->name ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) { + VISIT_START( node ); + + __pass::symtab::addUnion( core, 0, node->name ); VISIT({ @@ -1746,6 +1746,6 @@ //-------------------------------------------------------------------------- // EnumInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::EnumInstType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) { VISIT_START( node ); @@ -1761,6 +1761,6 @@ //-------------------------------------------------------------------------- // TraitInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TraitInstType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) { VISIT_START( node ); @@ -1776,6 +1776,6 @@ //-------------------------------------------------------------------------- // TypeInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeInstType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) { VISIT_START( node ); @@ -1787,5 +1787,5 @@ } // ensure that base re-bound if doing substitution - __pass::forall::replace( pass, 0, node ); + __pass::forall::replace( core, 0, node ); ) @@ -1795,6 +1795,6 @@ //-------------------------------------------------------------------------- // TupleType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TupleType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) { VISIT_START( node ); @@ -1809,6 +1809,6 @@ //-------------------------------------------------------------------------- // TypeofType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeofType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) { VISIT_START( node ); @@ -1822,6 +1822,6 @@ //-------------------------------------------------------------------------- // VarArgsType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::VarArgsType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) { VISIT_START( node ); @@ -1831,6 +1831,6 @@ //-------------------------------------------------------------------------- // ZeroType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ZeroType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) { VISIT_START( node ); @@ -1840,6 +1840,6 @@ //-------------------------------------------------------------------------- // OneType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::OneType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) { VISIT_START( node ); @@ -1849,6 +1849,6 @@ //-------------------------------------------------------------------------- // GlobalScopeType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::GlobalScopeType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) { VISIT_START( node ); @@ -1859,6 +1859,6 @@ //-------------------------------------------------------------------------- // Designation -template< typename pass_t > -const ast::Designation * ast::Pass< pass_t >::visit( const ast::Designation * node ) { +template< typename core_t > +const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) { VISIT_START( node ); @@ -1870,6 +1870,6 @@ //-------------------------------------------------------------------------- // SingleInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) { VISIT_START( node ); @@ -1883,6 +1883,6 @@ //-------------------------------------------------------------------------- // ListInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) { VISIT_START( node ); @@ -1897,6 +1897,6 @@ //-------------------------------------------------------------------------- // ConstructorInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) { VISIT_START( node ); @@ -1912,6 +1912,6 @@ //-------------------------------------------------------------------------- // Attribute -template< typename pass_t > -const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node ) { +template< typename core_t > +const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) { VISIT_START( node ); @@ -1925,6 +1925,6 @@ //-------------------------------------------------------------------------- // TypeSubstitution -template< typename pass_t > -const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) { +template< typename core_t > +const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) { VISIT_START( node ); Index: src/AST/Pass.proto.hpp =================================================================== --- src/AST/Pass.proto.hpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/Pass.proto.hpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -20,5 +20,5 @@ namespace ast { -template +template class Pass; @@ -113,7 +113,7 @@ /// "Short hand" to check if this is a valid previsit function /// Mostly used to make the static_assert look (and print) prettier - template + template struct is_valid_previsit { - using ret_t = decltype( ((pass_t*)nullptr)->previsit( (const node_t *)nullptr ) ); + using ret_t = decltype( ((core_t*)nullptr)->previsit( (const node_t *)nullptr ) ); static constexpr bool value = std::is_void< ret_t >::value || @@ -129,7 +129,7 @@ template<> struct __assign { - template - static inline void result( pass_t & pass, const node_t * & node ) { - pass.previsit( node ); + template + static inline void result( core_t & core, const node_t * & node ) { + core.previsit( node ); } }; @@ -137,7 +137,7 @@ template<> struct __assign { - template - static inline void result( pass_t & pass, const node_t * & node ) { - node = pass.previsit( node ); + template + static inline void result( core_t & core, const node_t * & node ) { + node = core.previsit( node ); assertf(node, "Previsit must not return NULL"); } @@ -152,7 +152,7 @@ template<> struct __return { - template - static inline const node_t * result( pass_t & pass, const node_t * & node ) { - pass.postvisit( node ); + template + static inline const node_t * result( core_t & core, const node_t * & node ) { + core.postvisit( node ); return node; } @@ -161,7 +161,7 @@ template<> struct __return { - template - static inline auto result( pass_t & pass, const node_t * & node ) { - return pass.postvisit( node ); + template + static inline auto result( core_t & core, const node_t * & node ) { + return core.postvisit( node ); } }; @@ -182,8 +182,8 @@ //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call - template - static inline auto previsit( pass_t & pass, const node_t * & node, int ) -> decltype( pass.previsit( node ), void() ) { + template + static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) { static_assert( - is_valid_previsit::value, + is_valid_previsit::value, "Previsit may not change the type of the node. It must return its paremeter or void." ); @@ -191,26 +191,26 @@ __assign< std::is_void< - decltype( pass.previsit( node ) ) + decltype( core.previsit( node ) ) >::value - >::result( pass, node ); + >::result( core, node ); } - template - static inline auto previsit( pass_t &, const node_t *, long ) {} + template + static inline auto previsit( core_t &, const node_t *, long ) {} // PostVisit : never mutates the passed pointer but may return a different node - template - static inline auto postvisit( pass_t & pass, const node_t * node, int ) -> - decltype( pass.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) + template + static inline auto postvisit( core_t & core, const node_t * node, int ) -> + decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) { return __return< std::is_void< - decltype( pass.postvisit( node ) ) + decltype( core.postvisit( node ) ) >::value - >::result( pass, node ); + >::result( core, node ); } - template - static inline const node_t * postvisit( pass_t &, const node_t * node, long ) { return node; } + template + static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; } //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -227,9 +227,9 @@ // The type is not strictly enforced but does match the accessory #define FIELD_PTR( name, default_type ) \ - template< typename pass_t > \ - static inline auto name( pass_t & pass, int ) -> decltype( &pass.name ) { return &pass.name; } \ + template< typename core_t > \ + static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \ \ - template< typename pass_t > \ - static inline default_type * name( pass_t &, long ) { return nullptr; } + template< typename core_t > \ + static inline default_type * name( core_t &, long ) { return nullptr; } // List of fields and their expected types @@ -241,24 +241,24 @@ FIELD_PTR( visit_children, __pass::bool_ref ) FIELD_PTR( at_cleanup, __pass::at_cleanup_t ) - FIELD_PTR( visitor, ast::Pass * const ) + FIELD_PTR( visitor, ast::Pass * const ) // Remove the macro to make sure we don't clash #undef FIELD_PTR - template< typename pass_t > - static inline auto beginTrace(pass_t &, int) -> decltype( pass_t::traceId, void() ) { - // Stats::Heap::stacktrace_push(pass_t::traceId); + template< typename core_t > + static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { + // Stats::Heap::stacktrace_push(core_t::traceId); } - template< typename pass_t > - static inline auto endTrace(pass_t &, int) -> decltype( pass_t::traceId, void() ) { + template< typename core_t > + static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { // Stats::Heap::stacktrace_pop(); } - template< typename pass_t > - static void beginTrace(pass_t &, long) {} - - template< typename pass_t > - static void endTrace(pass_t &, long) {} + template< typename core_t > + static void beginTrace(core_t &, long) {} + + template< typename core_t > + static void endTrace(core_t &, long) {} // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement. @@ -266,19 +266,19 @@ // detect it using the same strategy namespace scope { - template - static inline auto enter( pass_t & pass, int ) -> decltype( pass.beginScope(), void() ) { - pass.beginScope(); - } - - template - static inline void enter( pass_t &, long ) {} - - template - static inline auto leave( pass_t & pass, int ) -> decltype( pass.endScope(), void() ) { - pass.endScope(); - } - - template - static inline void leave( pass_t &, long ) {} + template + static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) { + core.beginScope(); + } + + template + static inline void enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) { + core.endScope(); + } + + template + static inline void leave( core_t &, long ) {} } // namespace scope @@ -287,39 +287,39 @@ namespace symtab { // Some simple scoping rules - template - static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab, void() ) { - pass.symtab.enterScope(); - } - - template - static inline auto enter( pass_t &, long ) {} - - template - static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab, void() ) { - pass.symtab.leaveScope(); - } - - template - static inline auto leave( pass_t &, long ) {} + template + static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.enterScope(); + } + + template + static inline auto enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.leaveScope(); + } + + template + static inline auto leave( core_t &, long ) {} // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments // Create macro to condense these common patterns #define SYMTAB_FUNC1( func, type ) \ - template \ - static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\ - pass.symtab.func( arg ); \ + template \ + static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\ + core.symtab.func( arg ); \ } \ \ - template \ - static inline void func( pass_t &, long, type ) {} + template \ + static inline void func( core_t &, long, type ) {} #define SYMTAB_FUNC2( func, type1, type2 ) \ - template \ - static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\ - pass.symtab.func( arg1, arg2 ); \ + template \ + static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\ + core.symtab.func( arg1, arg2 ); \ } \ \ - template \ - static inline void func( pass_t &, long, type1, type2 ) {} + template \ + static inline void func( core_t &, long, type1, type2 ) {} SYMTAB_FUNC1( addId , const DeclWithType * ); @@ -332,43 +332,43 @@ // A few extra functions have more complicated behaviour, they are hand written - template - static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) { + template + static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) { ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name ); fwd->params = decl->params; - pass.symtab.addStruct( fwd ); - } - - template - static inline void addStructFwd( pass_t &, long, const ast::StructDecl * ) {} - - template - static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) { + core.symtab.addStruct( fwd ); + } + + template + static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {} + + template + static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) { UnionDecl * fwd = new UnionDecl( decl->location, decl->name ); fwd->params = decl->params; - pass.symtab.addUnion( fwd ); - } - - template - static inline void addUnionFwd( pass_t &, long, const ast::UnionDecl * ) {} - - template - static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) { - if ( ! pass.symtab.lookupStruct( str ) ) { - pass.symtab.addStruct( str ); + core.symtab.addUnion( fwd ); + } + + template + static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {} + + template + static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) { + if ( ! core.symtab.lookupStruct( str ) ) { + core.symtab.addStruct( str ); } } - template - static inline void addStruct( pass_t &, long, const std::string & ) {} - - template - static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) { - if ( ! pass.symtab.lookupUnion( str ) ) { - pass.symtab.addUnion( str ); + template + static inline void addStruct( core_t &, long, const std::string & ) {} + + template + static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) { + if ( ! core.symtab.lookupUnion( str ) ) { + core.symtab.addUnion( str ); } } - template - static inline void addUnion( pass_t &, long, const std::string & ) {} + template + static inline void addUnion( core_t &, long, const std::string & ) {} #undef SYMTAB_FUNC1 @@ -380,41 +380,41 @@ namespace forall { // Some simple scoping rules - template - static inline auto enter( pass_t & pass, int, const ast::ParameterizedType * type ) - -> decltype( pass.subs, void() ) { - if ( ! type->forall.empty() ) pass.subs.beginScope(); - } - - template - static inline auto enter( pass_t &, long, const ast::ParameterizedType * ) {} - - template - static inline auto leave( pass_t & pass, int, const ast::ParameterizedType * type ) - -> decltype( pass.subs, void() ) { - if ( ! type->forall.empty() ) { pass.subs.endScope(); } - } - - template - static inline auto leave( pass_t &, long, const ast::ParameterizedType * ) {} + template + static inline auto enter( core_t & core, int, const ast::ParameterizedType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) core.subs.beginScope(); + } + + template + static inline auto enter( core_t &, long, const ast::ParameterizedType * ) {} + + template + static inline auto leave( core_t & core, int, const ast::ParameterizedType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) { core.subs.endScope(); } + } + + template + static inline auto leave( core_t &, long, const ast::ParameterizedType * ) {} // Get the substitution table, if present - template - static inline auto subs( pass_t & pass, int ) -> decltype( &pass.subs ) { - return &pass.subs; - } - - template - static inline ast::ForallSubstitutionTable * subs( pass_t &, long ) { return nullptr; } + template + static inline auto subs( core_t & core, int ) -> decltype( &core.subs ) { + return &core.subs; + } + + template + static inline ast::ForallSubstitutionTable * subs( core_t &, long ) { return nullptr; } // Replaces a TypeInstType's base TypeDecl according to the table - template - static inline auto replace( pass_t & pass, int, const ast::TypeInstType *& inst ) - -> decltype( pass.subs, void() ) { + template + static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst ) + -> decltype( core.subs, void() ) { inst = ast::mutate_field( - inst, &ast::TypeInstType::base, pass.subs.replace( inst->base ) ); - } - - template - static inline auto replace( pass_t &, long, const ast::TypeInstType *& ) {} + inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) ); + } + + template + static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {} } // namespace forall Index: src/AST/Type.cpp =================================================================== --- src/AST/Type.cpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/Type.cpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -94,8 +94,8 @@ // --- ParameterizedType -void ParameterizedType::initWithSub( - const ParameterizedType & o, Pass< ForallSubstitutor > & sub +void ParameterizedType::initWithSub( + const ParameterizedType & o, Pass< ForallSubstitutor > & sub ) { - forall = sub.pass( o.forall ); + forall = sub.core( o.forall ); } @@ -103,10 +103,10 @@ FunctionType::FunctionType( const FunctionType & o ) -: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), +: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), isVarArgs( o.isVarArgs ) { Pass< ForallSubstitutor > sub; initWithSub( o, sub ); // initialize substitution map - returns = sub.pass( o.returns ); // apply to return and parameter types - params = sub.pass( o.params ); + returns = sub.core( o.returns ); // apply to return and parameter types + params = sub.core( o.params ); } @@ -128,5 +128,5 @@ void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) { ParameterizedType::initWithSub( o, sub ); // initialize substitution - params = sub.pass( o.params ); // apply to parameters + params = sub.core( o.params ); // apply to parameters } @@ -166,5 +166,5 @@ // --- TraitInstType -TraitInstType::TraitInstType( +TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q, std::vector>&& as ) : ReferenceToType( b->name, q, move(as) ), base( b ) {} @@ -172,9 +172,9 @@ // --- TypeInstType -TypeInstType::TypeInstType( const TypeInstType & o ) +TypeInstType::TypeInstType( const TypeInstType & o ) : ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) { Pass< ForallSubstitutor > sub; initWithSub( o, sub ); // initialize substitution - base = sub.pass( o.base ); // apply to base type + base = sub.core( o.base ); // apply to base type } Index: src/AST/TypeEnvironment.cpp =================================================================== --- src/AST/TypeEnvironment.cpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/TypeEnvironment.cpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -59,5 +59,5 @@ std::copy( clz.vars.begin(), clz.vars.end(), std::ostream_iterator< std::string >( out, " " ) ); out << ")"; - + if ( clz.bound ) { out << " -> "; @@ -92,5 +92,5 @@ } } - + i = next; // go to next node even if this removed } @@ -161,9 +161,9 @@ Pass occur{ var, env }; maybe_accept( ty, occur ); - return occur.pass.result; - } -} - -bool TypeEnvironment::combine( + return occur.core.result; + } +} + +bool TypeEnvironment::combine( const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) { // short-circuit easy cases @@ -199,5 +199,5 @@ auto st = internal_lookup( *vt ); if ( st == env.end() ) { - // unbound, safe to add if occurs + // unbound, safe to add if occurs if ( r.bound && occurs( r.bound, *vt, *this ) ) return false; r.vars.emplace( *vt ); @@ -266,8 +266,8 @@ } -bool TypeEnvironment::bindVar( - const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, - const SymbolTable & symtab +bool TypeEnvironment::bindVar( + const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, + const SymbolTable & symtab ) { // remove references from bound type, so that type variables can only bind to value types @@ -286,6 +286,6 @@ ptr newType = it->bound; reset_qualifiers( newType, typeInst->qualifiers ); - if ( unifyInexact( - newType, target, *this, need, have, open, + if ( unifyInexact( + newType, target, *this, need, have, open, widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) { if ( common ) { @@ -300,5 +300,5 @@ } } else { - env.emplace_back( + env.emplace_back( typeInst->name, target, widen.first && widen.second, data ); } @@ -306,12 +306,12 @@ } -bool TypeEnvironment::bindVarToVar( - const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & open, - WidenMode widen, const SymbolTable & symtab +bool TypeEnvironment::bindVarToVar( + const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & open, + WidenMode widen, const SymbolTable & symtab ) { auto c1 = internal_lookup( var1->name ); auto c2 = internal_lookup( var2->name ); - + // exit early if variables already bound together if ( c1 != env.end() && c1 == c2 ) { @@ -396,5 +396,5 @@ } -bool TypeEnvironment::mergeBound( +bool TypeEnvironment::mergeBound( EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) { if ( from.bound ) { @@ -406,5 +406,5 @@ AssertionSet need, have; - if ( unifyInexact( + if ( unifyInexact( toType, fromType, *this, need, have, open, widen, symtab, common ) ) { // unifies, set common type if necessary @@ -424,5 +424,5 @@ } -bool TypeEnvironment::mergeClasses( +bool TypeEnvironment::mergeClasses( ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab ) { Index: src/AST/TypeSubstitution.cpp =================================================================== --- src/AST/TypeSubstitution.cpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/TypeSubstitution.cpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -121,10 +121,10 @@ Pass sub( *this, true ); do { - sub.pass.subCount = 0; - sub.pass.freeOnly = true; + sub.core.subCount = 0; + sub.core.freeOnly = true; for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) { i->second = i->second->accept( sub ); } - } while ( sub.pass.subCount ); + } while ( sub.core.subCount ); } Index: src/AST/TypeSubstitution.hpp =================================================================== --- src/AST/TypeSubstitution.hpp (revision 0d070cacad00a72507dd2c167585d3eb6ccc9198) +++ src/AST/TypeSubstitution.hpp (revision 980fb4e3ad96b48cc0912eafa1db767498aaa625) @@ -99,5 +99,5 @@ void initialize( const TypeSubstitution &src, TypeSubstitution &dest ); - template + template friend class Pass; @@ -188,5 +188,5 @@ Pass sub( *this, false ); input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) ); - return { input, sub.pass.subCount }; + return { input, sub.core.subCount }; } @@ -196,5 +196,5 @@ Pass sub( *this, true ); input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) ); - return { input, sub.pass.subCount }; + return { input, sub.core.subCount }; }