Corrected deducer with aggregate initalization

gracicot · gracicot · commit 942a4f832886 · 2026-01-10T23:56:00.000-05:00
diff --git a/include/kangaru/detail/constructor.hpp b/include/kangaru/detail/constructor.hpp
@@ -15,11 +15,19 @@
 
 KANGARU5_EXPORT namespace kangaru {
 	template<typename T, typename... Args>
-	concept raw_constructor_callable = std::constructible_from<T, Args...> or brace_constructible<T, Args...>;
+	concept raw_constructor_callable =
+		   std::constructible_from<T, Args...>
+		or (
+			    brace_constructible<T, Args...>
+			and (
+				   not std::is_aggregate_v<T>
+				or sizeof...(Args) != 1
+			)
+		);
 	
 	template<unqualified_object Type>
 	struct raw_constructor_function {
-		constexpr auto operator()(auto&&... args) const& requires(
+		constexpr auto operator()(auto&&... args) const& -> Type requires(
 			raw_constructor_callable<Type, decltype(args)...>
 		) {
 			if constexpr (std::constructible_from<Type, decltype(args)...>) {
diff --git a/include/kangaru/detail/deducer.hpp b/include/kangaru/detail/deducer.hpp
@@ -117,6 +117,11 @@ namespace kangaru {
 		operator T const& () const;
 		#endif
 		
+		#if KANGARU5_RVALUE_CONST_AMBIGUOUS()
+		template<deducible T>
+		operator T const&& () const;
+		#endif
+		
 		#if KANGARU5_RVALUE_AMBIGUOUS()
 		template<typename T>
 		operator T&& () const;
@@ -127,20 +132,19 @@ namespace kangaru {
 		using is_deducer = kangaru_deducer_tag;
 		
 		template<deducible T>
-		operator T () const;
+		operator T ();
 		
 		template<deducible T>
-		operator T& ();
+		operator T& () const;
 		
-		#if KANGARU5_LVALUE_CONST_AMBIGUOUS()
 		template<deducible T>
-		operator T const& ();
-		#endif
+		operator T const& () const;
+		
+		template<deducible T>
+		operator T const&& () const;
 		
-		#if KANGARU5_RVALUE_AMBIGUOUS()
 		template<typename T>
-		operator T&& ();
-		#endif
+		operator T&& () const;
 	};
 	
 	KANGARU5_EXPORT struct placeholder_deducer {
@@ -555,42 +559,118 @@ namespace kangaru {
 	}
 	
 	namespace detail::deducer {
+		template<typename T, typename F, typename, typename>
+		inline constexpr auto callable_with_nth_parameter_being_expand = false;
+		
 		template<typename T, typename F, std::size_t... before, std::size_t... after>
-		inline consteval auto callable_with_nth_parameter_being_expand(std::index_sequence<before...>, std::index_sequence<after...>) -> bool {
-			return callable<
+		inline constexpr auto callable_with_nth_parameter_being_expand<T, F, std::index_sequence<before...>, std::index_sequence<after...>> =
+			callable<
 				F,
 				detail::utility::expand<placeholder_deducer, before>...,
 				T,
 				detail::utility::expand<placeholder_deducer, after>...
 			>;
-		}
 		
 		template<typename T, typename F, std::size_t nth, std::size_t max>
-		inline constexpr auto callable_with_nth_parameter_being = bool{
-			KANGARU5_NO_ADL(callable_with_nth_parameter_being_expand<T, F>)(std::make_index_sequence<nth>{}, std::make_index_sequence<max - nth - 1>{})
-		};
+		concept callable_with_nth_parameter_being =
+			callable_with_nth_parameter_being_expand<T, F, std::make_index_sequence<nth>, std::make_index_sequence<max - nth - 1>>;
 		
 		template<typename F, std::size_t nth, std::size_t max>
-		inline constexpr auto is_nth_parameter_prvalue = bool{
+		concept function_nth_parameter_prvalue =
 			    not callable_with_nth_parameter_being<ambiguous_prvalue_deducer, F, nth, max>
-			and callable_with_nth_parameter_being<ambiguous_overloaded_reference_deducer, F, nth, max>
-		};
+			and callable_with_nth_parameter_being<ambiguous_overloaded_reference_deducer, F, nth, max>;
+		
+		template<typename T, typename F, std::size_t nth, std::size_t max>
+		concept callable_with_lvalue_const_ref = callable_with_nth_parameter_being<
+			filtered_value_category_deducer<T, reference_kind::lvalue_const_reference>,
+			F,
+			nth,
+			max
+		>;
+		
+		// TODO: Remove conditionals, convert to pure boolean expressions
+		template<typename T, typename F, std::size_t nth, std::size_t max>
+		concept callable_with_rvalue_const_ref = (
+			  callable_with_lvalue_const_ref<T, F, nth, max>
+			? not callable_with_nth_parameter_being<
+					filtered_value_category_deducer<T, reference_kind::lvalue_const_reference_and_rvalue_const_reference>,
+					F,
+					nth,
+					max
+				>
+			: (
+				callable_with_nth_parameter_being<
+					filtered_value_category_deducer<T, reference_kind::rvalue_const_reference>,
+					F,
+					nth,
+					max
+				> or (
+					callable_with_nth_parameter_being<
+						filtered_value_category_deducer<T, reference_kind::rvalue_reference>,
+						F,
+						nth,
+						max
+					> and not callable_with_nth_parameter_being<
+						filtered_value_category_deducer<T, reference_kind::rvalue_reference_and_rvalue_const_reference>,
+						F,
+						nth,
+						max
+					>
+				)
+			)
+		);
+		
+		template<typename T, typename F, std::size_t nth, std::size_t max>
+		constexpr auto callable_with_lvalue_ref =
+			  callable_with_lvalue_const_ref<T, F, nth, max>
+			? not callable_with_nth_parameter_being<
+				filtered_value_category_deducer<T, reference_kind::lvalue_reference_and_lvalue_const_reference>,
+				F,
+				nth,
+				max
+			>
+			: callable_with_nth_parameter_being<
+				filtered_value_category_deducer<T, reference_kind::lvalue_reference>,
+				F,
+				nth,
+				max
+			>;
+		
+		template<typename T, typename F, std::size_t nth, std::size_t max>
+		constexpr auto callable_with_rvalue_ref = 
+			  callable_with_rvalue_const_ref<T, F, nth, max>
+			? not callable_with_nth_parameter_being<
+				filtered_value_category_deducer<T, reference_kind::rvalue_reference_and_rvalue_const_reference>,
+				F,
+				nth,
+				max
+			>
+			: callable_with_lvalue_const_ref<T, F, nth, max>
+				? not callable_with_nth_parameter_being<
+					filtered_value_category_deducer<T, reference_kind::lvalue_const_reference_and_rvalue_reference>,
+					F,
+					nth,
+					max
+				>
+				: callable_with_nth_parameter_being<
+					filtered_value_category_deducer<T, reference_kind::rvalue_reference>,
+					F,
+					nth,
+					max
+				>;
 		
 		template<typename T, typename F, std::size_t nth, std::size_t max>
 		inline consteval auto reference_kind_for_nth_parameter() -> reference_kind {
-			if constexpr (is_nth_parameter_prvalue<F, nth, max>) {
+			if constexpr (function_nth_parameter_prvalue<F, nth, max>) {
 				return reference_kind::none;
 			} else {
 				// Welcome to insanity
 				
 				// Only one kind of parameter will accept a lvalue const reference, and it's a lvalue const reference.
 				// If the function is callable with a lvalue const reference, then it means there's an overload that accepts it.
-				constexpr auto callable_with_lvalue_const_ref = callable_with_nth_parameter_being<
-					filtered_value_category_deducer<T, reference_kind::lvalue_const_reference>,
-					F,
-					nth,
-					max
-				>;
+				constexpr auto lvalue_const_ref = callable_with_lvalue_const_ref<T, F, nth, max>
+					? reference_kind::lvalue_const_reference
+					: reference_kind::none;
 				
 				// Now we have something harder to match. Sending a rvalue constant reference would indeed match a rvalue
 				// constant reference parameter, but would also match a lvalue constant reference. This means that if we
@@ -604,82 +684,31 @@ namespace kangaru {
 				// On the contrary, if there was no match for lvalue constant reference:
 				// - We match for rvalue constant reference. If it matches, we're gold.
 				// - If we don't match, we exclude matching with mutable rvalue for clang
-				constexpr auto callable_with_rvalue_const_ref = callable_with_lvalue_const_ref
-					? not callable_with_nth_parameter_being<
-						filtered_value_category_deducer<T, reference_kind::lvalue_const_reference_and_rvalue_const_reference>,
-						F,
-						nth,
-						max
-					>
-					: (
-						callable_with_nth_parameter_being<
-							filtered_value_category_deducer<T, reference_kind::rvalue_const_reference>,
-							F,
-							nth,
-							max
-						> or (
-							callable_with_nth_parameter_being<
-								filtered_value_category_deducer<T, reference_kind::rvalue_reference>,
-								F,
-								nth,
-								max
-							> and not callable_with_nth_parameter_being<
-								filtered_value_category_deducer<T, reference_kind::rvalue_reference_and_rvalue_const_reference>,
-								F,
-								nth,
-								max
-							>
-						)
-					);
+				constexpr auto rvalue_const_ref = callable_with_rvalue_const_ref<T, F, nth, max>
+					? reference_kind::rvalue_const_reference
+					: reference_kind::none;
 				
 				// To check for normal lvalue references, we need to first check if we already match with a const reference.
 				// If we did match, then we'll do the trick where we try to call the function with a deducer that can
 				// Deduce both kind. If the call is ambiguous, then we have a candidate in the overload set that take a lvalue ref.
 				// Otherwise, we can just match with lvalue references.
-				constexpr auto callable_with_lvalue_ref = callable_with_lvalue_const_ref
-					? not callable_with_nth_parameter_being<
-						filtered_value_category_deducer<T, reference_kind::lvalue_reference_and_lvalue_const_reference>,
-						F,
-						nth,
-						max
-					>
-					: callable_with_nth_parameter_being<
-						filtered_value_category_deducer<T, reference_kind::lvalue_reference>,
-						F,
-						nth,
-						max
-					>;
+				constexpr auto lvalue_ref = callable_with_lvalue_ref<T, F, nth, max>
+					? reference_kind::lvalue_reference
+					: reference_kind::none;
 				
 				// Here we finally check for rvalue references. They can match rvalue references, rvalue const references, and
 				// lvalue const references. We need take into account if we matched for them them before in order to do the right
 				// little dance of ambiguous call check.
-				constexpr auto callable_with_rvalue_ref = callable_with_rvalue_const_ref
-					? not callable_with_nth_parameter_being<
-						filtered_value_category_deducer<T, reference_kind::rvalue_reference_and_rvalue_const_reference>,
-						F,
-						nth,
-						max
-					>
-					: callable_with_lvalue_const_ref
-						? not callable_with_nth_parameter_being<
-							filtered_value_category_deducer<T, reference_kind::lvalue_const_reference_and_rvalue_reference>,
-							F,
-							nth,
-							max
-						>
-						: callable_with_nth_parameter_being<
-							filtered_value_category_deducer<T, reference_kind::rvalue_reference>,
-							F,
-							nth,
-							max
-						>;
+				constexpr auto rvalue_ref = callable_with_rvalue_ref<T, F, nth, max>
+					? reference_kind::rvalue_reference
+					: reference_kind::none;
 				
 				// We build the bitmask enum to express what overloads of different reference kind exists
 				return (
-					  (callable_with_lvalue_ref ? reference_kind::lvalue_reference : reference_kind::none)
-					| (callable_with_lvalue_const_ref ? reference_kind::lvalue_const_reference : reference_kind::none)
-					| (callable_with_rvalue_ref ? reference_kind::rvalue_reference : reference_kind::none)
-					| (callable_with_rvalue_const_ref ? reference_kind::rvalue_const_reference : reference_kind::none)
+					  lvalue_ref
+					| lvalue_const_ref
+					| rvalue_ref
+					| rvalue_const_ref
 				);
 			}
 		}
@@ -692,7 +721,7 @@ namespace kangaru {
 		
 		template<typename F, typename Deducer, std::size_t nth, std::size_t arity>
 		using prvalue_filtered_deducer_for = detail::type_traits::conditional_t<
-			    not is_nth_parameter_prvalue<F, nth, arity>
+			    not function_nth_parameter_prvalue<F, nth, arity>
 			and callable_with_nth_parameter_being<exclude_prvalue_deducer<Deducer>, F, nth, arity>,
 			exclude_prvalue_deducer<Deducer>,
 			exclude_references_deducer<Deducer>
diff --git a/include/kangaru/detail/define.hpp b/include/kangaru/detail/define.hpp
@@ -37,6 +37,7 @@
 	#define KANGARU5_NO_UNIQUE_ADDRESS [[no_unique_address]]
 	#define KANGARU5_INLINE [[clang::always_inline]]
 	#define KANGARU5_RVALUE_AMBIGUOUS() false
+	#define KANGARU5_RVALUE_CONST_AMBIGUOUS() false
 	#define KANGARU5_LVALUE_CONST_AMBIGUOUS() true
 	#define KANGARU5_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
 	
@@ -57,6 +58,7 @@
 	#define KANGARU5_NO_UNIQUE_ADDRESS [[no_unique_address]]
 	#define KANGARU5_INLINE [[gnu::always_inline]]
 	#define KANGARU5_RVALUE_AMBIGUOUS() true
+	#define KANGARU5_RVALUE_CONST_AMBIGUOUS() true
 	#define KANGARU5_LVALUE_CONST_AMBIGUOUS() false
 	#define KANGARU5_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
 	#define KANGARU5_CONSTEXPR_VOIDSTAR_CAST_SUPPORTED() (__cpp_constexpr >= 202306L)
@@ -72,6 +74,7 @@
 	#define KANGARU5_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
 	#define KANGARU5_INLINE [[msvc::forceinline]]
 	#define KANGARU5_RVALUE_AMBIGUOUS() false
+	#define KANGARU5_RVALUE_CONST_AMBIGUOUS() false
 	#define KANGARU5_LVALUE_CONST_AMBIGUOUS() true
 	#define KANGARU5_FUNCTION_SIGNATURE __FUNCSIG__
 	
diff --git a/tests/src/5-modular-source.cpp b/tests/src/5-modular-source.cpp
@@ -1,3 +1,4 @@
+#include "kangaru/detail/deducer.hpp"
 #include "kangaru/detail/injector.hpp"
 #include "kangaru/detail/recursive_source.hpp"
 #include "kangaru/detail/source.hpp"
@@ -419,12 +420,9 @@ namespace kangaru {
 }
 
 // Here's many classes, all have some relations with others
-
 struct service_1_a { int i; };
 struct service_1_b { service_1_a& s1a; int i; };
-
-// TODO: Investigate why an aggregate containing one dependency fails to be injected
-struct service_1_c { service_1_b s1b; service_1_a& s1a; };
+struct service_1_c { service_1_b s1b; };
 
 struct agg1 {
 	service_1_a& a;
@@ -450,11 +448,8 @@ struct agg2 {
 	service_2_a& s2a;
 };
 
-// TODO: Figure out how to properly inject aggregate bases.
 struct service_3_a_base { service_2_b& s2b; service_1_a& s1a; };
-struct service_3_a : service_3_a_base {
-	explicit constexpr service_3_a(service_2_b& s2b, service_1_a& s1a) : service_3_a_base{.s2b = s2b, .s1a = s1a} {}
-};
+struct service_3_a : service_3_a_base {};
 
 struct service_3_b_base {};
 struct service_3_b : service_3_b_base {
diff --git a/tests/src/5-reference-deducer.cpp b/tests/src/5-reference-deducer.cpp
