Changes in src/AST/Pass.impl.hpp [ee918356:3b0bc16]

File:

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

src/AST/Pass.impl.hpp

@@ -79 +79 @@
 
                 template<typename it_t, template <class...> class container_t>
-                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
-                        if(empty(stmts)) return;
-
-                        std::move(stmts->begin(), stmts->end(), it);
-                        stmts->clear();
+                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * decls, bool * mutated = nullptr ) {
+                        if(empty(decls)) return;
+
+                        std::move(decls->begin(), decls->end(), it);
+                        decls->clear();
                         if(mutated) *mutated = true;
                 }
@@ -123 +123 @@
                         return !new_val.empty();
                 }
-        }
-
-
-        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) {
-                object->*field = value;
         }
 
@@ -139 +131 @@
                                 !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
-                        >
+                        , decltype( node->accept(*this) )
                 >::type
         {
@@ -150 +140 @@
                 static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
 
-                auto nval = node->accept( *this );
-                ast::Pass< core_t >::result1<
-                        typename std::remove_pointer< decltype( node->accept(*this) ) >::type
-                > res;
-                res.differs = nval != node;
-                res.value = nval;
-                return res;
+                return node->accept( *this );
         }
 
         template< typename core_t >
-        typename ast::Pass< core_t >::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
@@ -169 +153 @@
                 }
 
-                auto nval = expr->accept( *this );
-                return { nval != expr, nval };
+                return expr->accept( *this );
         }
 
         template< typename core_t >
-        typename ast::Pass< core_t >::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
+        const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
 
-                const ast::Stmt * nval = stmt->accept( *this );
-                return { nval != stmt, nval };
+                return stmt->accept( *this );
         }
 
         template< typename core_t >
-        typename ast::Pass< core_t >::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -208 +190 @@
                 // If the pass doesn't want to add anything then we are done
                 if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
-                        return { nstmt != stmt, nstmt };
+                        return nstmt;
                 }
 
@@ -230 +212 @@
                 __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
 
-                return {true, compound};
+                return compound;
         }
 
         template< typename core_t >
         template< template <class...> class container_t >
-        template< typename object_t, typename super_t, typename field_t >
-        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() );
-
-                auto cit = enumerate(container).begin();
-
-                container_t<ptr<Stmt>> nvals;
-                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) );
-                        }
-                }
-
-                object->*field = std::move(nvals);
-        }
-
-        template< typename core_t >
-        template< template <class...> class container_t >
-        typename ast::Pass< core_t >::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -285 +244 @@
                 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
 
-                resultNstmt<container_t> new_kids;
-                for( auto value : enumerate( statements ) ) {
+                bool mutated = false;
+                container_t< ptr<Stmt> > new_kids;
+                for( const Stmt * stmt : statements ) {
                         try {
-                                size_t i = value.idx;
-                                const Stmt * stmt = value.val;
                                 __pedantic_pass_assert( stmt );
                                 const ast::Stmt * new_stmt = stmt->accept( *this );
                                 assert( new_stmt );
-                                if(new_stmt != stmt ) { new_kids.differs = true; }
+                                if(new_stmt != stmt ) mutated = true;
 
                                 // Make sure that it is either adding statements or declartions but not both
@@ -303 +261 @@
 
                                 // Take all the statements which should have gone after, N/A for first iteration
-                                new_kids.take_all( decls_before );
-                                new_kids.take_all( stmts_before );
+                                __pass::take_all( std::back_inserter( new_kids ), decls_before, &mutated );
+                                __pass::take_all( std::back_inserter( new_kids ), stmts_before, &mutated );
 
                                 // Now add the statement if there is one
-                                if(new_stmt != stmt) {
-                                        new_kids.values.emplace_back( new_stmt, i, false );
-                                } else {
-                                        new_kids.values.emplace_back( nullptr, i, true );
-                                }
+                                new_kids.emplace_back( new_stmt );
 
                                 // Take all the declarations that go before
-                                new_kids.take_all( decls_after );
-                                new_kids.take_all( stmts_after );
+                                __pass::take_all( std::back_inserter( new_kids ), decls_after, &mutated );
+                                __pass::take_all( std::back_inserter( new_kids ), stmts_after, &mutated );
                         }
                         catch ( SemanticErrorException &e ) {
@@ -324 +278 @@
                 if ( !errors.isEmpty() ) { throw errors; }
 
-                return new_kids;
+                return mutated ? new_kids : container_t< ptr<Stmt> >();
         }
 
         template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        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() );
-
-                for(size_t i = 0; i < container.size(); i++) {
-                        // Take all the elements that are different in 'values'
-                        // and swap them into 'container'
-                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
-                }
-
-                // Now the original containers should still have the unchanged values
-                // but also contain the new values
-        }
-
-        template< typename core_t >
-        template< template <class...> class container_t, typename node_t >
-        typename ast::Pass< core_t >::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        container_t< ast::ptr<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 {};
@@ -356 +293 @@
 
                 bool mutated = false;
