Changes in src/AST/Pass.impl.hpp [7a780ad:af746cc]

File:

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

src/AST/Pass.impl.hpp

@@ -109 +109 @@
                 return val;
         }
+
+        //------------------------------
+        /// Check if value was mutated, different for pointers and containers
+        template<typename lhs_t, typename rhs_t>
+        bool differs( const lhs_t * old_val, const rhs_t * new_val ) {
+                return old_val != new_val;
+        }
+
+        template< template <class...> class container_t, typename node_t >
+        bool differs( const container_t<ast::ptr< node_t >> &, const container_t<ast::ptr< node_t >> & new_val ) {
+                return !new_val.empty();
+        }
 }
 
@@ -114 +126 @@
 template< typename node_t >
 auto ast::Pass< core_t >::call_accept( const node_t * node ) ->
-                ast::Pass< core_t >::call_accept_result_t<node_t> {
+        typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
+{
         __pedantic_pass_assert( __visit_children() );
         __pedantic_pass_assert( node );
 
+        static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR" );
+        static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR" );
+
         auto nval = node->accept( *this );
-        return { nval != node, nval };
+        __pass::result1<
+                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+        > res;
+        res.differs = nval != node;
+        res.value = nval;
+        return res;
+}
+
+template< typename core_t >
+ast::__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( expr );
+
+        auto nval = expr->accept( *this );
+        return { nval != expr, nval };
+}
+
+template< typename core_t >
+ast::__pass::template result1<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 };
 }
 
@@ -191 +230 @@
 ast::__pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
         __pedantic_pass_assert( __visit_children() );
-        __pedantic_pass_assert( !statements.empty() );
+        if ( statements.empty() ) return {};
 
         // We are going to aggregate errors for all these statements
@@ -224 +263 @@
                         const ast::Stmt * new_stmt = stmt->accept( *this );
                         assert( new_stmt );
+                        if ( new_stmt != stmt ) { new_kids.differs = true; }
 
                         // Make sure that it is either adding statements or declartions but not both
@@ -236 +276 @@
                         // Now add the statement if there is one
                         if ( new_stmt != stmt ) {
-                                new_kids.differs = true;
-                                new_kids.values.emplace_back( new_stmt );
+                                new_kids.values.emplace_back( new_stmt, i, false );
                         } else {
-                                new_kids.values.emplace_back( i );
+                                new_kids.values.emplace_back( nullptr, i, true );
                         }
 
@@ -259 +298 @@
 ast::__pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
         __pedantic_pass_assert( __visit_children() );
-        __pedantic_pass_assert( !container.empty() );
-
-        // Collect errors from processing all these nodes.
+        if ( container.empty() ) return {};
         SemanticErrorException errors;
 
@@ -305 +342 @@
         static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
 
-        auto result = call_accept( old_val );
-        if ( result.differs ) {
+        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 ) {
                 auto new_parent = __pass::mutate<core_t>(parent);
-                result.apply( new_parent, field );
+                new_val.apply(new_parent, field);
                 parent = new_parent;
         }
@@ -326 +366 @@
         static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
 
-        auto result = call_accept_top( old_val );
-        if ( result.differs ) {
+        auto new_val = call_accept_top( 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 ) {
                 auto new_parent = __pass::mutate<core_t>(parent);
-                result.apply( new_parent, field );
+                new_val.apply(new_parent, field);
                 parent = new_parent;
         }
@@ -347 +390 @@
         static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
 
-        auto result = call_accept_as_compound( old_val );
-        if ( result.differs ) {
+        auto new_val = call_accept_as_compound( 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 ) {
                 auto new_parent = __pass::mutate<core_t>(parent);
-                result.apply( new_parent, child );
+                new_val.apply( new_parent, child );
                 parent = new_parent;
         }
@@ -406 +452 @@
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
-        if ( auto ptr = __pass::translationUnit( visitor.core, 0 ) ) {
+        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
                 ValueGuard<const TranslationUnit *> guard( *ptr );
                 *ptr = &unit;
@@ -477 +523 @@
                                 CodeLocation{}, "__func__",
                                 new ast::ArrayType{
-                                        new ast::BasicType{ ast::BasicKind::Char, ast::CV::Const },
+                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
                                         nullptr, VariableLen, DynamicDim
                                 },