Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 0240a7cb7979f24051511d43c3d45b6d79bb5d08) +++ src/AST/Pass.hpp (revision eb211bf8d8987a9f51f479f33bbdf5dd9ba03d82) @@ -239,90 +239,32 @@ private: - // Regular nodes + __pass::result1 call_accept( const ast::Stmt * ); + __pass::result1 call_accept( const ast::Expr * ); + + /// This has a `type` member that is the return type for the + /// generic call_accept if the generic call_accept is defined. template< typename node_t > - struct result1 { - bool differs; - const node_t * value; - - template< typename object_t, typename super_t, typename field_t > - void apply(object_t *, field_t super_t::* field); - }; - - result1 call_accept( const ast::Stmt * ); - result1 call_accept( const ast::Expr * ); + using generic_call_accept_result = + std::enable_if< + !std::is_base_of::value && + !std::is_base_of::value + , __pass::result1< + typename std::remove_pointer< typename std::result_of< + decltype(&node_t::accept)(node_t*, type&) >::type >::type + > + >; template< typename node_t > auto call_accept( const node_t * node ) - -> typename std::enable_if< - !std::is_base_of::value && - !std::is_base_of::value - , result1< - typename std::remove_pointer< decltype( node->accept(*this) ) >::type - > - >::type; + -> typename generic_call_accept_result::type; // requests WithStmtsToAdd directly add to this statement, as if it is a compound. - result1 call_accept_as_compound(const ast::Stmt *); - - // Container of statements + __pass::result1 call_accept_as_compound(const ast::Stmt *); + template< template class container_t > - struct resultNstmt { - struct delta { - ptr nval; - ssize_t old_idx; - bool is_old; - - delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {} - }; - - bool differs; - container_t< delta > values; - - resultNstmt() : differs(false), values{} {} - resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {} - - template< typename object_t, typename super_t, typename field_t > - void apply(object_t *, field_t super_t::* field); - - template< template class incontainer_t > - void take_all( incontainer_t> * stmts ) { - if(!stmts || stmts->empty()) return; - - std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr& decl) -> delta { - return delta( decl.release(), -1, false ); - }); - stmts->clear(); - differs = true; - } - - template< template class incontainer_t > - void take_all( incontainer_t> * decls ) { - if(!decls || decls->empty()) return; - - std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr& decl) -> auto { - auto loc = decl->location; - auto stmt = new DeclStmt( loc, decl.release() ); - return delta( stmt, -1, false ); - }); - decls->clear(); - differs = true; - } - }; - - template< template class container_t > - resultNstmt call_accept( const container_t< ptr > & ); - - // Container of something + __pass::resultNstmt call_accept( const container_t< ptr > & ); + template< template class container_t, typename node_t > - struct resultN { - bool differs; - container_t> values; - - template< typename object_t, typename super_t, typename field_t > - void apply(object_t *, field_t super_t::* field); - }; - - template< template class container_t, typename node_t > - resultN< container_t, node_t > call_accept( const container_t< ptr > & container ); + __pass::resultN< container_t, node_t > call_accept( const container_t< ptr > & container ); public: Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 0240a7cb7979f24051511d43c3d45b6d79bb5d08) +++ src/AST/Pass.impl.hpp (revision eb211bf8d8987a9f51f479f33bbdf5dd9ba03d82) @@ -111,5 +111,4 @@ } - //------------------------------ /// Check if value was mutated, different for pointers and containers @@ -125,9 +124,7 @@ } - - template< typename core_t > template< typename node_t > template< typename object_t, typename super_t, typename field_t > - void ast::Pass< core_t >::result1< node_t >::apply(object_t * object, field_t super_t::* field) { + void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) { object->*field = value; } @@ -136,11 +133,5 @@ template< typename node_t > auto ast::Pass< core_t >::call_accept( const node_t * node ) - -> typename std::enable_if< - !std::is_base_of::value && - !std::is_base_of::value - , ast::Pass< core_t >::result1< - typename std::remove_pointer< decltype( node->accept(*this) ) >::type - > - >::type + -> typename ast::Pass< core_t >::template generic_call_accept_result::type { __pedantic_pass_assert( __visit_children() ); @@ -151,5 +142,5 @@ auto nval = node->accept( *this ); - ast::Pass< core_t >::result1< + __pass::result1< typename std::remove_pointer< decltype( node->accept(*this) ) >::type > res; @@ -160,5 +151,5 @@ template< typename core_t > - typename ast::Pass< core_t >::template result1 ast::Pass< core_t >::call_accept( const ast::Expr * expr ) { + __pass::template result1 ast::Pass< core_t >::call_accept( const ast::Expr * expr ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( expr ); @@ -174,5 +165,5 @@ template< typename core_t > - typename ast::Pass< core_t >::template result1 ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) { + __pass::template result1 ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( stmt ); @@ -183,5 +174,5 @@ template< typename core_t > - typename ast::Pass< core_t >::template result1 ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) { + __pass::template result1 ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( stmt ); @@ -233,8 +224,7 @@ } - template< typename core_t > template< template class container_t > template< typename object_t, typename super_t, typename field_t > - void ast::Pass< core_t >::resultNstmt::apply(object_t * object, field_t super_t::* field) { + void __pass::resultNstmt::apply(object_t * object, field_t super_t::* field) { auto & container = object->*field; __pedantic_pass_assert( container.size() <= values.size() ); @@ -243,20 +233,48 @@ container_t> nvals; - for(delta & d : values) { - if( d.is_old ) { + for (delta & d : values) { + if ( d.is_old ) { __pedantic_pass_assert( cit.idx <= d.old_idx ); std::advance( cit, d.old_idx - cit.idx ); nvals.push_back( std::move( (*cit).val) ); } else { - nvals.push_back( std::move(d.nval) ); + nvals.push_back( std::move(d.new_val) ); } } - object->*field = std::move(nvals); + container = std::move(nvals); + } + + template< template class container_t > + template< template class incontainer_t > + void __pass::resultNstmt< container_t >::take_all( incontainer_t> * stmts ) { + if (!stmts || stmts->empty()) return; + + std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), + [](ast::ptr& stmt) -> delta { + return delta( stmt.release(), -1, false ); + }); + stmts->clear(); + differs = true; + } + + template< template class container_t > + template< template class incontainer_t > + void __pass::resultNstmt< container_t >::take_all( incontainer_t> * decls ) { + if (!decls || decls->empty()) return; + + std::transform(decls->begin(), decls->end(), std::back_inserter( values ), + [](ast::ptr& decl) -> delta { + auto loc = decl->location; + auto stmt = new DeclStmt( loc, decl.release() ); + return delta( stmt, -1, false ); + }); + decls->clear(); + differs = true; } template< typename core_t > template< template class container_t > - typename ast::Pass< core_t >::template resultNstmt ast::Pass< core_t >::call_accept( const container_t< ptr > & statements ) { + __pass::template resultNstmt ast::Pass< core_t >::call_accept( const container_t< ptr > & statements ) { __pedantic_pass_assert( __visit_children() ); if( statements.empty() ) return {}; @@ -285,5 +303,5 @@ pass_visitor_stats.avg->push(pass_visitor_stats.depth); - resultNstmt new_kids; + __pass::resultNstmt new_kids; for( auto value : enumerate( statements ) ) { try { @@ -327,8 +345,7 @@ } - template< typename core_t > template< template class container_t, typename node_t > template< typename object_t, typename super_t, typename field_t > - void ast::Pass< core_t >::resultN::apply(object_t * object, field_t super_t::* field) { + void __pass::resultN::apply(object_t * object, field_t super_t::* field) { auto & container = object->*field; __pedantic_pass_assert( container.size() == values.size() ); @@ -346,5 +363,5 @@ template< typename core_t > template< template class container_t, typename node_t > - typename ast::Pass< core_t >::template resultN ast::Pass< core_t >::call_accept( const container_t< ast::ptr > & container ) { + __pass::template resultN ast::Pass< core_t >::call_accept( const container_t< ast::ptr > & container ) { __pedantic_pass_assert( __visit_children() ); if( container.empty() ) return {}; @@ -378,5 +395,5 @@ if ( ! errors.isEmpty() ) { throw errors; } - return ast::Pass< core_t >::resultN{ mutated, new_kids }; + return ast::__pass::resultN{ mutated, new_kids }; } Index: src/AST/Pass.proto.hpp =================================================================== --- src/AST/Pass.proto.hpp (revision 0240a7cb7979f24051511d43c3d45b6d79bb5d08) +++ src/AST/Pass.proto.hpp (revision eb211bf8d8987a9f51f479f33bbdf5dd9ba03d82) @@ -123,4 +123,50 @@ static constexpr bool value = std::is_void< ret_t >::value || std::is_base_of::type >::value; + }; + + /// The result is a single node. + template< typename node_t > + struct result1 { + bool differs; + const node_t * value; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); + }; + + /// The result is a container of statements. + template< template class container_t > + struct resultNstmt { + /// The delta/change on a single node. + struct delta { + ptr new_val; + ssize_t old_idx; + bool is_old; + + delta(const Stmt * s, ssize_t i, bool old) : + new_val(s), old_idx(i), is_old(old) {} + }; + + bool differs; + container_t< delta > values; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); + + template< template class incontainer_t > + void take_all( incontainer_t> * stmts ); + + template< template class incontainer_t > + void take_all( incontainer_t> * decls ); + }; + + /// The result is a container of nodes. + template< template class container_t, typename node_t > + struct resultN { + bool differs; + container_t> values; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); }; Index: src/Common/CodeLocation.h =================================================================== --- src/Common/CodeLocation.h (revision 0240a7cb7979f24051511d43c3d45b6d79bb5d08) +++ src/Common/CodeLocation.h (revision eb211bf8d8987a9f51f479f33bbdf5dd9ba03d82) @@ -25,5 +25,4 @@ /// Create a new unset CodeLocation. CodeLocation() = default; - /// Create a new CodeLocation with the given values.