Scrap your static_assert: report compile-time checks instead of breaking the build

[steve-downey]

Removes every live static_assert from tests/beman/expected/*.test.cpp, replacing each with a check the test run reports.

Why

A static_assert is a poor test. A wrong answer is a translation failure, so the only thing anyone sees is a compiler diagnostic — the test run reports nothing, the xUnit output is empty, and because the build stops at the first failing assertion, no other test in the file is exercised. A trait that flips from under you takes the whole file with it and tells you about exactly one problem.

What replaces it

Two header-only components under tests/beman/expected/testing/:

constant_eval(probe) is consteval, so calling it is an immediate invocation: the probe is evaluated during translation and its result must be a constant expression. Whether something can be constant-evaluated is therefore still answered by the compiler, with no static_assert needed — only the value comparison moves to the test run:

constexpr auto probe = [] {
    expt::expected<int, int> e(expt::unexpect, 7);
    return int_state{e.has_value(), e.error()};
};
CHECK(constant_eval(probe) == int_state{false, 7});   // constant evaluation
CHECK(probe() == int_state{false, 7});                // ordinary evaluation

A wrong value now reports { error 7 } == { error 3 } and the rest of the file still runs. Because the probe is a plain lambda rather than a consteval one, the same body covers both evaluation modes — which matters for a union-based type.

type_name<T>() returns the identity of T, compared with std::is_same_v. The check is exactly as strict as the static_assert it replaces; the compiler's spelling is consulted only to explain a failure:

FAILED: CHECK( type_name<decltype(*e)>() == type_name<int&>() )
with expansion: const int& == int&

It has two implementations of that spelling, selected automatically and holding to the same contract: P2996 reflection via std::meta::display_string_of(^^T) where available, and otherwise recovery from std::source_location::function_name() by calibrating on the signatures of signature<bool> and signature<char>, which differ only where the template argument is named. Nothing about any compiler's format is hard-coded. Both produce byte-identical spellings for every type the suite uses.

Result

• 283 static_assert declarations removed across 17 files, plus 32 in the exemplar. None remain live; the word survives only in comments.
• ctest goes from 1095/1095 to 1172/1172 — assertions that were previously invisible are now reported cases.
• Verified on both type_name implementations, and for the behavioral files against std::expected as well as beman::expected.

Two things worth reviewing closely

expected_std_equivalence.test.cpp is no longer a translation-time gate. Its assertions are generated by BEMAN_PARITY/BEMAN_RUN over a battery of error types; the macros now expand to INFO + CHECK inside a TEST_CASE, so a divergence names the exact (T, E) pair. A consequence: the four pre-existing is_trivially_copyable divergences on clang with libstdc++ — which are four hard static assertion failed errors at HEAD — now surface as named test failures instead of breaking the build. Pre-existing, and now diagnosable, but it is a real change in failure mode for that target.

-freflection is enabled in cmake/gcc-16-toolchain.cmake only. It cannot go in CMakePresets.json, because the preset toolchains use the unversioned g++ and gcc rejects the flag outright below -std=c++26. That leaves the reflection path without CI coverage — tracked in #88.