Skip to content

[SUGGESTION][FIX] Add narrowing 'as' cast and static assert failure instead of nonesuch… #106

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 5 commits into from
Closed

[SUGGESTION][FIX] Add narrowing 'as' cast and static assert failure instead of nonesuch… #106

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
8f799c7
Add optional as
filipsajdak Dec 29, 2022
c37a3e6
Add handling literals for as casts
filipsajdak Dec 29, 2022
0753596
Add support for calling safe as in inspect alternatives
filipsajdak Dec 29, 2022
b69b58e
Add unsafe_narrow
filipsajdak Dec 29, 2022
94f8d40
Update tests due to inspect_as generation
filipsajdak Dec 29, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
259 changes: 218 additions & 41 deletions include/cpp2util.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -208,6 +208,7 @@
#include <utility>
#include <cstdio>
#include <cstdint>
#include <cmath>

#if defined(CPP2_USE_SOURCE_LOCATION)
#include <source_location>
Expand Down Expand Up @@ -721,9 +722,37 @@ inline constexpr auto is( auto const& x, auto const& value ) -> bool
//-------------------------------------------------------------------------------------------------------------
// Built-in as
//
template< typename C >
auto as(auto const&) -> auto {
return nonesuch;
template <typename... Ts>
inline constexpr auto program_violates_type_safety_guarantee = sizeof...(Ts) < 0;

template <typename O>
inline constexpr bool is_optional_v = requires{ typename O::value_type; requires std::same_as<std::optional<typename O::value_type>, O>;};

template< typename C, typename T >
auto as(T const& t) -> auto {
if constexpr (is_optional_v<C>) {
return C{};
} else if constexpr (is_optional_v<T>) {
static_assert(program_violates_type_safety_guarantee<C, T>, "No safe 'as' cast from optional");
}
else {
static_assert(program_violates_type_safety_guarantee<C, T>, "No safe 'as' cast available please use optional cast `as std::optional<T>` or `unsafe_narrow<T>()`");
}
}

template< typename C, auto x, typename X >
inline constexpr bool is_castable_v = std::is_arithmetic_v<C>
&& std::is_arithmetic_v<X>
&& !(static_cast<X>(static_cast<C>(x)) != x || ((std::is_signed_v<C> != std::is_signed_v<X>) && ((static_cast<C>(x) < C{}) != (x < X{}))));

template< typename C, auto x, typename X>
inline constexpr auto as() -> auto
{
if constexpr ( is_castable_v<C, x, X> ) {
return static_cast<C>(X(x));
} else {
static_assert(program_violates_type_safety_guarantee<C, X>, "No safe 'as' cast available please use optional cast `as std::optional<T>` or `unsafe_narrow<T>()`");
}
}

template< typename C, typename X >
Expand All @@ -734,7 +763,7 @@ auto as( X const& x ) -> decltype(auto) {

template< typename C, typename X >
auto as( X const& x ) -> auto
requires (!std::is_same_v<C, X> && requires { C{x}; })
requires (!is_optional_v<C> && !std::is_same_v<C, X> && requires { C{x}; })
{
return C{x};
}
Expand All @@ -745,31 +774,6 @@ auto as( X&& x ) -> C&& {
return std::forward<X>(x);
}

template< typename C, typename X >
requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
auto as( X& x ) -> C& {
return dynamic_cast<C&>(x);
}

template< typename C, typename X >
requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
auto as( X const& x ) -> C const& {
return dynamic_cast<C const&>(x);
}

template< typename C, typename X >
requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
auto as( X* x ) -> C* {
return dynamic_cast<C*>(x);
}

template< typename C, typename X >
requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
auto as( X const* x ) -> C const* {
return dynamic_cast<C const*>(x);
}


//-------------------------------------------------------------------------------------------------------------
// std::variant is and as
//
Expand Down Expand Up @@ -890,8 +894,10 @@ auto is( std::variant<Ts...> const& x ) {
return false;
}

template<typename T, typename... Ts>
auto as( std::variant<Ts...> const& x ) {
template< typename O, typename X, typename... Ts >
requires is_optional_v<O>
auto as( std::variant<Ts...> const& x ) -> O {
using T = typename O::value_type;
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); }
Expand All @@ -912,7 +918,7 @@ auto as( std::variant<Ts...> const& x ) {
if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<7>(x); }
if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<8>(x); }
if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<9>(x); }
throw std::bad_variant_access();
return O{};
}


