diff --git a/include/cpp2util.h b/include/cpp2util.h index 51d28639f0..1ee0a06f76 100644 --- a/include/cpp2util.h +++ b/include/cpp2util.h @@ -692,6 +692,11 @@ concept specialization_of_template_type_and_nttp = requires (X x) { { specialization_of_template_helper(std::forward(x)) } -> std::same_as; }; +template +concept boolean_testable = std::convertible_to && requires(X&& x) { + { !std::forward(x) } -> std::convertible_to; +}; + template concept dereferencable = requires (X x) { *x; }; @@ -775,6 +780,97 @@ auto pointer_eq(T const* a, T const* b) { return std::compare_three_way{}(a, b) == std::strong_ordering::equal; } +//----------------------------------------------------------------------- +// +// A type_find_if for iterating over types in parameter packs +// +// Note: This implementation works around limitations in gcc <12.1, +// Clang <13, and MSVC <19.29. Otherwise we could avoid type_it and use +// a lambda with an explicit parameter type list like this: +// +// template +// constexpr auto type_find_if(F&& fun) +// { +// std::size_t found = std::variant_npos; +// [&](std::index_sequence){ +// if constexpr ((requires { {CPP2_FORWARD(fun).template operator()()} -> std::convertible_to;} && ...)) { +// (((CPP2_FORWARD(fun).template operator()()) && (found = Is, true)) || ...); +// } +// }(std::index_sequence_for()); +// return found; +// } +// +// Note: The internal if constexpr could have else with static_assert. +// Unfortunately there doesn't seem to be a way to make it work on MSVC. +// +//----------------------------------------------------------------------- +// +template +struct type_it { + using type = T; + inline static const std::size_t index = Index; +}; + +template +constexpr auto type_find_if(F&& fun) +{ + std::size_t found = std::variant_npos; + [&](std::index_sequence){ + if constexpr ((requires { {CPP2_FORWARD(fun)(type_it{})} -> boolean_testable;} && ...)) { + ((CPP2_FORWARD(fun)(type_it{}) && (found = Is, true)) || ...); + } + }(std::index_sequence_for()); + return found; +} + +template class C, typename... Ts> +constexpr auto type_find_if(C const&, F&& fun) +{ + return type_find_if(CPP2_FORWARD(fun)); +} + +template +constexpr auto variant_contains_type(std::variant) +{ + if constexpr (is_any) { + return std::true_type{}; + } else { + return std::false_type{}; + } +} + +template +using constness_like_t = + std::conditional_t< + std::is_const_v< + std::remove_pointer_t< + std::remove_reference_t + > + >, + std::add_const_t, + std::remove_const_t + >; + +template +[[nodiscard]] constexpr auto&& forward_like(U&& x) noexcept +{ + constexpr bool is_adding_const = std::is_const_v>; + if constexpr (std::is_lvalue_reference_v) + { + if constexpr (is_adding_const) + return std::as_const(x); + else + return static_cast(x); + } + else + { + if constexpr (is_adding_const) + return std::move(std::as_const(x)); + else + return std::move(x); + } +} + //----------------------------------------------------------------------- // @@ -1924,215 +2020,63 @@ auto as(auto&& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT_AS) -> decltype(auto) // std::variant is and as // -// Common internal helper -// -template -constexpr auto operator_as( std::variant && x ) -> decltype(auto) { - if constexpr (I < std::variant_size_v>) { - return std::get( x ); - } - else { - return nonesuch; - } -} - -template -constexpr auto operator_as( std::variant & x ) -> decltype(auto) { - if constexpr (I < std::variant_size_v>) { - return std::get( x ); - } - else { - return nonesuch; - } -} - -template -constexpr auto operator_as( std::variant const& x ) -> decltype(auto) { - if constexpr (I < std::variant_size_v>) { - return std::get( x ); +template< typename C, specialization_of_template X > +constexpr auto is( X const& x ) -> auto +{ + if constexpr ( + std::is_same_v + || std::is_base_of_v + ) + { + return std::true_type{}; } else { - return nonesuch; + if (x.valueless_by_exception()) { + return std::is_same_v; + } + if constexpr ( + std::is_same_v + ) + { + if constexpr (requires { {variant_contains_type(std::declval())} -> std::same_as; }) { + return std::get_if(&x) != nullptr; + } + } + return type_find_if(x, [&](It const&) -> bool { + if (x.index() == It::index) { return std::is_same_v>;} + return false; + }) != std::variant_npos; } } -// is Type -// -template -constexpr auto operator_is( std::variant const& x ) { - return x.index(); -} - -template -auto is( std::variant const& x ); - - -// is Value -// -template -constexpr auto is( std::variant const& x, auto&& value ) -> bool +template X> +inline constexpr auto is( X const& x, auto&& value ) -> bool { - // 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 || requires{ &value.operator(); }) { + return type_find_if(x, [&](It const&) -> bool { + if (x.index() == It::index) { + if constexpr (valid_predicate(x))>) { + return value(std::get(x)); + } else if constexpr ( requires { bool{std::get(x) == value}; } ) { + return std::get(x) == value; + } + } return false; - } - - // Value case - else { - if constexpr (requires{ bool{ operator_as< 0>(x) == value }; }) { if (x.index() == 0) return operator_as< 0>(x) == value; } - if constexpr (requires{ bool{ operator_as< 1>(x) == value }; }) { if (x.index() == 1) return operator_as< 1>(x) == value; } - if constexpr (requires{ bool{ operator_as< 2>(x) == value }; }) { if (x.index() == 2) return operator_as< 2>(x) == value; } - if constexpr (requires{ bool{ operator_as< 3>(x) == value }; }) { if (x.index() == 3) return operator_as< 3>(x) == value; } - if constexpr (requires{ bool{ operator_as< 4>(x) == value }; }) { if (x.index() == 4) return operator_as< 4>(x) == value; } - if constexpr (requires{ bool{ operator_as< 5>(x) == value }; }) { if (x.index() == 5) return operator_as< 5>(x) == value; } - if constexpr (requires{ bool{ operator_as< 6>(x) == value }; }) { if (x.index() == 6) return operator_as< 6>(x) == value; } - if constexpr (requires{ bool{ operator_as< 7>(x) == value }; }) { if (x.index() == 7) return operator_as< 7>(x) == value; } - if constexpr (requires{ bool{ operator_as< 8>(x) == value }; }) { if (x.index() == 8) return operator_as< 8>(x) == value; } - if constexpr (requires{ bool{ operator_as< 9>(x) == value }; }) { if (x.index() == 9) return operator_as< 9>(x) == value; } - if constexpr (requires{ bool{ operator_as<10>(x) == value }; }) { if (x.index() == 10) return operator_as<10>(x) == value; } - if constexpr (requires{ bool{ operator_as<11>(x) == value }; }) { if (x.index() == 11) return operator_as<11>(x) == value; } - if constexpr (requires{ bool{ operator_as<12>(x) == value }; }) { if (x.index() == 12) return operator_as<12>(x) == value; } - if constexpr (requires{ bool{ operator_as<13>(x) == value }; }) { if (x.index() == 13) return operator_as<13>(x) == value; } - if constexpr (requires{ bool{ operator_as<14>(x) == value }; }) { if (x.index() == 14) return operator_as<14>(x) == value; } - if constexpr (requires{ bool{ operator_as<15>(x) == value }; }) { if (x.index() == 15) return operator_as<15>(x) == value; } - if constexpr (requires{ bool{ operator_as<16>(x) == value }; }) { if (x.index() == 16) return operator_as<16>(x) == value; } - if constexpr (requires{ bool{ operator_as<17>(x) == value }; }) { if (x.index() == 17) return operator_as<17>(x) == value; } - if constexpr (requires{ bool{ operator_as<18>(x) == value }; }) { if (x.index() == 18) return operator_as<18>(x) == value; } - if constexpr (requires{ bool{ operator_as<19>(x) == value }; }) { if (x.index() == 19) return operator_as<19>(x) == value; } - } - return false; + }) != std::variant_npos; } - -// as -// -template -auto is( std::variant const& x ) { - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() == 1) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() == 2) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() == 3) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() == 4) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() == 5) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() == 6) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() == 7) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() == 8) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() == 9) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return true; } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return true; } - if constexpr (std::is_same_v< T, empty > ) { - if (x.valueless_by_exception()) return true; - // Need to guard this with is_any otherwise the get_if is illegal - if constexpr (is_any) return std::get_if(&x) != nullptr; - } - return false; -} - -template -auto as( std::variant && x ) -> decltype(auto) { - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() == 1) return operator_as<1>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() == 2) return operator_as<2>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() == 3) return operator_as<3>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() == 4) return operator_as<4>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() == 5) return operator_as<5>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() == 6) return operator_as<6>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() == 7) return operator_as<7>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() == 8) return operator_as<8>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() == 9) return operator_as<9>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } - Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); -} - -template -auto as( std::variant & x ) -> decltype(auto) { - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() == 1) return operator_as<1>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() == 2) return operator_as<2>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() == 3) return operator_as<3>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() == 4) return operator_as<4>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() == 5) return operator_as<5>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() == 6) return operator_as<6>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() == 7) return operator_as<7>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() == 8) return operator_as<8>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() == 9) return operator_as<9>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } - Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); -} - -template -auto as( std::variant const& x ) -> decltype(auto) { - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() == 1) return operator_as<1>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() == 2) return operator_as<2>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() == 3) return operator_as<3>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() == 4) return operator_as<4>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() == 5) return operator_as<5>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() == 6) return operator_as<6>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() == 7) return operator_as<7>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() == 8) return operator_as<8>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() == 9) return operator_as<9>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } - if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } - Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); +template< typename C, specialization_of_template X > +auto as(X&& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT_AS) -> decltype(auto) +{ + constness_like_t* ptr = nullptr; + type_find_if(CPP2_FORWARD(x), [&](It const&) -> bool { + if constexpr (std::is_same_v< typename It::type, C >) { if (CPP2_FORWARD(x).index() == It::index) { ptr = &std::get(x); return true; } }; + return false; + }); + if (!ptr) { Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); } + return cpp2::forward_like(*ptr); } - //------------------------------------------------------------------------------------------------------------- // std::any is and as // diff --git a/regression-tests/mixed-is-as-value-with-variant.cpp2 b/regression-tests/mixed-is-as-value-with-variant.cpp2 new file mode 100644 index 0000000000..0f23617d84 --- /dev/null +++ b/regression-tests/mixed-is-as-value-with-variant.cpp2 @@ -0,0 +1,112 @@ +auto in(int min, int max) { + return [=](int x){ return min <= x && x <= max; }; +} + +test: (forward v) = { + if v is (42) { + std::cout << " 42"; + } + if v is (24) { + std::cout << " 24"; + } + if v is (100) { + std::cout << " 100"; + } + if v is (-100) { + std::cout << " -100"; + } + if v is (314) { + std::cout << " 314"; + } + if v is (std::optional(100)) { + std::cout << " std::optional(100)"; + } + if v is (std::any(-100)) { + std::cout << " std::any(-100)"; + } + if v is (new(1000)) { + std::cout << " std::unique_ptr(1000)"; + } + i : int = 314; + if v is (i&) { + std::cout << " *int(314)"; + } + if v is (in(0,100)) { + std::cout << " in(0,100)"; + } + std::cout << "\n---" << std::endl; +} + +my_variant: type == std::variant, std::any, *int, std::unique_ptr>; + +main: () -> int = { + + v: std::variant, std::any, *int, std::unique_ptr, my_variant> = (); + + header(1, "std::monostate"); + v..emplace<0>(); + test(v); + + header(1, "int(42)"); + v..emplace<1>(42); + test(v); + + header(1, "int(24)"); + v..emplace<2>(24); + test(v); + + header(1, "std::optional(100)"); + v..emplace<3>(100); + test(v); + + header(1, "std::any(-100)"); + v..emplace<4>(-100); + test(v); + + i : int = 314; + header(1, "*int(314)"); + v..emplace<5>(i&); + test(v); + + header(1, "std::unique_ptr(1000)"); + v..emplace<6>(new(1000)); + test(v); + + header(1, "my_variant(std::monostate)"); + v..emplace<7>(); + test(v); + + header(1, "my_variant(int(42))"); + v..emplace<7>(); + std::get<7>(v)..emplace<1>(42); + test(v); + + header(1, "my_variant(int(24))"); + v..emplace<7>(); + std::get<7>(v)..emplace<2>(24); + test(v); + + header(1, "my_variant(std::optional(100))"); + v..emplace<7>(); + std::get<7>(v)..emplace<3>(100); + test(v); + + header(1, "my_variant(std::any(-100))"); + v..emplace<7>(); + std::get<7>(v)..emplace<4>(-100); + test(v); + + header(1, "my_variant(*int(314))"); + v..emplace<7>(); + std::get<7>(v)..emplace<5>(i&); + test(v); + + header(1, "my_variant(std::unique_ptr(1000))"); + v..emplace<7>(); + std::get<7>(v)..emplace<6>(new(1000)); + test(v); +} + +header: (lvl : int, msg: std::string) = { + std::cout << std::string(lvl, '#') << " " << msg << std::endl; +} diff --git a/regression-tests/mixed-is-as-variant.cpp2 b/regression-tests/mixed-is-as-variant.cpp2 new file mode 100644 index 0000000000..1af72815d9 --- /dev/null +++ b/regression-tests/mixed-is-as-variant.cpp2 @@ -0,0 +1,91 @@ +test: (forward v) = { + std::cout << "v is empty = (v is void)$" << std::endl; + std::cout << "v is std::monostate = (v is std::monostate)$" << std::endl; + std::cout << "v is X< 0> = (v is X< 0>)$,\t(v as X< 1>) = " << expect_no_throw(forward v, :(forward v) v as X<0>) << std::endl; + std::cout << "v is X< 1> = (v is X< 1>)$,\t(v as X< 1>).to_string() = (expect_no_throw(forward v, :(forward v) -> std::string = { return (v as X< 1>).to_string();}))$" << std::endl; + std::cout << "v is X<19> = (v is X<19>)$,\t(v as X<19>).to_string() = (expect_no_throw(forward v, :(forward v) -> std::string = { return (v as X<19>).to_string();}))$" << std::endl; + std::cout << "v is X<20> = (v is X<20>)$,\t(v as X<20>) = " << expect_no_throw(forward v, :(forward v) v as X<20>) << std::endl; + std::cout << std::endl; +} + +main: () -> int = { + + v: std::variant, X< 2>, X< 3>, X< 4>, X< 5>, X< 6>, X< 7>, X< 8>, X< 9>, X<10>, + X<11>, X<12>, X<13>, X<14>, X<15>, X<16>, X<17>, X<18>, X<19>, X<20> > = (); + + header(1, "std::monostate"); + v..emplace<0>(); + run_tests(v); + + header(1, "X<1>"); + v..emplace<1>(); + run_tests(v); + + header(1, "X<19>"); + v..emplace<19>(); + run_tests(v); + + header(1, "X<20>"); + v..emplace<20>(); + run_tests(v); + + header(1, "X<10>(std::exception)"); + set_to_valueless_by_exception<10>(v); + run_tests(v); + +} + +run_tests: (forward v) = { + header(2, "v as lvalue reference"); + test(v); + + header(2, "v as const lvalue reference"); + test(std::as_const(v)); + + header(2, "v as rvalue reference"); + test(move v); +} + +header: (lvl : int, msg: std::string) = { + std::cout << std::string(lvl, '#') << " " << msg << "\n" << std::endl; +} + +template +struct X { + operator int() const { return I; } + X() = default; + X(std::exception const& e) { throw e; } + auto to_string() const { return "X<" + std::to_string(I) + ">"; } +}; + +template +void set_to_valueless_by_exception(auto& v) try { + v.template emplace(std::runtime_error("make valueless")); +} catch (...) {} + +auto expect_no_throw(auto&& l) -> std::string try { + if constexpr ( requires { { l() } -> std::convertible_to; }) { + return l(); + } else { + l(); + return "works!"; + } +} catch (std::exception const& e) { + return e.what(); +} catch (...) { + return "unknown exception!"; +} + +auto expect_no_throw(auto&& v, auto&& l) -> std::string try { + if constexpr ( requires { { l(v) } -> std::convertible_to; }) { + return l(v); + } else { + l(v); + return "works!"; + } +} catch (std::exception const& e) { + return e.what(); +} catch (...) { + return "unknown exception!"; +} diff --git a/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..1dcf1c3700 --- /dev/null +++ b/regression-tests/test-results/apple-clang-14-c++2b/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-check.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-check.cpp.execution index 60dbded0ba..8c939be081 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-check.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-check.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(1007) decltype(auto) cpp2::impl::assert_in_bounds(auto &&, std::source_location) [arg = 5, x:auto = std::vector]: Bounds safety violation: out of bounds access attempt detected - attempted access at index 5, [min,max] range is [0,4] +../../../include/cpp2util.h(1103) decltype(auto) cpp2::impl::assert_in_bounds(auto &&, std::source_location) [arg = 5, x:auto = std::vector]: Bounds safety violation: out of bounds access attempt detected - attempted access at index 5, [min,max] range is [0,4] diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-safety-with-assert.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-safety-with-assert.cpp.execution index 6effcd5768..148e3b7d8f 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-safety-with-assert.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-bounds-safety-with-assert.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(819) : Bounds safety violation +../../../include/cpp2util.h(915) : Bounds safety violation diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-initialization-safety-3-contract-violation.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-initialization-safety-3-contract-violation.cpp.execution index cda862f7c7..d1b29d5d47 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/mixed-initialization-safety-3-contract-violation.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-initialization-safety-3-contract-violation.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(819) : Contract violation: fill: value must contain at least count elements +../../../include/cpp2util.h(915) : Contract violation: fill: value must contain at least count elements diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..1dcf1c3700 --- /dev/null +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + diff --git a/regression-tests/test-results/apple-clang-15-c++2b/mixed-lifetime-safety-and-null-contracts.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/mixed-lifetime-safety-and-null-contracts.cpp.execution index 121149a600..7fd8ae38b6 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/mixed-lifetime-safety-and-null-contracts.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/mixed-lifetime-safety-and-null-contracts.cpp.execution @@ -1,2 +1,2 @@ sending error to my framework... [dynamic null dereference attempt detected] -from source location: ../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = int *&] +from source location: ../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = int *&] diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-expected-not-null.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-expected-not-null.cpp.execution index 3f3a6e9f41..d944874ab1 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-expected-not-null.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-expected-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::expected]: Null safety violation: std::expected has an unexpected value +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::expected]: Null safety violation: std::expected has an unexpected value diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-optional-not-null.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-optional-not-null.cpp.execution index 9529414a02..19ed72cebe 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-optional-not-null.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-optional-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::optional]: Null safety violation: std::optional does not contain a value +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::optional]: Null safety violation: std::optional does not contain a value diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-shared-ptr-not-null.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-shared-ptr-not-null.cpp.execution index 3eba52e06f..bae46a9581 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-shared-ptr-not-null.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-shared-ptr-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::shared_ptr]: Null safety violation: std::shared_ptr is empty +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::shared_ptr]: Null safety violation: std::shared_ptr is empty diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-unique-ptr-not-null.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-unique-ptr-not-null.cpp.execution index a56bf43053..8e194df283 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-unique-ptr-not-null.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/pure2-assert-unique-ptr-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::unique_ptr]: Null safety violation: std::unique_ptr is empty +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::unique_ptr]: Null safety violation: std::unique_ptr is empty diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-default-arguments.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-default-arguments.cpp.execution index 71d4adcb87..a49873036a 100644 --- a/regression-tests/test-results/apple-clang-15-c++2b/pure2-default-arguments.cpp.execution +++ b/regression-tests/test-results/apple-clang-15-c++2b/pure2-default-arguments.cpp.execution @@ -1,2 +1,4 @@ calling: -012an older compiler +012 +an older compiler +1, 1, 66 diff --git a/regression-tests/test-results/clang-12-c++20/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/clang-12-c++20/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/clang-12-c++20/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/clang-12-c++20/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/clang-12-c++20/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/clang-12-c++20/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..1dcf1c3700 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20-libcpp/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + diff --git a/regression-tests/test-results/clang-15-c++20/mixed-bounds-check.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-bounds-check.cpp.execution index 60dbded0ba..8c939be081 100644 --- a/regression-tests/test-results/clang-15-c++20/mixed-bounds-check.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/mixed-bounds-check.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(1007) decltype(auto) cpp2::impl::assert_in_bounds(auto &&, std::source_location) [arg = 5, x:auto = std::vector]: Bounds safety violation: out of bounds access attempt detected - attempted access at index 5, [min,max] range is [0,4] +../../../include/cpp2util.h(1103) decltype(auto) cpp2::impl::assert_in_bounds(auto &&, std::source_location) [arg = 5, x:auto = std::vector]: Bounds safety violation: out of bounds access attempt detected - attempted access at index 5, [min,max] range is [0,4] diff --git a/regression-tests/test-results/clang-15-c++20/mixed-bounds-safety-with-assert.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-bounds-safety-with-assert.cpp.execution index 6effcd5768..148e3b7d8f 100644 --- a/regression-tests/test-results/clang-15-c++20/mixed-bounds-safety-with-assert.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/mixed-bounds-safety-with-assert.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(819) : Bounds safety violation +../../../include/cpp2util.h(915) : Bounds safety violation diff --git a/regression-tests/test-results/clang-15-c++20/mixed-initialization-safety-3-contract-violation.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-initialization-safety-3-contract-violation.cpp.execution index cda862f7c7..d1b29d5d47 100644 --- a/regression-tests/test-results/clang-15-c++20/mixed-initialization-safety-3-contract-violation.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/mixed-initialization-safety-3-contract-violation.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(819) : Contract violation: fill: value must contain at least count elements +../../../include/cpp2util.h(915) : Contract violation: fill: value must contain at least count elements diff --git a/regression-tests/test-results/clang-15-c++20/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/clang-15-c++20/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/clang-15-c++20/mixed-lifetime-safety-and-null-contracts.cpp.execution b/regression-tests/test-results/clang-15-c++20/mixed-lifetime-safety-and-null-contracts.cpp.execution index 121149a600..7fd8ae38b6 100644 --- a/regression-tests/test-results/clang-15-c++20/mixed-lifetime-safety-and-null-contracts.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/mixed-lifetime-safety-and-null-contracts.cpp.execution @@ -1,2 +1,2 @@ sending error to my framework... [dynamic null dereference attempt detected] -from source location: ../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = int *&] +from source location: ../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = int *&] diff --git a/regression-tests/test-results/clang-15-c++20/pure2-assert-optional-not-null.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-assert-optional-not-null.cpp.execution index 9529414a02..19ed72cebe 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-assert-optional-not-null.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-assert-optional-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::optional]: Null safety violation: std::optional does not contain a value +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::optional]: Null safety violation: std::optional does not contain a value diff --git a/regression-tests/test-results/clang-15-c++20/pure2-assert-shared-ptr-not-null.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-assert-shared-ptr-not-null.cpp.execution index 3eba52e06f..bae46a9581 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-assert-shared-ptr-not-null.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-assert-shared-ptr-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::shared_ptr]: Null safety violation: std::shared_ptr is empty +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::shared_ptr]: Null safety violation: std::shared_ptr is empty diff --git a/regression-tests/test-results/clang-15-c++20/pure2-assert-unique-ptr-not-null.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-assert-unique-ptr-not-null.cpp.execution index a56bf43053..8e194df283 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-assert-unique-ptr-not-null.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-assert-unique-ptr-not-null.cpp.execution @@ -1 +1 @@ -../../../include/cpp2util.h(898) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::unique_ptr]: Null safety violation: std::unique_ptr is empty +../../../include/cpp2util.h(994) decltype(auto) cpp2::impl::assert_not_null(auto &&, std::source_location) [arg:auto = std::unique_ptr]: Null safety violation: std::unique_ptr is empty diff --git a/regression-tests/test-results/clang-15-c++20/pure2-default-arguments.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-default-arguments.cpp.execution index 71d4adcb87..a49873036a 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-default-arguments.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-default-arguments.cpp.execution @@ -1,2 +1,4 @@ calling: -012an older compiler +012 +an older compiler +1, 1, 66 diff --git a/regression-tests/test-results/clang-18-c++20/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/clang-18-c++20/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++20/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/clang-18-c++20/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/clang-18-c++20/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++20/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..1dcf1c3700 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++23-libcpp/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad_variant_access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad_variant_access +v is X< 1> = false, (v as X< 1>).to_string() = bad_variant_access +v is X<19> = false, (v as X<19>).to_string() = bad_variant_access +v is X<20> = false, (v as X<20>) = bad_variant_access + diff --git a/regression-tests/test-results/gcc-10-c++20/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/gcc-10-c++20/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/gcc-10-c++20/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/gcc-10-c++20/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/gcc-10-c++20/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/gcc-10-c++20/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-default-arguments.cpp.output b/regression-tests/test-results/gcc-10-c++20/pure2-default-arguments.cpp.output index 471a03f02e..7ed50a83d1 100644 --- a/regression-tests/test-results/gcc-10-c++20/pure2-default-arguments.cpp.output +++ b/regression-tests/test-results/gcc-10-c++20/pure2-default-arguments.cpp.output @@ -1,66 +1,66 @@ In file included from pure2-default-arguments.cpp:7: ../../../include/cpp2util.h:2086:28: error: local variable ‘obj’ may not appear in this context - 2086 | auto as( std::variant & x ) -> decltype(auto) { + 2086 | template | ^~~ ../../../include/cpp2util.h:2047:34: note: in definition of macro ‘CPP2_UFCS_IDENTITY’ - 2047 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } - | ^~~~~~~~~~~ + 2047 | return false; + | ^ ../../../include/cpp2util.h:2086:15: note: in expansion of macro ‘CPP2_FORWARD’ - 2086 | auto as( std::variant & x ) -> decltype(auto) { + 2086 | template | ^~~~~~~~~~~~ ../../../include/cpp2util.h:2107:22: note: in expansion of macro ‘CPP2_UFCS_CONSTRAINT_ARG’ - 2107 | Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); - | ^~~~~~~~~~~~~~~~~~~~~~~~ + 2107 | } + | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ pure2-default-arguments.cpp2:6:22: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ ../../../include/cpp2util.h:2086:92: error: local variable ‘params’ may not appear in this context - 2086 | auto as( std::variant & x ) -> decltype(auto) { + 2086 | template | ^ ../../../include/cpp2util.h:2047:34: note: in definition of macro ‘CPP2_UFCS_IDENTITY’ - 2047 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } - | ^~~~~~~~~~~ + 2047 | return false; + | ^ ../../../include/cpp2util.h:2086:79: note: in expansion of macro ‘CPP2_FORWARD’ - 2086 | auto as( std::variant & x ) -> decltype(auto) { + 2086 | template | ^ ../../../include/cpp2util.h:2107:22: note: in expansion of macro ‘CPP2_UFCS_CONSTRAINT_ARG’ - 2107 | Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); - | ^~~~~~~~~~~~~~~~~~~~~~~~ + 2107 | } + | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ pure2-default-arguments.cpp2:6:22: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ ../../../include/cpp2util.h:2087:74: error: local variable ‘obj’ may not appear in this context - 2087 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } + 2087 | requires (std::is_same_v && !std::is_same_v && !std::is_same_v) | ^~~ ../../../include/cpp2util.h:2047:34: note: in definition of macro ‘CPP2_UFCS_IDENTITY’ - 2047 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } - | ^~~~~~~~~~~ + 2047 | return false; + | ^ ../../../include/cpp2util.h:2087:61: note: in expansion of macro ‘CPP2_FORWARD’ - 2087 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } + 2087 | requires (std::is_same_v && !std::is_same_v && !std::is_same_v) | ^~~~~~~~~~~~ ../../../include/cpp2util.h:2107:22: note: in expansion of macro ‘CPP2_UFCS_CONSTRAINT_ARG’ - 2107 | Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); - | ^~~~~~~~~~~~~~~~~~~~~~~~ + 2107 | } + | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ pure2-default-arguments.cpp2:6:22: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ ../../../include/cpp2util.h:2087:93: error: local variable ‘params’ may not appear in this context - 2087 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } + 2087 | requires (std::is_same_v && !std::is_same_v && !std::is_same_v) | ^~~~~~ ../../../include/cpp2util.h:2047:34: note: in definition of macro ‘CPP2_UFCS_IDENTITY’ - 2047 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } - | ^~~~~~~~~~~ + 2047 | return false; + | ^ ../../../include/cpp2util.h:2087:80: note: in expansion of macro ‘CPP2_FORWARD’ - 2087 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() == 0) return operator_as<0>(x); } + 2087 | requires (std::is_same_v && !std::is_same_v && !std::is_same_v) | ^~~~~~~~~~~~ ../../../include/cpp2util.h:2107:22: note: in expansion of macro ‘CPP2_UFCS_CONSTRAINT_ARG’ - 2107 | Throw( std::bad_variant_access(), "'as' cast failed for 'variant'"); - | ^~~~~~~~~~~~~~~~~~~~~~~~ + 2107 | } + | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ pure2-default-arguments.cpp2:6:22: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ pure2-default-arguments.cpp2:6:61: error: ‘std::source_location’ has not been declared diff --git a/regression-tests/test-results/gcc-13-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output b/regression-tests/test-results/gcc-13-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output index 2bdfe9d165..b08a69eb07 100644 --- a/regression-tests/test-results/gcc-13-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output +++ b/regression-tests/test-results/gcc-13-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output @@ -1,41 +1,41 @@ In file included from mixed-bugfix-for-ufcs-non-local.cpp:6: ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:13:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:13:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:31:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:31:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:33:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:33:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid diff --git a/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/gcc-13-c++2b/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-default-arguments.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-default-arguments.cpp.execution index 13c1bc1e73..afb167febc 100644 --- a/regression-tests/test-results/gcc-13-c++2b/pure2-default-arguments.cpp.execution +++ b/regression-tests/test-results/gcc-13-c++2b/pure2-default-arguments.cpp.execution @@ -1,2 +1,4 @@ calling: int main(int, char**) -012an older compiler +012 +an older compiler +1, 1, 66 diff --git a/regression-tests/test-results/gcc-14-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output b/regression-tests/test-results/gcc-14-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output index 2bdfe9d165..b08a69eb07 100644 --- a/regression-tests/test-results/gcc-14-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output +++ b/regression-tests/test-results/gcc-14-c++2b/mixed-bugfix-for-ufcs-non-local.cpp.output @@ -1,41 +1,41 @@ In file included from mixed-bugfix-for-ufcs-non-local.cpp:6: ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:13:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:13:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:31:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:31:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:33:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:33:36: error: template argument 1 is invalid ../../../include/cpp2util.h:2100:1: error: lambda-expression in template parameter type - 2100 | if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } + 2100 | { | ^ ../../../include/cpp2util.h:2137:59: note: in expansion of macro ‘CPP2_UFCS_’ - 2137 | // std::any is and as + 2137 | | ^ mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’ mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid diff --git a/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bfa0bda566 --- /dev/null +++ b/regression-tests/test-results/gcc-14-c++2b/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution index 0d1459552f..afb167febc 100644 --- a/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution +++ b/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution @@ -1,4 +1,4 @@ calling: int main(int, char**) 012 -a newer compiler +an older compiler 1, 1, 66 diff --git a/regression-tests/test-results/mixed-is-as-value-with-variant.cpp b/regression-tests/test-results/mixed-is-as-value-with-variant.cpp new file mode 100644 index 0000000000..c43d306b8f --- /dev/null +++ b/regression-tests/test-results/mixed-is-as-value-with-variant.cpp @@ -0,0 +1,142 @@ + + +//=== Cpp2 type declarations ==================================================== + + +#include "cpp2util.h" + +#line 1 "mixed-is-as-value-with-variant.cpp2" + + +//=== Cpp2 type definitions and function declarations =========================== + +#line 1 "mixed-is-as-value-with-variant.cpp2" +auto in(int min, int max) { + return [=](int x){ return min <= x && x <= max; }; +} + +#line 5 "mixed-is-as-value-with-variant.cpp2" +auto test(auto&& v) -> void; + +#line 40 "mixed-is-as-value-with-variant.cpp2" +using my_variant = std::variant,std::any,int*,std::unique_ptr>; + +[[nodiscard]] auto main() -> int; + +#line 110 "mixed-is-as-value-with-variant.cpp2" +auto header(cpp2::impl::in lvl, cpp2::impl::in msg) -> void; + +//=== Cpp2 function definitions ================================================= + +#line 1 "mixed-is-as-value-with-variant.cpp2" + +#line 5 "mixed-is-as-value-with-variant.cpp2" +auto test(auto&& v) -> void{ + if (cpp2::impl::is(v, (42))) { + std::cout << " 42"; + } + if (cpp2::impl::is(v, (24))) { + std::cout << " 24"; + } + if (cpp2::impl::is(v, (100))) { + std::cout << " 100"; + } + if (cpp2::impl::is(v, (-100))) { + std::cout << " -100"; + } + if (cpp2::impl::is(v, (314))) { + std::cout << " 314"; + } + if (cpp2::impl::is(v, (std::optional(100)))) { + std::cout << " std::optional(100)"; + } + if (cpp2::impl::is(v, (std::any(-100)))) { + std::cout << " std::any(-100)"; + } + if (cpp2::impl::is(v, (cpp2_new(1000)))) { + std::cout << " std::unique_ptr(1000)"; + } + int i {314}; + if (cpp2::impl::is(v, (&i))) { + std::cout << " *int(314)"; + } + if (cpp2::impl::is(CPP2_FORWARD(v), (in(0, 100)))) { + std::cout << " in(0,100)"; + } + std::cout << "\n---" << std::endl; +} + +#line 42 "mixed-is-as-value-with-variant.cpp2" +[[nodiscard]] auto main() -> int{ + + std::variant,std::any,int*,std::unique_ptr,my_variant> v {}; + + header(1, "std::monostate"); + v.emplace<0>(); + test(v); + + header(1, "int(42)"); + v.emplace<1>(42); + test(v); + + header(1, "int(24)"); + v.emplace<2>(24); + test(v); + + header(1, "std::optional(100)"); + v.emplace<3>(100); + test(v); + + header(1, "std::any(-100)"); + v.emplace<4>(-100); + test(v); + + int i {314}; + header(1, "*int(314)"); + v.emplace<5>(&i); + test(v); + + header(1, "std::unique_ptr(1000)"); + v.emplace<6>(cpp2_new(1000)); + test(v); + + header(1, "my_variant(std::monostate)"); + v.emplace<7>(); + test(v); + + header(1, "my_variant(int(42))"); + v.emplace<7>(); + std::get<7>(v).emplace<1>(42); + test(v); + + header(1, "my_variant(int(24))"); + v.emplace<7>(); + std::get<7>(v).emplace<2>(24); + test(v); + + header(1, "my_variant(std::optional(100))"); + v.emplace<7>(); + std::get<7>(v).emplace<3>(100); + test(v); + + header(1, "my_variant(std::any(-100))"); + v.emplace<7>(); + std::get<7>(v).emplace<4>(-100); + test(v); + + header(1, "my_variant(*int(314))"); + v.emplace<7>(); + std::get<7>(v).emplace<5>(&i); + test(v); + + header(1, "my_variant(std::unique_ptr(1000))"); + v.emplace<7>(); + std::get<7>(v).emplace<6>(cpp2_new(1000)); + test(cpp2::move(v)); +} + +#line 110 "mixed-is-as-value-with-variant.cpp2" +auto header(cpp2::impl::in lvl, cpp2::impl::in msg) -> void{ + std::cout << std::string(lvl, '#') << " " << msg << std::endl; +} + diff --git a/regression-tests/test-results/mixed-is-as-value-with-variant.cpp2.output b/regression-tests/test-results/mixed-is-as-value-with-variant.cpp2.output new file mode 100644 index 0000000000..20ca411a38 --- /dev/null +++ b/regression-tests/test-results/mixed-is-as-value-with-variant.cpp2.output @@ -0,0 +1,2 @@ +mixed-is-as-value-with-variant.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks) + diff --git a/regression-tests/test-results/mixed-is-as-variant.cpp b/regression-tests/test-results/mixed-is-as-variant.cpp new file mode 100644 index 0000000000..c65063d506 --- /dev/null +++ b/regression-tests/test-results/mixed-is-as-variant.cpp @@ -0,0 +1,125 @@ + + +//=== Cpp2 type declarations ==================================================== + + +#include "cpp2util.h" + +#line 1 "mixed-is-as-variant.cpp2" + + +//=== Cpp2 type definitions and function declarations =========================== + +#line 1 "mixed-is-as-variant.cpp2" +auto test(auto&& v) -> void; + +#line 11 "mixed-is-as-variant.cpp2" +[[nodiscard]] auto main() -> int; + +#line 39 "mixed-is-as-variant.cpp2" +auto run_tests(auto&& v) -> void; + +#line 50 "mixed-is-as-variant.cpp2" +auto header(cpp2::impl::in lvl, cpp2::impl::in msg) -> void; +#line 53 "mixed-is-as-variant.cpp2" + +template +struct X { + operator int() const { return I; } + X() = default; + X(std::exception const& e) { throw e; } + auto to_string() const { return "X<" + std::to_string(I) + ">"; } +}; + +template +void set_to_valueless_by_exception(auto& v) try { + v.template emplace(std::runtime_error("make valueless")); +} catch (...) {} + +auto expect_no_throw(auto&& l) -> std::string try { + if constexpr ( requires { { l() } -> std::convertible_to; }) { + return l(); + } else { + l(); + return "works!"; + } +} catch (std::exception const& e) { + return e.what(); +} catch (...) { + return "unknown exception!"; +} + +auto expect_no_throw(auto&& v, auto&& l) -> std::string try { + if constexpr ( requires { { l(v) } -> std::convertible_to; }) { + return l(v); + } else { + l(v); + return "works!"; + } +} catch (std::exception const& e) { + return e.what(); +} catch (...) { + return "unknown exception!"; +} + + +//=== Cpp2 function definitions ================================================= + +#line 1 "mixed-is-as-variant.cpp2" +auto test(auto&& v) -> void{ +#line 2 "mixed-is-as-variant.cpp2" + std::cout << "v is empty = " + cpp2::to_string(cpp2::impl::is(v)) + "" << std::endl; + std::cout << "v is std::monostate = " + cpp2::to_string(cpp2::impl::is(v)) + "" << std::endl; + std::cout << "v is X< 0> = " + cpp2::to_string(cpp2::impl::is>(v)) + ",\t(v as X< 1>) = " << expect_no_throw(CPP2_FORWARD(v), [](auto&& v) -> auto { return cpp2::impl::as_>(CPP2_FORWARD(v)); }) << std::endl; + std::cout << "v is X< 1> = " + cpp2::to_string(cpp2::impl::is>(v)) + ",\t(v as X< 1>).to_string() = " + cpp2::to_string(expect_no_throw(CPP2_FORWARD(v), [](auto&& v) -> std::string{return CPP2_UFCS(to_string)((cpp2::impl::as_>(CPP2_FORWARD(v)))); })) + "" << std::endl; + std::cout << "v is X<19> = " + cpp2::to_string(cpp2::impl::is>(v)) + ",\t(v as X<19>).to_string() = " + cpp2::to_string(expect_no_throw(CPP2_FORWARD(v), [](auto&& v) -> std::string{return CPP2_UFCS(to_string)((cpp2::impl::as_>(CPP2_FORWARD(v)))); })) + "" << std::endl; + std::cout << "v is X<20> = " + cpp2::to_string(cpp2::impl::is>(v)) + ",\t(v as X<20>) = " << expect_no_throw(CPP2_FORWARD(v), [](auto&& v) -> auto { return cpp2::impl::as_>(CPP2_FORWARD(v)); }) << std::endl; + std::cout << std::endl; +} + +#line 11 "mixed-is-as-variant.cpp2" +[[nodiscard]] auto main() -> int{ + + std::variant,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>,X<9>,X<10>,X<11>,X<12>,X<13>,X<14>,X<15>,X<16>,X<17>,X<18>,X<19>,X<20>> v { + + }; + + header(1, "std::monostate"); + v.emplace<0>(); + run_tests(v); + + header(1, "X<1>"); + v.emplace<1>(); + run_tests(v); + + header(1, "X<19>"); + v.emplace<19>(); + run_tests(v); + + header(1, "X<20>"); + v.emplace<20>(); + run_tests(v); + + header(1, "X<10>(std::exception)"); + set_to_valueless_by_exception<10>(v); + run_tests(cpp2::move(v)); + +} + +#line 39 "mixed-is-as-variant.cpp2" +auto run_tests(auto&& v) -> void{ + header(2, "v as lvalue reference"); + test(v); + + header(2, "v as const lvalue reference"); + test(std::as_const(v)); + + header(2, "v as rvalue reference"); + test(std::move(CPP2_FORWARD(v))); +} + +#line 50 "mixed-is-as-variant.cpp2" +auto header(cpp2::impl::in lvl, cpp2::impl::in msg) -> void{ + std::cout << std::string(lvl, '#') << " " << msg << "\n" << std::endl; +} + diff --git a/regression-tests/test-results/mixed-is-as-variant.cpp2.output b/regression-tests/test-results/mixed-is-as-variant.cpp2.output new file mode 100644 index 0000000000..9b27359b0f --- /dev/null +++ b/regression-tests/test-results/mixed-is-as-variant.cpp2.output @@ -0,0 +1,2 @@ +mixed-is-as-variant.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks) + diff --git a/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.output b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.output new file mode 100644 index 0000000000..f46ea0d253 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-value-with-variant.cpp.output @@ -0,0 +1 @@ +mixed-is-as-value-with-variant.cpp diff --git a/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bd2d00c276 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + diff --git a/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.output b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.output new file mode 100644 index 0000000000..e2100d41dc --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/mixed-is-as-variant.cpp.output @@ -0,0 +1 @@ +mixed-is-as-variant.cpp diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-assert-expected-not-null.cpp.output b/regression-tests/test-results/msvc-2022-c++20/pure2-assert-expected-not-null.cpp.output index e069d85fd9..c953444d7a 100644 --- a/regression-tests/test-results/msvc-2022-c++20/pure2-assert-expected-not-null.cpp.output +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-assert-expected-not-null.cpp.output @@ -6,7 +6,7 @@ pure2-assert-expected-not-null.cpp2(7): error C2143: syntax error: missing ';' b pure2-assert-expected-not-null.cpp2(7): error C2143: syntax error: missing ';' before '}' pure2-assert-expected-not-null.cpp2(9): error C2065: 'ex': undeclared identifier pure2-assert-expected-not-null.cpp2(9): error C2672: 'cpp2::impl::assert_not_null': no matching overloaded function found -..\..\..\include\cpp2util.h(898): note: could be 'decltype(auto) cpp2::impl::assert_not_null(_T0 &&,std::source_location)' +..\..\..\include\cpp2util.h(994): note: could be 'decltype(auto) cpp2::impl::assert_not_null(_T0 &&,std::source_location)' pure2-assert-expected-not-null.cpp2(14): error C2039: 'expected': is not a member of 'std' predefined C++ types (compiler internal)(347): note: see declaration of 'std' pure2-assert-expected-not-null.cpp2(14): error C2062: type 'int' unexpected @@ -19,4 +19,4 @@ pure2-assert-expected-not-null.cpp2(14): note: while trying to match the argumen pure2-assert-expected-not-null.cpp2(14): error C2143: syntax error: missing ';' before '}' pure2-assert-expected-not-null.cpp2(15): error C2065: 'ex': undeclared identifier pure2-assert-expected-not-null.cpp2(15): error C2672: 'cpp2::impl::assert_not_null': no matching overloaded function found -..\..\..\include\cpp2util.h(898): note: could be 'decltype(auto) cpp2::impl::assert_not_null(_T0 &&,std::source_location)' +..\..\..\include\cpp2util.h(994): note: could be 'decltype(auto) cpp2::impl::assert_not_null(_T0 &&,std::source_location)' diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-default-arguments.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-default-arguments.cpp.execution index 75f26d0fc7..28b9d2515f 100644 --- a/regression-tests/test-results/msvc-2022-c++20/pure2-default-arguments.cpp.execution +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-default-arguments.cpp.execution @@ -1,2 +1,4 @@ calling: int __cdecl main(const int,char **) -012a newer compiler +012 +a newer compiler +1, 1, 66 diff --git a/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.execution new file mode 100644 index 0000000000..13a1c120c5 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.execution @@ -0,0 +1,42 @@ +# std::monostate + +--- +# int(42) + 42 in(0,100) +--- +# int(24) + 24 in(0,100) +--- +# std::optional(100) + 100 std::optional(100) +--- +# std::any(-100) + +--- +# *int(314) + +--- +# std::unique_ptr(1000) + +--- +# my_variant(std::monostate) + +--- +# my_variant(int(42)) + +--- +# my_variant(int(24)) + +--- +# my_variant(std::optional(100)) + +--- +# my_variant(std::any(-100)) + +--- +# my_variant(*int(314)) + +--- +# my_variant(std::unique_ptr(1000)) + +--- diff --git a/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.output b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.output new file mode 100644 index 0000000000..f46ea0d253 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-value-with-variant.cpp.output @@ -0,0 +1 @@ +mixed-is-as-value-with-variant.cpp diff --git a/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.execution new file mode 100644 index 0000000000..bd2d00c276 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.execution @@ -0,0 +1,145 @@ +# std::monostate + +## v as lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = true +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<1> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = true, (v as X< 1>).to_string() = X<1> +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +# X<19> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = true, (v as X<19>).to_string() = X<19> +v is X<20> = false, (v as X<20>) = bad variant access + +# X<20> + +## v as lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as const lvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +## v as rvalue reference + +v is empty = false +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = true, (v as X<20>) = works! + +# X<10>(std::exception) + +## v as lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as const lvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + +## v as rvalue reference + +v is empty = true +v is std::monostate = false +v is X< 0> = false, (v as X< 1>) = bad variant access +v is X< 1> = false, (v as X< 1>).to_string() = bad variant access +v is X<19> = false, (v as X<19>).to_string() = bad variant access +v is X<20> = false, (v as X<20>) = bad variant access + diff --git a/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.output b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.output new file mode 100644 index 0000000000..e2100d41dc --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/mixed-is-as-variant.cpp.output @@ -0,0 +1 @@ +mixed-is-as-variant.cpp