using handler = void (*)(CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM);

constexpr contract_group (handler h = {}) : reporter(h) { }

constexpr auto set_handler(handler h) -> handler;

constexpr auto get_handler() const -> handler { return reporter; }

constexpr auto expects (bool b, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT)

-> void { if (!b) reporter(msg CPP2_SOURCE_LOCATION_ARG); }

handler reporter;

std::cerr

#ifdef CPP2_USE_SOURCE_LOCATION

<< where.file_name() << "("

<< where.line() << ") "

<< where.function_name() << ": "

#endif

<< group << " violation";

if (msg[0] != '\0') {

std::cerr << ": " << msg;

}

std::cerr << "\n";

std::terminate();

Default.expects(h);

auto old = reporter;

reporter = h;

return old;

{

// NOTE: This "!= T{}" test may or may not work for STL iterators. The standard

// doesn't guarantee that using == and != will reliably report whether an

// STL iterator has the default-constructed value

Null.expects(p != CPP2_TYPEOF(p){}, "dynamic null dereference attempt detected" CPP2_SOURCE_LOCATION_ARG);

return std::forward<decltype(p)>(p);

requires (std::is_integral_v<CPP2_TYPEOF(arg)> &&

requires { std::ssize(x); x[arg]; })

{

Bounds.expects(0 <= arg && arg < std::ssize(x), "out of bounds access attempt detected" CPP2_SOURCE_LOCATION_ARG);

return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];

requires (!(std::is_integral_v<CPP2_TYPEOF(arg)> &&

requires { std::ssize(x); x[arg]; }))

{

return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];

#ifdef CPP2_NO_EXCEPTIONS

Type.expects(

!"exceptions are disabled with -fno-exceptions",

msg

);

std::terminate();

#else

throw CPP2_FORWARD(x);

#endif

#ifdef CPP2_NO_EXCEPTIONS

return 0;

#else

return std::uncaught_exceptions();

#endif

#ifdef CPP2_NO_RTTI

Type.expects(

!"'as' dynamic casting is disabled with -fno-rtti", // more likely to appear on console

"'as' dynamic casting is disabled with -fno-rtti" // make message available to hooked handlers

);

return nullptr;

#else

return dynamic_cast<T>(CPP2_FORWARD(x));

#endif

#ifdef CPP2_NO_RTTI

Type.expects(

!"'any' dynamic casting is disabled with -fno-rtti", // more likely to appear on console

"'any' dynamic casting is disabled with -fno-rtti" // make message available to hooked handlers

);

#else

return typeid(T);

#endif

bool init = false;

alignas(T) std::byte data[sizeof(T)]; // or: std::aligned_storage_t<sizeof(T), alignof(T)> data

auto t() -> T& { return *std::launder(reinterpret_cast<T*>(&data)); }

template<typename U>

friend class out;

auto destroy() -> void { if (init) { t().~T(); } init = false; }

deferred_init() noexcept { }

~deferred_init() noexcept { destroy(); }

auto value() noexcept -> T& { Default.expects(init); return t(); }

auto construct (auto&& ...args) -> void { Default.expects(!init); new (&data) T(std::forward<decltype(args)>(args)...); init = true; }

auto construct_list(auto&& ...args) -> void { Default.expects(!init); new (&data) T{std::forward<decltype(args)>(args)...}; init = true; }

// Not going to bother with std::variant here

union {

T* t;

deferred_init<T>* dt;

};

out<T>* ot = {};

bool has_t;

// Each out in a chain contains its own uncaught_count ...

int uncaught_count = Uncaught_exceptions();

// ... but all in a chain share the topmost called_construct_

bool called_construct_ = false;

out(T* t) noexcept : t{ t}, has_t{true} { Default.expects( t); }

out(deferred_init<T>* dt) noexcept : dt{dt}, has_t{false} { Default.expects(dt); }

out(out<T>* ot) noexcept : ot{ot}, has_t{ot->has_t} { Default.expects(ot);

if (has_t) { t = ot->t; }

else { dt = ot->dt; }

}

auto called_construct() -> bool& {

if (ot) { return ot->called_construct(); }

else { return called_construct_; }

}

// In the case of an exception, if the parameter was uninitialized

// then leave it in the same state on exit (strong guarantee)

~out() {

if (called_construct() && uncaught_count != Uncaught_exceptions()) {

Default.expects(!has_t);

dt->destroy();

called_construct() = false;

}

}

auto construct(auto&& ...args) -> void {

if (has_t) {

Default.expects( t );

*t = T(std::forward<decltype(args)>(args)...);

}

else {

Default.expects( dt );

if (dt->init) {

dt->value() = T(std::forward<decltype(args)>(args)...);

}

else {

dt->construct(std::forward<decltype(args)>(args)...);

called_construct() = true;

}

}

}

auto construct_list(auto&& ...args) -> void {

if (has_t) {

Default.expects( t );

*t = T{std::forward<decltype(args)>(args)...};

}

else {

Default.expects( dt );

if (dt->init) {

dt->value() = T{std::forward<decltype(args)>(args)...};

}

else {

dt->construct_list(std::forward<decltype(args)>(args)...);

called_construct() = true;

}

}

}

auto value() noexcept -> T& {

if (has_t) {

Default.expects( t );

return *t;

}

else {

Default.expects( dt );

return dt->value();

}

}

{

// Predicate case

if constexpr (requires{ bool{ value(x) }; }) {

return value(x);

}

else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {

return false;

}

// Value case

else if constexpr (requires{ bool{x == value}; }) {

return x == value;

}

return false;

{

if constexpr ( is_castable_v<C, x> ) {

return static_cast<C>(x);

} else {

return nonesuch;

}

requires (

std::is_floating_point_v<C> &&

std::is_floating_point_v<CPP2_TYPEOF(x)> &&

sizeof(CPP2_TYPEOF(x)) > sizeof(C)

)

{

return nonesuch;

requires (

std::is_integral_v<C> &&

std::is_integral_v<CPP2_TYPEOF(x)> &&

std::is_signed_v<CPP2_TYPEOF(x)> != std::is_signed_v<C> &&

sizeof(CPP2_TYPEOF(x)) <= sizeof(C)

)

{

const C c = static_cast<C>(x);

Type.expects( // precondition check: must be round-trippable => not lossy

static_cast<CPP2_TYPEOF(x)>(c) == x && (c < C{}) == (x < CPP2_TYPEOF(x){}),

"dynamic lossy narrowing conversion attempt detected" CPP2_SOURCE_LOCATION_ARG

);

return c;

requires (!std::is_same_v<C, X> && requires { C{x}; })

{

// Experiment: Recognize the nested `::value_type` pattern for some dynamic library types

// like std::optional, and try to prevent accidental narrowing conversions even when

// those types themselves don't defend against them

if constexpr( requires { requires std::is_convertible_v<X, typename C::value_type>; } ) {

if constexpr( is_narrowing_v<typename C::value_type, X>) {

return nonesuch;

}

}

return C{x};

if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {

return std::get<I>( x );

}

else {

return nonesuch;

}

if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {

return std::get<I>( x );

}

else {

return nonesuch;

}

if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {

return std::get<I>( x );

}

else {

return nonesuch;

}

{

// Predicate case

if constexpr (requires{ bool{ value(operator_as< 0>(x)) }; }) { if (x.index() == 0) return value(operator_as< 0>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 1>(x)) }; }) { if (x.index() == 1) return value(operator_as< 1>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 2>(x)) }; }) { if (x.index() == 2) return value(operator_as< 2>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 3>(x)) }; }) { if (x.index() == 3) return value(operator_as< 3>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 4>(x)) }; }) { if (x.index() == 4) return value(operator_as< 4>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 5>(x)) }; }) { if (x.index() == 5) return value(operator_as< 5>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 6>(x)) }; }) { if (x.index() == 6) return value(operator_as< 6>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 7>(x)) }; }) { if (x.index() == 7) return value(operator_as< 7>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 8>(x)) }; }) { if (x.index() == 8) return value(operator_as< 8>(x)); }

