Remove variant_has_substitute

Author: yaito3014

include/iris/x4/core/detail/parse_alternative.hpp

@@ -67,7 +67,7 @@ template<class Parser, X4Attribute Attr>
 struct pass_parser_attribute
 {
     using attribute_type = parser_traits<Parser>::attribute_type;
-    using substitute_type = traits::variant_find_substitute_t<Attr, attribute_type>;
+    using substitute_type = traits::variant_find_holdable_type_t<Attr, attribute_type>;
 
     using type = std::conditional_t<
         std::same_as<Attr, substitute_type>,

include/iris/x4/core/detail/parse_into_container.hpp

@@ -140,11 +140,12 @@ template<class Parser>
     requires Parser::handles_container
 struct parse_into_container_impl<Parser>
 {
+    // TODO: decompose pass_attribute_as_is to make more logic clear
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
     static constexpr bool pass_attibute_as_is = std::disjunction_v<
         parser_accepts_container<Parser, Attr>,
 
-        std::negation<traits::can_hold<
+        std::negation<std::is_same<
             typename traits::pseudo_attribute<
                 It, Se, Context,
                 typename parser_traits<Parser>::attribute_type
@@ -217,7 +218,7 @@ parse_into_container(
         using attribute_type = parser_traits<Parser>::attribute_type;
 
         // e.g. `std::string` when the attribute_type is `char`
-        using substitute_type = traits::variant_find_substitute_t<Attr, traits::build_container_t<attribute_type>>;
+        using substitute_type = traits::variant_find_holdable_type_t<Attr, traits::build_container_t<attribute_type>>;
 
         // instead of creating a temporary `substitute_type`, append directly into the emplaced alternative
         auto& variant_alt = attr.template emplace<substitute_type>();

include/iris/x4/core/move_to.hpp

@@ -153,51 +153,32 @@ move_to(Source&& src, Dest& dest)
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires traits::is_size_one_sequence_v<Source> && traits::variant_has_substitute_v<Dest, Source>
+    requires std::is_assignable_v<Dest&, Source&&>
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
-    // dest is a variant, src is a single element tuple-like that the variant
-    // *can* directly hold.
-    static_assert(std::is_assignable_v<Dest&, Source>);
     dest = std::forward<Source>(src);
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires traits::is_size_one_sequence_v<Source> && (!traits::variant_has_substitute_v<Dest, Source>)
+    requires (!std::is_assignable_v<Dest&, Source&&>) && traits::is_size_one_sequence_v<Source>
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(noexcept(dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)))))
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
-    // dest is a variant, src is a single element tuple-like that the variant
-    // cannot directly hold. We'll try to unwrap the single element tuple-like.
-
-    // Make sure that the Dest variant can really hold Source
     static_assert(
-        traits::variant_has_substitute_v<Dest, alloy::tuple_element_t<0, Source>>,
+        std::is_assignable_v<Dest&, decltype(std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src))))>,
         "Error! The destination variant (Dest) cannot hold the source type (Source)"
     );
 
-    // TODO: preliminarily invoke static_assert to check if the assignment is valid
     dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)));
 }
 
-template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires (!traits::is_size_one_sequence_v<Source>)
-constexpr void
-move_to(Source&& src, Dest& dest)
-    noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
-{
-    static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
-    static_assert(std::is_assignable_v<Dest&, Source>);
-    dest = std::forward<Source>(src);
-}
-
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::optional_attr> Dest>
 constexpr void
 move_to(Source&& src, Dest& dest)

include/iris/x4/traits/can_hold.hpp

@@ -10,29 +10,23 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/x4/core/attribute.hpp>
 #include <iris/x4/traits/container_traits.hpp>
 #include <iris/x4/traits/tuple_traits.hpp>
 
+#include <iris/x4/core/attribute.hpp>
+
 #include <iris/alloy/traits.hpp>
 
 #include <optional>
 #include <type_traits>
 
 namespace iris::x4::traits {
 
-// Find out if T can be a (strong) substitute for Attribute
-template<class T, class Attr>
+template<class T, class U>
 struct can_hold;
 
-template<class T, class Attr>
-constexpr bool can_hold_v = can_hold<T, Attr>::value;
-
-template<class T>
-struct is_variant;
-
-template<class Variant, class Attr>
-struct variant_has_substitute;
+template<class T, class U>
+constexpr bool can_hold_v = can_hold<T, U>::value;
 
 namespace detail {
 
@@ -50,55 +44,50 @@ template<class TTuple, class UTuple>
     requires is_same_size_sequence_v<TTuple, UTuple>
 struct is_all_substitute_for_tuple<TTuple, UTuple> : is_all_substitute_for_tuple_impl<TTuple, UTuple> {};
 
-template<class T, class Attr>
+template<class T, class U>
 struct value_type_can_hold
-    : can_hold<container_value_t<T>, container_value_t<Attr>>
+    : can_hold<container_value_t<T>, container_value_t<U>>
 {};
 
-template<class T, class Attr>
+template<class T, class U>
 struct can_hold_impl : std::false_type {};
 
-template<class T, class Attr>
+template<class T, class U>
     requires std::conjunction_v<
         alloy::is_tuple_like<T>,
-        alloy::is_tuple_like<Attr>
+        alloy::is_tuple_like<U>
     >
-struct can_hold_impl<T, Attr>
-    : is_all_substitute_for_tuple<T, Attr>
+struct can_hold_impl<T, U>
+    : is_all_substitute_for_tuple<T, U>
 {};
 
-template<class T, class Attr>
+template<class T, class U>
     requires
         is_container_v<T> &&
-        is_container_v<Attr>
-struct can_hold_impl<T, Attr>
-    : value_type_can_hold<T, Attr>
-{};
-
-template<class T, class Attr>
-    requires is_variant<T>::value
-struct can_hold_impl<T, Attr>
-    : variant_has_substitute<T, Attr>
+        is_container_v<U>
+struct can_hold_impl<T, U>
+    : value_type_can_hold<T, U>
 {};
 
 } // detail
 
-template<class T, class Attr>
+template<class T, class U>
 struct can_hold
     : std::disjunction<
-          std::is_same<T, Attr>,
-          detail::can_hold_impl<T, Attr>
+        std::is_same<T, U>,
+        std::is_assignable<T&, U>,
+        detail::can_hold_impl<T, U>
     >
 {};
 
-template<class T, X4UnusedAttribute Attr>
-struct can_hold<T, Attr>
+template<class T, X4UnusedAttribute U>
+struct can_hold<T, U>
     : std::false_type
 {};
 
-template<class T, X4Attribute Attr>
-struct can_hold<std::optional<T>, std::optional<Attr>>
-    : can_hold<T, Attr>
+template<class T, class U>
+struct can_hold<std::optional<T>, std::optional<U>>
+    : can_hold<T, U>
 {};
 
 } // iris::x4::traits

include/iris/x4/traits/variant_traits.hpp

@@ -16,6 +16,7 @@
 
 #include <iris/rvariant/variant_helper.hpp>
 
