feedc0de/Catch2
1
0 Fork 0
forked from catchorg/Catch2
Code Pull Requests Activity

Support for constexpr matchers in C++20 (P0784)

Browse Source 
To make this all work, I had to remove the stringification cache
from matchers. In theory, this can cause performance penalty in
cases where single matcher instance is stringified multiple times,
but in practice this does not happen much, and the difference is
surprisingly small anyway, because the performance of stringification
is already horrible and full of allocating strings just to throw
them away.

The matcher combinators need P2738 from C++26 to be `constexpr`.

Closes #3091
This commit is contained in:
Martin Hořeňovský committed 2026-05-12 11:05:02 +02:00
1 parent 15b9393f0f
commit 651247c7f4
14 files changed
+254 -49
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/catch2/internal/catch_compiler_capabilities.hpp
+12
View File
@@ -35,6 +35,18 @@
# define CATCH_CPP20_OR_GREATER
#endif
// Matchers are only constexpr-able in C++20
#if defined( CATCH_CPP20_OR_GREATER ) && \
defined( __cpp_constexpr_dynamic_alloc ) && \
__cpp_constexpr_dynamic_alloc >= 201907L && \
/* GCC < 13 define the feature macro, but compiler bugs stop us from using it */ \
( !defined( __GNUC__ ) || __GNUC__ >= 13 || defined(__clang__) )
# define CATCH_INTERNAL_CONSTEXPR_MATCHERS_ENABLED
# define CATCH_DESTRUCTOR_CONSTEXPR constexpr
#else
# define CATCH_DESTRUCTOR_CONSTEXPR
#endif
// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
src/catch2/matchers/catch_matchers.cpp
+5 -5
View File
@@ -13,13 +13,13 @@ namespace Catch {
namespace Matchers {
std::string MatcherUntypedBase::toString() const {
if (m_cachedToString.empty()) {
m_cachedToString = describe();
}
return m_cachedToString;
return describe();
}
MatcherUntypedBase::~MatcherUntypedBase() = default;
std::string MatcherUntypedBase::describe() const {
using namespace std::string_literals;
return "Undescribed matcher"s;
}
} // namespace Matchers
} // namespace Catch
src/catch2/matchers/catch_matchers.hpp
+38 -6
View File
@@ -20,10 +20,10 @@ namespace Matchers {
class MatcherUntypedBase {
public:
MatcherUntypedBase() = default;
constexpr MatcherUntypedBase() = default;
MatcherUntypedBase(MatcherUntypedBase const&) = default;
MatcherUntypedBase(MatcherUntypedBase&&) = default;
constexpr MatcherUntypedBase(MatcherUntypedBase const&) = default;
constexpr MatcherUntypedBase(MatcherUntypedBase&&) = default;
MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
@@ -31,9 +31,9 @@ namespace Matchers {
std::string toString() const;
protected:
virtual ~MatcherUntypedBase(); // = default;
virtual std::string describe() const = 0;
mutable std::string m_cachedToString;
CATCH_DESTRUCTOR_CONSTEXPR virtual ~MatcherUntypedBase() = default;
//! Should be overridden, but we provide default "undescribed" impl
virtual std::string describe() const;
};
@@ -215,6 +215,19 @@ namespace Matchers {
#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
#define CATCH_STATIC_REQUIRE_THAT( arg, matcher ) \
static_assert( ( matcher ).match( arg ), #matcher ".match( " #arg " )"); \
CATCH_SUCCEED( #matcher ".match( " #arg " )" )
#define CATCH_STATIC_CHECK_THAT( arg, matcher ) \
static_assert( ( matcher ).match( arg ), #matcher ".match( " #arg " )"); \
CATCH_SUCCEED( #matcher ".match( " #arg " )" )
#else
#define CATCH_STATIC_REQUIRE_THAT( arg, matcher ) CATCH_REQUIRE_THAT( arg, matcher )
#define CATCH_STATIC_CHECK_THAT( arg, matcher ) CATCH_CHECK_THAT( arg, matcher )
#endif
#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
@@ -226,6 +239,9 @@ namespace Matchers {
#define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
#define CATCH_STATIC_REQUIRE_THAT( arg, matcher ) (void)(0)
#define CATCH_STATIC_CHECK_THAT( arg, matcher ) (void)(0)
#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
@@ -237,6 +253,19 @@ namespace Matchers {
#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
#define STATIC_REQUIRE_THAT( arg, matcher ) \
static_assert( ( matcher ).match( arg ), #matcher ".match( " #arg " )"); \
SUCCEED( #matcher ".match( " #arg " )" )
#define STATIC_CHECK_THAT( arg, matcher ) \
static_assert( ( matcher ).match( arg ), #matcher ".match( " #arg " )"); \
SUCCEED( #matcher ".match( " #arg " )" )
#else
#define STATIC_REQUIRE_THAT( arg, matcher ) REQUIRE_THAT( arg, matcher )
#define STATIC_CHECK_THAT( arg, matcher ) CHECK_THAT( arg, matcher )
#endif
#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
@@ -248,6 +277,9 @@ namespace Matchers {
#define CHECK_THAT( arg, matcher ) (void)(0)
#define REQUIRE_THAT( arg, matcher ) (void)(0)
#define STATIC_REQUIRE_THAT( arg, matcher ) (void)(0)
#define STATIC_CHECK_THAT( arg, matcher ) (void)(0)
#endif // end of user facing macro declarations
#endif // CATCH_MATCHERS_HPP_INCLUDED
src/catch2/matchers/catch_matchers_templated.cpp
+5 -1
View File
@@ -9,7 +9,11 @@
namespace Catch {
namespace Matchers {
MatcherGenericBase::~MatcherGenericBase() = default;
std::string MatcherGenericBase::describe() const {
using namespace std::string_literals;
return "Undescribed generic matcher"s;
}
namespace Detail {
src/catch2/matchers/catch_matchers_templated.hpp
+64 -35
View File
@@ -22,12 +22,12 @@
namespace Catch {
namespace Matchers {
class MatcherGenericBase : public MatcherUntypedBase {
std::string describe() const override;
public:
MatcherGenericBase() = default;
~MatcherGenericBase() override; // = default;
constexpr MatcherGenericBase() = default;
MatcherGenericBase(MatcherGenericBase const&) = default;
MatcherGenericBase(MatcherGenericBase&&) = default;
constexpr MatcherGenericBase(MatcherGenericBase const&) = default;
constexpr MatcherGenericBase(MatcherGenericBase&&) = default;
MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
@@ -36,7 +36,9 @@ namespace Matchers {
namespace Detail {
template<std::size_t N, std::size_t M>
std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
constexpr std::array<void const*, N + M>
array_cat( std::array<void const*, N>&& lhs,
std::array<void const*, M>&& rhs ) {
std::array<void const*, N + M> arr{};
std::copy_n(lhs.begin(), N, arr.begin());
std::copy_n(rhs.begin(), M, arr.begin() + N);
@@ -44,7 +46,8 @@ namespace Matchers {
}
template<std::size_t N>
std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
constexpr std::array<void const*, N + 1>
array_cat( std::array<void const*, N>&& lhs, void const* rhs ) {
std::array<void const*, N+1> arr{};
std::copy_n(lhs.begin(), N, arr.begin());
arr[N] = rhs;
@@ -52,7 +55,8 @@ namespace Matchers {
}
template<std::size_t N>
std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
constexpr std::array<void const*, N + 1>
array_cat( void const* lhs, std::array<void const*, N>&& rhs ) {
std::array<void const*, N + 1> arr{ {lhs} };
std::copy_n(rhs.begin(), N, arr.begin() + 1);
return arr;
@@ -75,23 +79,31 @@ namespace Matchers {
template<std::size_t N, typename Arg>
bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
constexpr bool match_all_of( Arg&&,
std::array<void const*, N> const&,
std::index_sequence<> ) {
return true;
}
template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
constexpr bool match_all_of( Arg&& arg,
std::array<void const*, N> const& matchers,
std::index_sequence<Idx, Indices...> ) {
return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
}
template<std::size_t N, typename Arg>
bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
constexpr bool match_any_of( Arg&&,
std::array<void const*, N> const&,
std::index_sequence<> ) {
return false;
}
template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
constexpr bool match_any_of( Arg&& arg,
std::array<void const*, N> const& matchers,
std::index_sequence<Idx, Indices...> ) {
return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
}
@@ -112,15 +124,18 @@ namespace Matchers {
public:
MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
constexpr MatchAllOfGeneric( MatchAllOfGeneric&& ) = default;
constexpr MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
MatchAllOfGeneric(MatcherTs const&... matchers CATCH_ATTR_LIFETIMEBOUND)
constexpr MatchAllOfGeneric(
MatcherTs const&... matchers CATCH_ATTR_LIFETIMEBOUND )
: m_matchers{ {std::addressof(matchers)...} } {}
explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
constexpr explicit MatchAllOfGeneric(
std::array<void const*, sizeof...( MatcherTs )> matchers ):
m_matchers{ matchers } {}
template<typename Arg>
bool match(Arg&& arg) const {
constexpr bool match( Arg&& arg ) const {
return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
}
@@ -136,7 +151,7 @@ namespace Matchers {
//! Avoids type nesting for `GenericAllOf && GenericAllOf` case
template<typename... MatchersRHS>
friend
constexpr friend
MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
MatchAllOfGeneric<MatcherTs...>&& lhs CATCH_ATTR_LIFETIMEBOUND,
MatchAllOfGeneric<MatchersRHS...>&& rhs CATCH_ATTR_LIFETIMEBOUND ) {
@@ -145,7 +160,8 @@ namespace Matchers {
//! Avoids type nesting for `GenericAllOf && some matcher` case
template<typename MatcherRHS>
friend std::enable_if_t<is_matcher_v<MatcherRHS>,
constexpr friend std::enable_if_t<
is_matcher_v<MatcherRHS>,
MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
MatchAllOfGeneric<MatcherTs...>&& lhs CATCH_ATTR_LIFETIMEBOUND,
MatcherRHS const& rhs CATCH_ATTR_LIFETIMEBOUND ) {
@@ -154,7 +170,8 @@ namespace Matchers {
//! Avoids type nesting for `some matcher && GenericAllOf` case
template<typename MatcherLHS>
friend std::enable_if_t<is_matcher_v<MatcherLHS>,
constexpr friend std::enable_if_t<
is_matcher_v<MatcherLHS>,
MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
MatcherLHS const& lhs CATCH_ATTR_LIFETIMEBOUND,
MatchAllOfGeneric<MatcherTs...>&& rhs CATCH_ATTR_LIFETIMEBOUND ) {
@@ -168,15 +185,18 @@ namespace Matchers {
public:
MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
constexpr MatchAnyOfGeneric( MatchAnyOfGeneric&& ) = default;
constexpr MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
MatchAnyOfGeneric(MatcherTs const&... matchers CATCH_ATTR_LIFETIMEBOUND)
constexpr MatchAnyOfGeneric(
MatcherTs const&... matchers CATCH_ATTR_LIFETIMEBOUND )
: m_matchers{ {std::addressof(matchers)...} } {}
explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
constexpr explicit MatchAnyOfGeneric(
std::array<void const*, sizeof...( MatcherTs )> matchers ):
m_matchers{ matchers } {}
template<typename Arg>
bool match(Arg&& arg) const {
constexpr bool match( Arg&& arg ) const {
return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
}
@@ -192,7 +212,8 @@ namespace Matchers {
//! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
template<typename... MatchersRHS>
friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
constexpr friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>
operator||(
MatchAnyOfGeneric<MatcherTs...>&& lhs CATCH_ATTR_LIFETIMEBOUND,
MatchAnyOfGeneric<MatchersRHS...>&& rhs CATCH_ATTR_LIFETIMEBOUND ) {
return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
@@ -200,7 +221,8 @@ namespace Matchers {
//! Avoids type nesting for `GenericAnyOf || some matcher` case
template<typename MatcherRHS>
friend std::enable_if_t<is_matcher_v<MatcherRHS>,
constexpr friend std::enable_if_t<
is_matcher_v<MatcherRHS>,
MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
MatchAnyOfGeneric<MatcherTs...>&& lhs CATCH_ATTR_LIFETIMEBOUND,
MatcherRHS const& rhs CATCH_ATTR_LIFETIMEBOUND ) {
@@ -209,7 +231,8 @@ namespace Matchers {
//! Avoids type nesting for `some matcher || GenericAnyOf` case
template<typename MatcherLHS>
friend std::enable_if_t<is_matcher_v<MatcherLHS>,
constexpr friend std::enable_if_t<
is_matcher_v<MatcherLHS>,
MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
MatcherLHS const& lhs CATCH_ATTR_LIFETIMEBOUND,
MatchAnyOfGeneric<MatcherTs...>&& rhs CATCH_ATTR_LIFETIMEBOUND) {
@@ -225,14 +248,15 @@ namespace Matchers {
public:
MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
constexpr MatchNotOfGeneric( MatchNotOfGeneric&& ) = default;
constexpr MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
explicit MatchNotOfGeneric(MatcherT const& matcher CATCH_ATTR_LIFETIMEBOUND)
constexpr explicit MatchNotOfGeneric(
MatcherT const& matcher CATCH_ATTR_LIFETIMEBOUND )
: m_matcher{matcher} {}
template<typename Arg>
bool match(Arg&& arg) const {
constexpr bool match( Arg&& arg ) const {
return !m_matcher.match(arg);
}
@@ -241,7 +265,7 @@ namespace Matchers {
}
//! Negating negation can just unwrap and return underlying matcher
friend MatcherT const&
constexpr friend MatcherT const&
operator!( MatchNotOfGeneric<MatcherT> const& matcher
CATCH_ATTR_LIFETIMEBOUND ) {
return matcher.m_matcher;
@@ -252,14 +276,18 @@ namespace Matchers {
// compose only generic matchers
template<typename MatcherLHS, typename MatcherRHS>
std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
constexpr std::enable_if_t<
Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>,
Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
operator&&( MatcherLHS const& lhs CATCH_ATTR_LIFETIMEBOUND,
MatcherRHS const& rhs CATCH_ATTR_LIFETIMEBOUND ) {
return { lhs, rhs };
}
template<typename MatcherLHS, typename MatcherRHS>
std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
constexpr std::enable_if_t<
Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>,
Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
operator||( MatcherLHS const& lhs CATCH_ATTR_LIFETIMEBOUND,
MatcherRHS const& rhs CATCH_ATTR_LIFETIMEBOUND ) {
return { lhs, rhs };
@@ -267,7 +295,8 @@ namespace Matchers {
//! Wrap provided generic matcher in generic negator
template<typename MatcherT>
std::enable_if_t<Detail::is_generic_matcher_v<MatcherT>, Detail::MatchNotOfGeneric<MatcherT>>
constexpr std::enable_if_t<Detail::is_generic_matcher_v<MatcherT>,
Detail::MatchNotOfGeneric<MatcherT>>
operator!( MatcherT const& matcher CATCH_ATTR_LIFETIMEBOUND ) {
return Detail::MatchNotOfGeneric<MatcherT>{matcher};
}