Changes in src/AST/Pass.impl.hpp [eb211bf:f8143a6]

File:

• src/AST/Pass.impl.hpp (modified) (13 diffs)

src/AST/Pass.impl.hpp

@@ -111 +111 @@
                 }
 
+
                 //------------------------------
                 /// Check if value was mutated, different for pointers and containers
@@ -124 +125 @@
         }
 
+
+        template< typename core_t >
         template< typename node_t >
         template< typename object_t, typename super_t, typename field_t >
-        void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
+        void ast::Pass< core_t >::result1< node_t >::apply(object_t * object, field_t super_t::* field) {
                 object->*field = value;
         }
@@ -133 +136 @@
         template< typename node_t >
         auto ast::Pass< core_t >::call_accept( const node_t * node )
-                -> typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
+                -> typename std::enable_if<
+                                !std::is_base_of<ast::Expr, node_t>::value &&
+                                !std::is_base_of<ast::Stmt, node_t>::value
+                        , ast::Pass< core_t >::result1<
+                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+                        >
+                >::type
         {
                 __pedantic_pass_assert( __visit_children() );
@@ -142 +151 @@
 
                 auto nval = node->accept( *this );
-                __pass::result1<
+                ast::Pass< core_t >::result1<
                         typename std::remove_pointer< decltype( node->accept(*this) ) >::type
                 > res;
@@ -151 +160 @@
 
         template< typename core_t >
-        __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        ast::Pass< core_t >::result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
@@ -165 +174 @@
 
         template< typename core_t >
-        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
+        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -174 +183 @@
 
         template< typename core_t >
-        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -224 +233 @@
         }
 
+        template< typename core_t >
         template< template <class...> class container_t >
         template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
+        void ast::Pass< core_t >::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
                 auto & container = object->*field;
                 __pedantic_pass_assert( container.size() <= values.size() );
@@ -233 +243 @@
 
                 container_t<ptr<Stmt>> 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.new_val) );
+                                nvals.push_back( std::move(d.nval) );
                         }
                 }
 
-                container = std::move(nvals);
-        }
-
-        template< template <class...> class container_t >
-        template< template <class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
-                if (!stmts || stmts->empty()) return;
-
-                std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
-                                return delta( stmt.release(), -1, false );
-                        });
-                stmts->clear();
-                differs = true;
-        }
-
-        template< template<class...> class container_t >
-        template< template<class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
-                if (!decls || decls->empty()) return;
-
-                std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Decl>& decl) -> delta {
-                                auto loc = decl->location;
-                                auto stmt = new DeclStmt( loc, decl.release() );
-                                return delta( stmt, -1, false );
-                        });
-                decls->clear();
-                differs = true;
+                object->*field = std::move(nvals);
         }
 
         template< typename core_t >
         template< template <class...> class container_t >
-        __pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        ast::Pass< core_t >::resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -303 +285 @@
                 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
 
-                __pass::resultNstmt<container_t> new_kids;
+                resultNstmt<container_t> new_kids;
                 for( auto value : enumerate( statements ) ) {
                         try {
@@ -345 +327 @@
         }
 
+        template< typename core_t >
         template< template <class...> class container_t, typename node_t >
         template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
+        void ast::Pass< core_t >::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
                 auto & container = object->*field;
                 __pedantic_pass_assert( container.size() == values.size() );
@@ -363 +346 @@
         template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        __pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        ast::Pass< core_t >::resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( container.empty() ) return {};
@@ -395 +378 @@
                 if ( ! errors.isEmpty() ) { throw errors; }
 
-                return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
+                return ast::Pass< core_t >::resultN<container_t, node_t>{ mutated,  new_kids };
         }