+#include <concepts>
 #include <type_traits>
 
 namespace iris::x4::traits {
@@ -34,20 +35,43 @@ struct is_variant<iris::rvariant<Ts...>> : std::true_type {};
 
 namespace detail {
 
-template<class Attr, class... Ts>
-struct variant_find_substitute_impl;
+template<class T, class... Ts>
+struct variant_has_exact_type;
 
-template<class Attr>
-struct variant_find_substitute_impl<Attr>
+template<class T, class... Ts>
+inline constexpr bool variant_has_exact_type_v = variant_has_exact_type<T, Ts...>::value;
+
+template<class T>
+struct variant_has_exact_type<T>
+    : std::false_type
+{};
+
+template<class T, class First, class... Rest>
+    requires std::same_as<T, iris::unwrap_recursive_type<First>>
+struct variant_has_exact_type<T, First, Rest...>
+    : std::true_type
+{};
+
+template<class T, class First, class... Rest>
+    requires (!std::same_as<T, iris::unwrap_recursive_type<First>>)
+struct variant_has_exact_type<T, First, Rest...>
+    : variant_has_exact_type<T, Rest...>
+{};
+
+template<class T, class... Ts>
+struct variant_find_holdable_type_impl;
+
+template<class T>
+struct variant_find_holdable_type_impl<T>
 {
-    using type = Attr;
+    using type = T;
 };
 
-template<class Attr, class First, class... Rest>
-struct variant_find_substitute_impl<Attr, First, Rest...>
+template<class T, class First, class... Rest>
+struct variant_find_holdable_type_impl<T, First, Rest...>
 {
     using type = std::conditional_t<
-        can_hold_v<iris::unwrap_recursive_type<First>, Attr>,
+        can_hold_v<iris::unwrap_recursive_type<First>, T>,
 
         // Given some type `T`, when both `T` and `recursive_wrapper<T>` is seen
         // during attribute resolution, X4 should ideally materialize the latter
@@ -60,61 +84,38 @@ struct variant_find_substitute_impl<Attr, First, Rest...>
         //
         First, // no need to unwrap due to the reason described above
 
-        typename variant_find_substitute_impl<Attr, Rest...>::type
+        typename variant_find_holdable_type_impl<T, Rest...>::type
     >;
 };
 
 } // detail
 
 
 template<class Variant, class T>
-struct variant_find_substitute;
+struct variant_find_holdable_type;
 
 template<class Variant, class T>
-using variant_find_substitute_t = typename variant_find_substitute<Variant, T>::type;
+using variant_find_holdable_type_t = typename variant_find_holdable_type<Variant, T>::type;
 
 template<class Variant>
-struct variant_find_substitute<Variant, Variant>
+struct variant_find_holdable_type<Variant, Variant>
 {
     using type = Variant;
 };
 
-template<class... Ts, class U>
-    requires (!std::same_as<iris::rvariant<Ts...>, U>)
-struct variant_find_substitute<iris::rvariant<Ts...>, U>
+template<class... Ts, class T>
+    requires (!std::same_as<iris::rvariant<Ts...>, T>) && detail::variant_has_exact_type_v<T, Ts...>
+struct variant_find_holdable_type<iris::rvariant<Ts...>, T>
 {
-    using type = typename detail::variant_find_substitute_impl<U, Ts...>::type;
+    using type = T;
 };
 
-
-template<class Variant, class U>
-struct variant_has_substitute;
-
-template<class Variant, class U>
-constexpr bool variant_has_substitute_v = variant_has_substitute<Variant, U>::value;
-
-template<class Variant>
-struct variant_has_substitute<Variant, Variant>
-    : std::true_type
-{};
-
-template<class T>
-struct variant_has_substitute<unused_type, T>
-    : std::true_type
-{};
-
-template<class T>
-struct variant_has_substitute<unused_type const, T>
-    : std::true_type
-{};
-
-// Recursively find the first type from the variant that can be a substitute for `T`.
-// Returns boolean value whether it was found.
-template<class... Ts, class U>
-    requires (!std::same_as<iris::rvariant<Ts...>, U>)
-struct variant_has_substitute<iris::rvariant<Ts...>, U>
-    : std::disjunction<can_hold<Ts, U>...>
-{};
+template<class... Ts, class T>
+    requires (!std::same_as<iris::rvariant<Ts...>, T>) && (!detail::variant_has_exact_type_v<T, Ts...>)
+struct variant_find_holdable_type<iris::rvariant<Ts...>, T>
+{
+    using type = typename detail::variant_find_holdable_type_impl<T, Ts...>::type;
+};
 
 } // iris::x4::traits
 

test/x4/alternative.cpp

@@ -231,7 +231,7 @@ TEST_CASE("alternative")
         using attribute_type = x4::parser_traits<Parser>::attribute_type;
         STATIC_CHECK(std::same_as<attribute_type, std::vector<bool>>);
 
-        using substitute_type = x4::traits::variant_find_substitute_t<Attr, attribute_type>;
+        using substitute_type = x4::traits::variant_find_holdable_type_t<Attr, attribute_type>;
         STATIC_CHECK(std::same_as<substitute_type, std::vector<bool>>);
 
         Attr var;
@@ -245,7 +245,7 @@ TEST_CASE("alternative")
         using attribute_type = x4::parser_traits<Parser>::attribute_type;
         STATIC_CHECK(std::same_as<attribute_type, std::string>);
 
-        using substitute_type = x4::traits::variant_find_substitute_t<Attr, attribute_type>;
+        using substitute_type = x4::traits::variant_find_holdable_type_t<Attr, attribute_type>;
         STATIC_CHECK(std::same_as<substitute_type, std::string>);
 
         Attr var;

test/x4/substitution.cpp

@@ -13,9 +13,3 @@ TEST_CASE("can_hold")
     STATIC_CHECK( x4::traits::can_hold_v<iris::rvariant<int, double>, int>);
     STATIC_CHECK(!x4::traits::can_hold_v<int, iris::rvariant<int, double>>);
 }
-
-TEST_CASE("variant_has_substitute")
-{
-    STATIC_CHECK( x4::traits::variant_has_substitute_v<iris::rvariant<int, double>, int>);
-    STATIC_CHECK(!x4::traits::variant_has_substitute_v<iris::rvariant<int, double>, char>);
-}