else if constexpr (requires{ bool{ value(operator_as< 9>(x)) }; }) { if (x.index() == 9) return value(operator_as< 9>(x)); }

else if constexpr (requires{ bool{ value(operator_as<10>(x)) }; }) { if (x.index() == 10) return value(operator_as<10>(x)); }

else if constexpr (requires{ bool{ value(operator_as<11>(x)) }; }) { if (x.index() == 11) return value(operator_as<11>(x)); }

else if constexpr (requires{ bool{ value(operator_as<12>(x)) }; }) { if (x.index() == 12) return value(operator_as<12>(x)); }

else if constexpr (requires{ bool{ value(operator_as<13>(x)) }; }) { if (x.index() == 13) return value(operator_as<13>(x)); }

else if constexpr (requires{ bool{ value(operator_as<14>(x)) }; }) { if (x.index() == 14) return value(operator_as<14>(x)); }

else if constexpr (requires{ bool{ value(operator_as<15>(x)) }; }) { if (x.index() == 15) return value(operator_as<15>(x)); }

else if constexpr (requires{ bool{ value(operator_as<16>(x)) }; }) { if (x.index() == 16) return value(operator_as<16>(x)); }

else if constexpr (requires{ bool{ value(operator_as<17>(x)) }; }) { if (x.index() == 17) return value(operator_as<17>(x)); }

else if constexpr (requires{ bool{ value(operator_as<18>(x)) }; }) { if (x.index() == 18) return value(operator_as<18>(x)); }

else if constexpr (requires{ bool{ value(operator_as<19>(x)) }; }) { if (x.index() == 19) return value(operator_as<19>(x)); }

else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {