Update expression-decomposition.hpp

Author: ZXShady

include/libassert/expression-decomposition.hpp

@@ -14,6 +14,8 @@
 
 LIBASSERT_BEGIN_NAMESPACE
 namespace detail {
+    template<typename T>
+    inline constexpr bool is_pointer_or_member_pointer = std::is_pointer_v<strip<T>> || std::is_member_pointer_v<strip<T>>;
     // Lots of boilerplate
     // std:: implementations don't allow two separate types for lhs/rhs
     // Note: is this macro potentially bad when it comes to debugging(?)
@@ -168,10 +170,11 @@ namespace detail {
     struct expression_decomposer<nothing, nothing, nothing> {
         explicit constexpr expression_decomposer() = default;
 #define LIBASSERT_GEN_BITFIELD_BOILERPLATE(type)\
-        template<typename Delay = type>[[nodiscard]] constexpr auto operator<<(const type& operand)&& {\
+        template<typename Delay = type>[[nodiscard]] constexpr auto operator<<(type operand)&& {\
             return expression_decomposer<Delay, nothing, nothing>(operand);\
         }
 
+        LIBASSERT_GEN_BITFIELD_BOILERPLATE(bool)
         LIBASSERT_GEN_BITFIELD_BOILERPLATE(char)
         LIBASSERT_GEN_BITFIELD_BOILERPLATE(signed char)
         LIBASSERT_GEN_BITFIELD_BOILERPLATE(unsigned char)
@@ -188,7 +191,7 @@ namespace detail {
 #undef LIBASSERT_GEN_BITFIELD_BOILERPLATE
 
 
-        template<typename O> [[nodiscard]] constexpr auto operator<<(O&& operand) && {
+        template<typename O,std::enable_if_t<!std::is_integral_v<strip<O>>,int> = 0> [[nodiscard]] constexpr auto operator<<(O&& operand) && {
             return expression_decomposer<O, nothing, nothing>(std::forward<O>(operand));
         }
     };
@@ -262,38 +265,36 @@ namespace detail {
             // and rvalues as rvalues.
             return std::forward<A>(a);
         }
-        template<typename Depend = std::remove_reference_t<A>,std::enable_if_t<
-            std::is_member_pointer_v<Depend> || std::is_pointer_v<Depend>,int> = 0
-        >
-        constexpr auto operator==(decltype(NULL)) && 
+        template<typename Null,std::enable_if_t<
+            std::is_integral_v<Null> && is_pointer_or_member_pointer<A>,int> = 0>
+        constexpr auto operator==(Null) &&
         {
             return expression_decomposer<A, std::nullptr_t, ops::eq>(std::forward<A>(a), nullptr);
         }
 
-        template<typename Depend = A, std::enable_if_t<isa<Depend,decltype(NULL)>, int> = 0
-        ,typename Pointer>
-        constexpr auto operator==(Pointer* pointer)&&
+        template<typename Pointer, std::enable_if_t<
+            is_pointer_or_member_pointer<Pointer> && std::is_integral_v<strip<A>>, int> = 0>
+        constexpr auto operator==(Pointer&& pointer) &&
         {
-            return expression_decomposer<std::nullptr_t , Pointer*, ops::eq > (nullptr, pointer);
+            return expression_decomposer<std::nullptr_t , Pointer, ops::eq > (nullptr, std::forward<Pointer>(pointer));
         }
 
-        template<typename Depend = std::remove_reference_t<A>, std::enable_if_t<
-            std::is_member_pointer_v<Depend> || std::is_pointer_v<Depend>, int> = 0
-        >
-        constexpr auto operator!=(decltype(NULL))&&
+        template<typename Null, std::enable_if_t<std::is_integral_v<Null> && is_pointer_or_member_pointer<A>, int> = 0>
+        constexpr auto operator!=(Null) &&
         {
             return expression_decomposer<A, std::nullptr_t, ops::neq>(std::forward<A>(a), nullptr);
         }
 
-        template<typename Depend = A, std::enable_if_t<isa<Depend, decltype(NULL)>, int> = 0
-            , typename Pointer>
-        constexpr auto operator!=(Pointer* pointer)&&
+        template<typename Pointer, std::enable_if_t<
+            is_pointer_or_member_pointer<Pointer> &&
+            std::is_integral_v<strip<A>>,int> = 0>
+        constexpr auto operator!=(Pointer&& pointer) &&
         {
-            return expression_decomposer<std::nullptr_t, Pointer*, ops::neq>(nullptr, pointer);
+            return expression_decomposer<std::nullptr_t, Pointer, ops::neq>(nullptr, std::forward<Pointer>(pointer));
         }
-
+        
         #define LIBASSERT_GEN_OP_BOILERPLATE(functor, op) \
-        template<typename O> [[nodiscard]] constexpr auto operator op(O&& operand) && { \
+        template<typename O,std::enable_if_t<!((std::is_integral_v<strip<O>> && is_pointer_or_member_pointer<A>) || (std::is_integral_v<strip<A>> && is_pointer_or_member_pointer<O>)),int> = 0> [[nodiscard]] constexpr auto operator op(O&& operand) && { \
             return expression_decomposer<A, O, functor>(std::forward<A>(a), std::forward<O>(operand)); \
         }
         LIBASSERT_DO_GEN_OP_BOILERPLATE