Expand Down Expand Up @@ -957,10 +963,16 @@ inline constexpr auto is( std::any const& x, auto const& value ) -> bool

// as
//
template<typename T, typename X>
requires (!std::is_reference_v<T> && std::is_same_v<X,std::any> && !std::is_same_v<T,std::any>)
constexpr auto as( X const& x ) -> T
{ return std::any_cast<T>( x ); }
template< typename O, typename X, typename T = typename O::value_type>
requires (is_optional_v<O> && std::is_same_v<X, std::any> && !std::is_same_v<T,std::any>)
constexpr auto as( X const& x ) -> O
{
try {
return std::any_cast<T>( x );
} catch (...) {
return O{};
}
}


//-------------------------------------------------------------------------------------------------------------
Expand Down Expand Up @@ -1001,13 +1013,178 @@ constexpr auto is( std::optional<T> const& x, auto const& value ) -> bool
}


// as
//-------------------------------------------------------------------------------------------------------------
// Optional as
//
template<typename T, typename X>
requires std::is_same_v<X,std::optional<T>>
constexpr auto as( X const& x ) -> decltype(auto)
{ return x.value(); }

template< typename O, typename X, typename C = typename O::value_type >
requires ( is_optional_v<O>
&& std::is_arithmetic_v<C> && std::is_arithmetic_v<X>
)
auto as( const X& x ) -> auto
{
constexpr const bool is_different_signedness = (std::is_signed_v<C> != std::is_signed_v<X>);
const C value = static_cast<C>(x);
auto is_equal_after_casting = false;
if constexpr (std::is_floating_point_v<C> || std::is_floating_point_v<X>) {
is_equal_after_casting = std::fabs(static_cast<X>(value) - x) < std::numeric_limits<C>::epsilon();
} else {
is_equal_after_casting = static_cast<X>(value) == x;
}

if ( !is_equal_after_casting || (is_different_signedness && ((value < C{}) != (x < X{}))))
{
return O{};
}

return O{value};
}

template< typename O, typename X, typename C = typename O::value_type >
auto as( X& x ) -> O
requires (is_optional_v<O> && !std::is_same_v<X, std::any> && !is_optional_v<X>
&& !std::is_arithmetic_v<X> && !std::is_arithmetic_v<C>
&& !std::is_pointer_v<C> && !std::is_pointer_v<X>
)
{
if constexpr (
std::is_base_of_v<X, C>
|| (std::is_polymorphic_v<X> && std::is_polymorphic_v<C>)
) {
if (auto* ptr = dynamic_cast<C*>(&x); ptr) {
return O{*ptr};
}
}
else if constexpr ( requires { C{x}; } ) {
return O{x};
}

return O{};
}

template< typename O, typename X, typename C = typename O::value_type >
auto as( X const& x ) -> O
requires (is_optional_v<O> && !std::is_same_v<X, std::any> && !is_optional_v<X>
&& !std::is_arithmetic_v<X> && !std::is_arithmetic_v<C>
&& !std::is_pointer_v<C> && !std::is_pointer_v<X>
)
{
if constexpr (
std::is_base_of_v<X, C>
|| (std::is_polymorphic_v<X> && std::is_polymorphic_v<C>)
) {
if (auto* ptr = dynamic_cast<C const*>(&x); ptr) {
return O{*ptr};
}
}
else if constexpr ( requires { C{x}; } ) {
return O{x};
}

return O{};
}

template< typename O, typename X, typename C = typename O::value_type >
auto as( X const* x ) -> O
requires (is_optional_v<O>
&& !std::is_arithmetic_v<X> && !std::is_arithmetic_v<C>
)
{
if constexpr ( std::is_pointer_v<C> ) {
using T = std::remove_pointer_t<C>;
if constexpr (
std::is_base_of_v<X, T>
|| (std::is_polymorphic_v<X> && std::is_polymorphic_v<T>)
) {

if (auto* ptr = dynamic_cast<C>(x); ptr) {
return O{ptr};
}
}
return O{};
}
else if constexpr ( requires { C{x}; } ) {
return O{x};
} else {
return O{};
}
}

template< typename O, typename X, typename C = typename O::value_type >
auto as( X* x ) -> O
requires (is_optional_v<O>
&& !std::is_arithmetic_v<X> && !std::is_arithmetic_v<C>
)
{
if constexpr ( std::is_pointer_v<C> ) {
using T = std::remove_pointer_t<C>;
if constexpr (
std::is_base_of_v<X, T>
|| (std::is_polymorphic_v<X> && std::is_polymorphic_v<T>)
) {

if (auto* ptr = dynamic_cast<C>(x); ptr) {
return O{ptr};
}
}
return O{};
}
else if constexpr ( requires { C{x}; } ) {
return O{x};
} else {
return O{};
}
}

// optional as optional
template< typename O, typename X >
requires ( is_optional_v<O> && is_optional_v<X> && !std::is_same_v<O, X>)
auto as( const X& x ) -> auto
{
if (x.has_value()) {
return as<O>(x.value());
} else {
return O{};
}
}

// for literals - compile-time cast
template< typename O, auto x, typename X, typename C = typename O::value_type >
requires (is_optional_v<O> && std::is_arithmetic_v<C> && std::is_arithmetic_v<X>)
inline constexpr auto as() -> O
{
if constexpr ( is_castable_v<C, x, X> ) {
return O{static_cast<C>(X(x))};
} else {
return O{};
}
}

template< typename IsChecked, typename C, typename X >
auto inspect_as( X&& x ) -> auto
{
using T = std::remove_cvref_t<X>;

if constexpr (is_optional_v<C> ) {
return as<C, T>(std::forward<X>(x));
} else {
return as<std::optional<C>, T>(std::forward<X>(x)).value();
}
}

template<typename T, auto x>
constexpr auto as( ) -> decltype(auto)
{ return as<T, x, decltype(x)>(); }

//-----------------------------------------------------------------------
//
// Unsafe narrow cast

template <typename C, typename X>
auto unsafe_narrow( X&& x ) noexcept -> decltype(auto)
{
return static_cast<C>(std::forward<X>(x));
}

//-----------------------------------------------------------------------
//
Expand Down
2 changes: 1 addition & 1 deletion regression-tests/test-results/mixed-inspect-values.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@ auto test(auto const& x) -> void{
else if (cpp2::is(__expr, in_2_3)) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
else if (cpp2::is(__expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
else if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); else return std::string{}; else return std::string{}; }
else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); else return std::string{}; else return std::string{}; }
else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::inspect_as<std::string, std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::inspect_as<std::string, std::string>(x))),std::string> ) return cpp2::inspect_as<std::string, std::string>(x); else return std::string{}; else return std::string{}; }
else return "(no match)"; }
() << "\n";
}
Expand Down
4 changes: 2 additions & 2 deletions ...ession-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,8 +35,8 @@ auto test_generic(auto const& x, auto const& msg) -> void{
<< std::setw(30) << msg
<< " value is "
<< [&] () -> std::string { auto&& __expr = x;
if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + std::to_string(cpp2::as<int>(x)))),std::string> ) return "integer " + std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{'"' + cpp2::as<std::string>(x) + '"';} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(('"' + cpp2::as<std::string>(x) + '"')),std::string> ) return '"' + cpp2::as<std::string>(x) + '"'; else return std::string{}; else return std::string{}; }
if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + std::to_string(cpp2::inspect_as<int, int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + std::to_string(cpp2::inspect_as<int, int>(x)))),std::string> ) return "integer " + std::to_string(cpp2::inspect_as<int, int>(x)); else return std::string{}; else return std::string{}; }
else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{'"' + cpp2::inspect_as<std::string, std::string>(x) + '"';} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(('"' + cpp2::inspect_as<std::string, std::string>(x) + '"')),std::string> ) return '"' + cpp2::inspect_as<std::string, std::string>(x) + '"'; else return std::string{}; else return std::string{}; }
else return "not an int or string"; }
()
<< "\n";
Expand Down
2 changes: 1 addition & 1 deletion regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,7 @@ auto print_an_int(auto const& x) -> void{
<< std::setw(30) << cpp2::to_string(x)
<< " value is "
<< [&] () -> std::string { auto&& __expr = x;
if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::inspect_as<int, int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::inspect_as<int, int>(x)))),std::string> ) return std::to_string(cpp2::inspect_as<int, int>(x)); else return std::string{}; else return std::string{}; }
else return "not an int"; }
()
<< "\n";
Expand Down
2 changes: 1 addition & 1 deletion regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
<< std::setw(30) << msg
<< " value is "
<< [&] () -> std::string { auto&& __expr = x;
if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::inspect_as<int, int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::inspect_as<int, int>(x)))),std::string> ) return std::to_string(cpp2::inspect_as<int, int>(x)); else return std::string{}; else return std::string{}; }
else return "not an int"; }
()
<< "\n";
Expand Down
Loading