Rename field_type_at to field_value_type_at

The alias strips cv from the deduced field type, producing a value type
suitable as a function parameter or local variable. The old name read as
"the field's type" — misleading, since callers cannot use it to inspect
the original field's const-ness. Rename to field_value_type_at(_t) so
the name matches what the alias actually yields.

No behavioural change. Two call sites in Settings.hpp updated; nothing
else used the alias.

Author: Centimo

include/rfl/Settings.hpp

@@ -54,7 +54,7 @@ T settings_with_replaced(
 template <class T, StringLiteral Name>
 T settings_with_replaced_by_name(
     const T& _obj,
-    field_type_at_t<T, field_index_by_name_v<T, Name>> _value) {
+    field_value_type_at_t<T, field_index_by_name_v<T, Name>> _value) {
   constexpr std::size_t I = field_index_by_name_v<T, Name>;
   static_assert(I != static_cast<std::size_t>(-1),
                 "No field with the given name exists in T.");
@@ -90,7 +90,7 @@ T settings_with_replaced_by_name(
         *this, std::move(_value));                                             \
   }                                                                            \
   template <::rfl::internal::StringLiteral Name>                               \
-  Derived with(::rfl::internal::field_type_at_t<                               \
+  Derived with(::rfl::internal::field_value_type_at_t<                         \
                Derived,                                                        \
                ::rfl::internal::field_index_by_name_v<Derived, Name>>          \
                    _value) const {                                             \

include/rfl/internal/field_index_by_name.hpp

@@ -38,9 +38,12 @@ inline constexpr std::size_t field_index_by_name_v =
     field_index_by_name_impl<T, Name>(
         std::make_index_sequence<num_fields<T>>{});
 
-/// Helper: extracts the value type the i-th fake-object pointer points to.
+/// Helper: extracts the cv-stripped value type of the i-th field of T,
+/// suitable as a function parameter or local variable type. Use this when
+/// you need to declare an object of the field's type; do not use it to
+/// inspect const-ness of the original field declaration (cv is removed).
 template <class T, std::size_t I>
-struct field_type_at {
+struct field_value_type_at {
   using type = std::remove_cv_t<std::remove_pointer_t<
       decltype(get_ith_field_from_fake_object<T, static_cast<int>(I)>())>>;
 };
@@ -54,12 +57,12 @@ struct unresolved_field_type {};
 /// that a failing field_index_by_name_v lookup does not trip an out-of-range
 /// instantiation before the caller's static_assert can fire.
 template <class T>
-struct field_type_at<T, static_cast<std::size_t>(-1)> {
+struct field_value_type_at<T, static_cast<std::size_t>(-1)> {
   using type = unresolved_field_type;
 };
 
 template <class T, std::size_t I>
-using field_type_at_t = typename field_type_at<T, I>::type;
+using field_value_type_at_t = typename field_value_type_at<T, I>::type;
 
 }  // namespace rfl::internal