Update assert-macros.hpp

Author: ZXShady

include/libassert/assert-macros.hpp

@@ -11,23 +11,31 @@
 LIBASSERT_BEGIN_NAMESPACE
 namespace detail {
 
-std::false_type is_referencable_expression(...);
+template <typename Concept, typename = void>
+inline constexpr bool is_referencable_expression_impl = false;
 
 template <typename Concept>
-auto is_referencable_expression(Concept c)
-    -> decltype(c(detail::expression_decomposer<>{}), std::true_type{});
+inline constexpr bool is_referencable_expression_impl<
+    Concept,
+    decltype(void(std::declval<Concept>()(detail::expression_decomposer{})))> = true;
 
+template <typename Concept>
+constexpr bool is_referencable_expression(const Concept&) {
+  return is_referencable_expression_impl<Concept>;
+}
 // A macro that checks whether an expression can be decomposed by the
 // decomposer. An expression that fails is a bitfield for example.
-#define LIBASSERT_IS_DECOMPOSABLE_EXPR(expr)                                   \
-  decltype(libassert::detail::is_referencable_expression(                      \
-      [](auto expr_decomposer) -> decltype(std::move(expr_decomposer)          \
-                                           << expr) {}))::value
+#define LIBASSERT_IS_DECOMPOSABLE_EXPR(expr)                          \
+  libassert::detail::is_referencable_expression(                      \
+      [&](auto expr_decomposer,                                       \
+         int =                                                        \
+             (void(libassert_expr_decomposer_t{} << expr), 0)) {})
 
 // The decomposer is passed as a template parameter to not evaluate the other
 // path and cause a hard error
 #define LIBASSERT_DECOMPOSER(expr)                                             \
   [&](auto decomposer) {                                                       \
+    using libassert_expr_decomposer_t = std::conditional_t<sizeof(decomposer) != 0,libassert::detail::expression_decomposer<>,void>;\
     if constexpr (sizeof(decomposer) &&                                        \
                   LIBASSERT_IS_DECOMPOSABLE_EXPR(expr)) {                      \
       return libassert::detail::expression_decomposer(std::move(decomposer)    \