-                container_t<ptr<node_t>> new_kids;
+                container_t< ast::ptr<node_t> > new_kids;
                 for ( const node_t * node : container ) {
                         try {
                                 __pedantic_pass_assert( node );
                                 const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
-                                if(new_stmt != node ) {
-                                        mutated = true;
-                                        new_kids.emplace_back( new_stmt );
-                                } else {
-                                        new_kids.emplace_back( nullptr );
-                                }
-
+                                if(new_stmt != node ) mutated = true;
+
+                                new_kids.emplace_back( new_stmt );
                         }
                         catch( SemanticErrorException &e ) {
@@ -373 +306 @@
                         }
                 }
-
-                __pedantic_pass_assert( new_kids.size() == container.size() );
                 pass_visitor_stats.depth--;
                 if ( ! errors.isEmpty() ) { throw errors; }
 
-                return ast::Pass< core_t >::resultN<container_t, node_t>{ mutated,  new_kids };
+                return mutated ? new_kids : container_t< ast::ptr<node_t> >();
         }
 
@@ -396 +327 @@
                 auto new_val = call_accept( old_val );
 
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
-
-                if( new_val.differs ) {
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+
+                if( __pass::differs(old_val, new_val) ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply(new_parent, child);
+                        new_parent->*child = new_val;
                         parent = new_parent;
                 }
@@ -422 +353 @@
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
 
-                if( new_val.differs ) {
+                if( __pass::differs(old_val, new_val) ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply( new_parent, child );
+                        new_parent->*child = new_val;
                         parent = new_parent;
                 }
@@ -1010 +941 @@
                         const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
                         if(func != clause.target.func) mutated = true;
-                        else func = nullptr;
 
                         std::vector<ptr<Expr>> new_args;
@@ -1016 +946 @@
                         for( const auto & arg : clause.target.args ) {
                                 auto a = arg->accept(*this);
-                                if( a != arg ) {
-                                        mutated = true;
-                                        new_args.push_back( a );
-                                } else
-                                        new_args.push_back( nullptr );
+                                new_args.push_back( a );
+                                if( a != arg ) mutated = true;
                         }
 
                         const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
                         if(stmt != clause.stmt) mutated = true;
-                        else stmt = nullptr;
 
                         const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
                         if(cond != clause.cond) mutated = true;
-                        else cond = nullptr;
 
                         new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
@@ -1036 +961 @@
                 if(mutated) {
                         auto n = __pass::mutate<core_t>(node);
-                        for(size_t i = 0; i < new_clauses.size(); i++) {
-                                if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
-
-                                for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
-                                        if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
-                                }
-
-                                if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
-                                if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
-                        }
+                        n->clauses = std::move( new_clauses );
                         node = n;
                 }
@@ -1053 +969 @@
                 if(node->field) { \
                         auto nval = call_accept( node->field ); \
-                        if(nval.differs ) { \
+                        if(nval != node->field ) { \
                                 auto nparent = __pass::mutate<core_t>(node); \
-                                nparent->field = nval.value; \
+                                nparent->field = nval; \
                                 node = nparent; \
                         } \