Changes in src/AST/Pass.proto.hpp [10a1225:e4b6cf78]

File:

• src/AST/Pass.proto.hpp (modified) (3 diffs)

src/AST/Pass.proto.hpp

@@ -107 +107 @@
                 bool     * m_prev;
                 bool_ref * m_ref;
+        };
+
+        /// "Short hand" to check if this is a valid previsit function
+        /// Mostly used to make the static_assert look (and print) prettier
+        template<typename pass_t, typename node_t>
+        struct is_valid_previsit {
+                using ret_t = decltype( ((pass_t*)nullptr)->previsit( (const node_t *)nullptr ) );
+
+                static constexpr bool value = std::is_void< ret_t >::value ||
+                        std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+        };
+
+        /// Used by previsit implementation
+        /// We need to reassign the result to 'node', unless the function
+        /// returns void, then we just leave 'node' unchanged
+        template<bool is_void>
+        struct __assign;
+
+        template<>
+        struct __assign<true> {
+                template<typename pass_t, typename node_t>
+                static inline void result( pass_t & pass, const node_t * & node ) {
+                        pass.previsit( node );
+                }
+        };
+
+        template<>
+        struct __assign<false> {
+                template<typename pass_t, typename node_t>
+                static inline void result( pass_t & pass, const node_t * & node ) {
+                        node = pass.previsit( node );
+                        assertf(node, "Previsit must not return NULL");
+                }
+        };
+
+        /// Used by postvisit implementation
+        /// We need to return the result unless the function
+        /// returns void, then we just return the original node
+        template<bool is_void>
+        struct __return;
+
+        template<>
+        struct __return<true> {
+                template<typename pass_t, typename node_t>
+                static inline const node_t * result( pass_t & pass, const node_t * & node ) {
+                        pass.postvisit( node );
+                        return node;
+                }
+        };
+
+        template<>
+        struct __return<false> {
+                template<typename pass_t, typename node_t>
+                static inline auto result( pass_t & pass, const node_t * & node ) {
+                        return pass.postvisit( node );
+                }
         };
 
@@ -126 +182 @@
         template<typename pass_t, typename node_t>
         static inline auto previsit( pass_t & pass, const node_t * & node, int ) -> decltype( pass.previsit( node ), void() ) {
-                node = pass.previsit( node );
-                assert(node);
+                static_assert(
+                        is_valid_previsit<pass_t, node_t>::value,
+                        "Previsit may not change the type of the node. It must return its paremeter or void."
+                );
+
+                __assign<
+                        std::is_void<
+                                decltype( pass.previsit( node ) )
+                        >::value
+                >::result( pass, node );
         }
 
@@ -135 +199 @@
         // PostVisit : never mutates the passed pointer but may return a different node
         template<typename pass_t, typename node_t>
-        static inline auto postvisit( pass_t & pass, const node_t * node, int ) -> decltype( pass.postvisit( node ), (const node_t *)nullptr ) {
-                return pass.postvisit( node );
+        static inline auto postvisit( pass_t & pass, const node_t * node, int ) ->
+                decltype( pass.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+        {
+                return __return<
+                        std::is_void<
+                                decltype( pass.postvisit( node ) )
+                        >::value
+                >::result( pass, node );
         }