Rework rebind interface

Author: gracicot

include/kangaru/detail/cache.hpp

@@ -6,6 +6,7 @@
 #include "ctti.hpp"
 #include "concepts.hpp"
 #include "cache_types.hpp"
+#include "source_helper.hpp"
 
 #include <type_traits>
 #include <concepts>
@@ -132,10 +133,10 @@ namespace kangaru {
 			std::ranges::swap(cache, other.cache);
 		}
 
-		template<forwarded<with_cache_asymmetric> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_cache_asymmetric<std::decay_t<NewSource>, source_reference_wrapper<unwrapped_cache_type>, CacheFrom> {
-			return with_cache_asymmetric<std::decay_t<NewSource>, source_reference_wrapper<unwrapped_cache_type>, CacheFrom>{
-				KANGARU5_FWD(new_source),
+		template<forwarded<with_cache_asymmetric> Original, forwarded_source NewLeaf>
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_cache_asymmetric<rebind_wrapped_source_result_t<Original, NewLeaf>, source_ref_t<Cache>, CacheFrom> {
+			return with_cache_asymmetric<rebind_wrapped_source_result_t<Original, NewLeaf>, source_ref_t<Cache>, CacheFrom>{
+				kangaru::rebind(KANGARU5_FWD(original).source, KANGARU5_FWD(new_leaf)),
 				KANGARU5_NO_ADL(ref)(original.cache)
 			};
 		}
@@ -204,9 +205,13 @@ namespace kangaru {
 		constexpr with_cache(Source source, Cache cache) noexcept :
 			parent_t{std::move(source), std::move(cache)} {}
 
-		template<forwarded<with_cache> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_cache<std::decay_t<NewSource>, source_reference_wrapper<maybe_wrapped_t<Cache>>> {
-			return with_cache<std::decay_t<NewSource>, source_reference_wrapper<maybe_wrapped_t<Cache>>>{parent_t::rebind(static_cast<detail::utility::forward_like_t<Original, parent_t>&&>(original), KANGARU5_FWD(new_source))};
+		template<forwarded<with_cache> Original, forwarded_source NewLeaf>
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept
+			-> with_cache<rebind_wrapped_source_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, source_ref_t<Cache>>
+		{
+			return with_cache<rebind_wrapped_source_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, source_ref_t<Cache>>{
+				parent_t::rebind(static_cast<detail::utility::forward_like_t<Original, parent_t>&&>(original), KANGARU5_FWD(new_leaf))
+			};
 		}
 
 		template<object T, forwarded<with_cache> Self>
@@ -254,13 +259,6 @@ namespace kangaru {
 			}
 		}
 
-		template<forwarded<with_cache_using_source> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_cache_using_source<std::decay_t<NewSource>, SourceFor> {
-			return with_cache_using_source<std::decay_t<NewSource>, SourceFor>{
-				KANGARU5_FWD(new_source),
-			};
-		}
-		
 		Source source;
 	};
 

include/kangaru/detail/container.hpp

@@ -14,12 +14,17 @@
 
 namespace kangaru {
 	template<injectable T>
-	using cached_pointer_to_injectable_reference_source = typename cached_pointer_to_source<injectable_reference_source>::template source<T>;
+	using cached_pointer_to_injectable_reference_source =
+		typename cached_pointer_to_source<injectable_reference_source>::template source<T>;
 
-	template<source Source, cache_map Cache = std::unordered_map<std::size_t, void*>, heap_storage Storage = default_heap_storage>
+	template<
+		rebindable_source Source,
+		cache_map Cache = std::unordered_map<std::size_t, void*>,
+		heap_storage Storage = default_heap_storage
+	>
 	struct container {
 		explicit constexpr container(Source source) noexcept :
-			source{
+			state{
 				make_source_with_cache(
 					make_source_with_heap_storage(
 						make_source_with_exhaustive_construction(
@@ -40,10 +45,10 @@ namespace kangaru {
 				Storage
 			>,
 			Cache
-		> source;
+		> state;
 
 		template<typename Self, typename S>
-		static constexpr auto rebound_source_tree(Self&& self, S&& source) {
+		static constexpr auto container_source(Self&& self, S&& source) {
 			return with_recursion{
 				make_source_with_exhaustive_construction(
 					with_alternative{
@@ -59,22 +64,22 @@ namespace kangaru {
 		}
 
 		template<typename Self>
-		using rebound_source_tree_t = decltype(
-			rebound_source_tree(std::declval<Self>(), std::declval<Self>().source)
+		using container_source_t = decltype(
+			container_source(std::declval<Self>(), std::declval<Self>().state)
 		);
 
 	public:
 		template<injectable T>
-		constexpr auto provide() & -> T requires source_of<rebound_source_tree_t<container&>, T> {
+		constexpr auto provide() & -> T requires source_of<container_source_t<container&>, T> {
 			return kangaru::provide<T>(
-				rebound_source_tree(*this, source)
+				container_source(*this, state)
 			);
 		}
 
 		template<injectable T>
-		constexpr auto provide() && -> T requires source_of<rebound_source_tree_t<container&&>, T> {
+		constexpr auto provide() && -> T requires source_of<container_source_t<container&&>, T> {
 			return kangaru::provide<T>(
-				rebound_source_tree(std::move(*this), std::move(source))
+				container_source(std::move(*this), std::move(state))
 			);
 		}
 	};

include/kangaru/detail/deducer.hpp

@@ -187,11 +187,11 @@ namespace kangaru {
 			if constexpr (source_of<Source, T const&>) {
 				return kangaru::provide<T const&>(static_cast<Source&&>(*source));
 			} else if constexpr (source_of<Source, T&>) {
-				return std::as_const(provide<T&>(static_cast<Source&&>(*source)));
+				return std::as_const(kangaru::provide<T&>(static_cast<Source&&>(*source)));
 			} else if constexpr (source_of<Source, T const&&>) {
-				return static_cast<T const&>(provide<T const&&>(static_cast<Source&&>(*source)));
+				return static_cast<T const&>(kangaru::provide<T const&&>(static_cast<Source&&>(*source)));
 			} else if constexpr (source_of<Source, T&&>) {
-				return static_cast<T const&>(provide<T&&>(static_cast<Source&&>(*source)));
+				return static_cast<T const&>(kangaru::provide<T&&>(static_cast<Source&&>(*source)));
 			} else {
 				static_assert(not std::same_as<T, T>, "exhaustive");
 			}

include/kangaru/detail/heap_storage.hpp

@@ -4,6 +4,7 @@
 #include "source_types.hpp"
 #include "source.hpp"
 #include "allocator.hpp"
+#include "source_helper.hpp"
 
 #include <concepts>
 #include <vector>
@@ -184,9 +185,9 @@ namespace kangaru {
 		}
 
 		template<forwarded<with_heap_storage> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_heap_storage<std::decay_t<NewSource>, source_reference_wrapper<maybe_wrapped_t<Storage>>> {
-			return with_heap_storage<std::decay_t<NewSource>, source_reference_wrapper<maybe_wrapped_t<Storage>>>{
-				KANGARU5_FWD(new_source),
+		static constexpr auto rebind(Original&& original, NewSource&& new_leaf) noexcept -> with_heap_storage<rebind_wrapped_source_result_t<Original, NewSource>, source_ref_t<Storage>> {
+			return with_heap_storage<rebind_wrapped_source_result_t<Original, NewSource>, source_ref_t<Storage>>{
+				kangaru::rebind(KANGARU5_FWD(original).source, new_leaf),
 				KANGARU5_NO_ADL(ref)(original.storage)
 			};
 		}

include/kangaru/detail/polymorphic_container.hpp

@@ -20,18 +20,18 @@ namespace kangaru {
 		struct polymorphic_to_concrete {};
 
 		template<injectable T>
-		struct polymorphic_to_concrete<polymorphic_source<T&>> {
+		struct polymorphic_to_concrete<kangaru::polymorphic_source<T&>> {
 			using type = with_polymorphic_cast<with_cast_from<injectable_reference_source<T>, T&>, T&>&;
 		};
 
 		template<kangaru::source T>
 		using polymorphic_to_concrete_t = typename polymorphic_to_concrete<T>::type;
 	}
 
-	template<source Source, cache_map Cache = polymorphic_map<std::unordered_map<std::size_t, type_erased_source_reference>>, heap_storage Storage = default_heap_storage>
+	template<rebindable_source Source, cache_map Cache = polymorphic_map<std::unordered_map<std::size_t, type_erased_source_reference>>, heap_storage Storage = default_heap_storage>
 	struct polymorphic_container {
 		explicit constexpr polymorphic_container(Source source) noexcept :
-			source{
+			state{
 				make_source_with_cache_asymmetric<detail::polymorphic_container::polymorphic_to_concrete_t>(
 					make_source_with_dereference(
 						make_source_with_heap_storage(
@@ -65,10 +65,10 @@ namespace kangaru {
 			>,
 			Cache,
 			detail::polymorphic_container::polymorphic_to_concrete_t
-		> source;
+		> state;
 
 		template<typename Self, typename S>
-		static constexpr auto rebound_source_tree(Self&& self, S&& source) {
+		static constexpr auto container_source(Self&& self, S&& source) {
 			return with_recursion{
 				make_source_with_exhaustive_construction(
 					with_alternative{
@@ -84,22 +84,22 @@ namespace kangaru {
 		}
 
 		template<typename Self>
-		using rebound_source_tree_t = decltype(
-			rebound_source_tree(std::declval<Self>(), std::declval<Self>().source)
+		using container_source_tree_t = decltype(
+			container_source(std::declval<Self>(), std::declval<Self>().state)
 		);
 
 	public:
 		template<injectable T>
-		constexpr auto provide() & -> T requires source_of<rebound_source_tree_t<polymorphic_container&>, T> {
+		constexpr auto provide() & -> T requires source_of<container_source_tree_t<polymorphic_container&>, T> {
 			return kangaru::provide<T>(
-				rebound_source_tree(*this, source)
+				container_source(*this, state)
 			);
 		}
 
 		template<injectable T>
-		constexpr auto provide() && -> T requires source_of<rebound_source_tree_t<polymorphic_container&&>, T> {
+		constexpr auto provide() && -> T requires source_of<container_source_tree_t<polymorphic_container&&>, T> {
 			return kangaru::provide<T>(
-				rebound_source_tree(std::move(*this), std::move(source))
+				container_source(std::move(*this), std::move(state))
 			);
 		}
 	};

include/kangaru/detail/polymorphic_source.hpp

@@ -148,14 +148,6 @@ namespace kangaru {
 			return kangaru::provide<T>(KANGARU5_FWD(source).source);
 		}
 
-		template<forwarded<with_polymorphic_cast> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_polymorphic_cast<std::decay_t<NewSource>, Primary> {
-			return with_polymorphic_cast<std::decay_t<NewSource>, Primary>{
-				KANGARU5_FWD(new_source),
-				original.cast,
-			};
-		}
-		
 		explicit constexpr operator type_erased_source_reference() noexcept {
 			return type_erased_source_reference{polymorphic_source<Primary>{source}};
 		}
@@ -171,9 +163,21 @@ namespace kangaru {
 		}
 	};
 
+	namespace detail::polymorphic_source {
+		template<typename>
+		struct override_polymorphic {};
+		
+		template<typename... Types>
+		struct override_polymorphic<std::tuple<Types&...>> {
+			 using type = std::tuple<kangaru::polymorphic_source<Types&>...>;
+		};
+	}
+	
 	// TODO: Check if this is at the right place
 	template<source Source, injectable Primary>
-	struct overrides_types_in_cache<with_polymorphic_cast<Source, Primary>> : overrides_types_in_cache<Source> {};
+	struct overrides_types_in_cache<with_polymorphic_cast<Source, Primary>> :
+		detail::polymorphic_source::override_polymorphic<overrides_types_in_cache_t<Primary>> {
+	};
 }
 
 #include "undef.hpp"

include/kangaru/detail/recursive_source.hpp

@@ -6,6 +6,7 @@
 #include "injector.hpp"
 #include "tag.hpp"
 #include "source.hpp"
+#include "source_types.hpp"
 #include "source_reference_wrapper.hpp"
 #include "source_helper.hpp"
 
@@ -230,13 +231,16 @@ namespace kangaru {
 			if constexpr (reference_wrapper<Source>) {
 				return std::as_const(source.construction).template operator()<T>(KANGARU5_FWD(source).source);
 			} else {
-				return std::as_const(source.construction).template operator()<T>(kangaru::fwd_ref(KANGARU5_FWD(source).source));
+				return std::as_const(source.construction).template operator()<T>(KANGARU5_NO_ADL(fwd_ref)(KANGARU5_FWD(source).source));
 			}
 		}
 
-		template<forwarded<with_construction> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_source) -> with_construction<std::decay_t<NewSource>, Construction> {
-			return with_construction<std::decay_t<NewSource>, Construction>{KANGARU5_FWD(new_source), original.construction};
+		template<forwarded<with_construction> Original, forwarded_source NewLeaf>
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_construction<rebind_wrapped_source_result_t<Original, NewLeaf>, Construction> {
+			return with_construction<rebind_wrapped_source_result_t<Original, NewLeaf>, Construction>{
+				kangaru::rebind(KANGARU5_FWD(original).source, KANGARU5_FWD(new_leaf)),
+				original.construction
+			};
 		}
 
 		Source source;
@@ -284,37 +288,53 @@ namespace kangaru {
 		// By wrapping source_of in a type, we allow that type to be incomplete!
 		template<kangaru::source Source, kangaru::injectable T>
 		struct source_of_sfinae_wrapper : std::bool_constant<source_of<Source, T>> {};
+		
+		template<kangaru::source Alternative>
+		struct leaf_as_alternative {
+			Alternative alternative;
+			
+			constexpr auto operator()(forwarded_source auto&& leaf) const noexcept {
+				return KANGARU5_NO_ADL(make_source_with_alternative)(
+					KANGARU5_NO_ADL(fwd_ref)(KANGARU5_FWD(leaf)),
+					alternative
+				);
+			}
+		};
 	}
 
-	template<source Source>
+	template<rebindable_source Source>
 	struct with_recursion {
-	private:
-		static constexpr auto rebound_self(auto&& self) requires wrapping_source<std::remove_reference_t<decltype(self)>> {
-			auto const source_ref = KANGARU5_NO_ADL(ref)(KANGARU5_NO_ADL(maybe_unwrap)(self.source));
-			return with_recursion<decltype(source_ref)>{source_ref};
-		}
-		
-		template<forwarded<with_recursion> Self>
-		using rebound_source_t = decltype(
-			detail::source_helper::rebind_source_tree(
-				rebound_self(std::declval<Self&>()),
-				std::declval<Self&>().source
-			)
-		);
-		
-	public:
-		explicit constexpr with_recursion(Source source) noexcept : source{std::move(source)} {}
-		
 		Source source;
 
 		template<typename T, forwarded<with_recursion> Self> requires (not wrapping_source_of<Self, T>)
 		constexpr KANGARU5_PROVIDE_FUNCTION_DECL(Self&& source) -> T requires(
-			detail::recursive_source::source_of_sfinae_wrapper<rebound_source_t<Self>, T>::value
+			// We uses the sfinae wrapper for source_of
+			// This forces the compiler to have a third state:
+			//   requires(true) --> goes in
+			//   requires(false) --> tries another function
+			//   requires(<substitution-error>) --> tries another function
+			//
+			// The first time the compiler encounter provide, it check source_of
+			// Then during the evaluation of source_of, it will encounter provide again
+			// But instead of evaluating source_of, it will see source_of as an incomplete type
+			// Thus skipping that function and try the next one and detect that one is callable
+			// The evaluation of source_of will then yeild true, but
+			// also yield false if it would result in infinite recursion
+			// Yes, this requires expression will yield different result depending on the metastate of the compiler!
+			detail::recursive_source::source_of_sfinae_wrapper<
+				rebind_wrapped_source_result_t<
+					Self&,
+					detail::recursive_source::leaf_as_alternative<with_recursion<source_ref_t<wrapped_source_t<Self>>>>
+				>,
+				T
+			>::value
 		) {
 			return kangaru::provide<T>(
-				detail::source_helper::rebind_source_tree(
-					rebound_self(source),
-					source.source
+				kangaru::rebind(
+					source,
+					detail::recursive_source::leaf_as_alternative<with_recursion<source_ref_t<wrapped_source_t<Self>>>>{
+						KANGARU5_NO_ADL(ref)(source.source)
+					}
 				)
 			);
 		}

include/kangaru/detail/source.hpp

@@ -105,13 +105,16 @@ namespace kangaru {
 		};
 
 	template<typename Source> requires weak_wrapping_source<std::remove_reference_t<Source>>
-	using wrapped_source_t = std::remove_reference_t<decltype(std::declval<Source&&>().source)>;
+	using wrapped_source_t = std::remove_reference_t<decltype((std::declval<Source&&>().source))>;
 
 	template<typename Source>
 	concept wrapping_source =
 		    weak_wrapping_source<Source>
 		and source<wrapped_source_t<Source>>;
 
+	template<typename Source>
+	concept forwarded_wrapping_source = wrapping_source<std::remove_reference_t<Source>>;
+	
 	struct none_source {};
 	static_assert(source<none_source>);