Do not allow presentation types for generic format parameters

Originally, either "{}" or "{:s}" were permitted due to a misreading of
the std::format specification. The string presentation type should not be
alowed.

Eventually, a mechanism similar to std::formatter should be supported,
allowing callers to fully specify the format string for generic types.

Author: trflynn89

fly/types/string/detail/string_formatter.hpp

@@ -332,14 +332,16 @@ template <
         std::is_arithmetic<T>,
         is_default_formatted_enum<StringType, T>>>
 inline void BasicStringFormatter<StringType, ParameterTypes...>::format_value(
-    FormatSpecifier &&specifier,
+    FormatSpecifier &&,
     const T &value)
 {
     static thread_local ostringstream_type s_stream;
 
     s_stream << value;
-    format_value(std::move(specifier), s_stream.str());
+    const auto formatted = s_stream.str();
     s_stream.str({});
+
+    append_string(formatted, formatted.size());
 }
 
 //==================================================================================================

fly/types/string/detail/string_formatter_types.hpp

@@ -104,7 +104,7 @@ namespace fly::detail {
  *        Strong enumeration types - If an overload of operator<< is defined, valid presentations
  *        are: none, "s". Else, valid presentations are: none, "c", b", "B", "o", "d", "x", "X".
  *
- *        Other (general) types - Valid presentations: none, "s". An overload of operator<< must be
+ *        Other (generic) types - Valid presentations: none. An overload of operator<< must be
  *        defined for generic types.
  *
  *        For details on each presentation type, see the above links.
@@ -390,37 +390,14 @@ class BasicFormatString
      * Helper trait to determine if a type is either streamable or string-like.
      */
     template <typename T>
-    using is_formatable_type = std::disjunction<
+    using is_formattable_type = std::disjunction<
         typename traits::OstreamTraits::template is_declared<T>,
         detail::is_like_supported_string<T>,
         detail::is_supported_character<T>,
         std::is_enum<std::remove_cvref_t<T>>>;
 
     template <typename T>
-    static inline constexpr bool is_formatable_type_v = is_formatable_type<T>::value;
-
-    /**
-     * Helper trait to classify an enumeration type as default-formatted (i.e. the user has not
-     * defined a custom operator<< for this type).
-     */
-    template <typename T>
-    using is_default_formatted_enum = std::conjunction<
-        std::is_enum<T>,
-        std::negation<typename traits::OstreamTraits::template is_declared<T>>>;
-
-    template <typename T>
-    static inline constexpr bool is_default_formatted_enum_v = is_default_formatted_enum<T>::value;
-
-    /**
-     * Helper trait to classify an enumeration type as user-formatted (i.e. the user has defined a
-     * custom operator<< for this type).
-     */
-    template <typename T>
-    using is_user_formatted_enum =
-        std::conjunction<std::is_enum<T>, typename traits::OstreamTraits::template is_declared<T>>;
-
-    template <typename T>
-    static inline constexpr bool is_user_formatted_enum_v = is_user_formatted_enum<T>::value;
+    static inline constexpr bool is_formattable_type_v = is_formattable_type<T>::value;
 
     /**
      * Helper trait to classify a type as an integer, excluding character and boolean types.
@@ -434,6 +411,18 @@ class BasicFormatString
     template <typename T>
     static inline constexpr bool is_integer_v = is_integer<T>::value;
 
+    /**
+     * Helper trait to classify an enumeration type as default-formatted (i.e. the user has not
+     * defined a custom operator<< for this type).
+     */
+    template <typename T>
+    using is_default_formatted_enum = std::conjunction<
+        std::is_enum<T>,
+        std::negation<typename traits::OstreamTraits::template is_declared<T>>>;
+
+    template <typename T>
+    static inline constexpr bool is_default_formatted_enum_v = is_default_formatted_enum<T>::value;
+
     /**
      * Upon parsing an un-escaped opening brace, parse a single replacement field in the format
      * string. If valid, the lexer will be advanced to the character after the closing brace.
@@ -563,12 +552,12 @@ class BasicFormatString
     constexpr void validate_type(ParameterType type, const FormatSpecifier &specifier);
 
     /**
-     * Determine the type of a format parameter. Returns ParameterType::Generic if the given index
-     * was not found, or if the type of the format parameter is unknown.
+     * Determine the type of a format parameter. Returns ParameterType::Generic if the type of the
+     * format parameter is unknown.
      *
      * @param index The index of the format parameter to inspect.
      *
-     * @return The type of the format parameter.
+     * @return If found, the type of the format parameter. Otherwise, an uninitialized value.
      */
     template <size_t N = 0>
     constexpr std::optional<ParameterType> parameter_type(size_t index);
@@ -791,7 +780,7 @@ FLY_CONSTEVAL BasicFormatString<StringType, ParameterTypes...>::BasicFormatStrin
 {
     std::optional<char_type> ch;
 
-    if constexpr (!(is_formatable_type_v<ParameterTypes> && ...))
+    if constexpr (!(is_formattable_type_v<ParameterTypes> && ...))
     {
         on_error("An overloaded operator<< must be defined for all format parameters");
     }
@@ -1204,10 +1193,9 @@ constexpr void BasicFormatString<StringType, ParameterTypes...>::validate_type(
     switch (type)
     {
         case ParameterType::Generic:
-            if ((specifier.m_type != FormatSpecifier::Type::None) &&
-                (specifier.m_type != FormatSpecifier::Type::String))
+            if (specifier.m_type != FormatSpecifier::Type::None)
             {
-                on_error("Generic types must be formatted with {} or {:s}");
+                on_error("Generic types must be formatted with {}");
             }
             break;
 
@@ -1227,7 +1215,7 @@ constexpr void BasicFormatString<StringType, ParameterTypes...>::validate_type(
             if ((specifier.m_type != FormatSpecifier::Type::None) &&
                 (specifier.m_type != FormatSpecifier::Type::String))
             {
-                on_error("String types and user-formatted enums must be formatted with {} or {:s}");
+                on_error("String types must be formatted with {} or {:s}");
             }
             break;
 
@@ -1247,9 +1235,7 @@ constexpr void BasicFormatString<StringType, ParameterTypes...>::validate_type(
                 (specifier.m_type != FormatSpecifier::Type::Decimal) &&
                 (specifier.m_type != FormatSpecifier::Type::Hex))
             {
-                on_error(
-                    "Integral types and default-formatted enums must be formatted with {} or one "
-                    "of {:cbBodxX}");
+                on_error("Integral types must be formatted with {} or one of {:cbBodxX}");
             }
             break;
 
@@ -1298,7 +1284,7 @@ constexpr auto BasicFormatString<StringType, ParameterTypes...>::parameter_type(
         {
             return ParameterType::Character;
         }
-        else if constexpr (is_like_supported_string_v<T> || is_user_formatted_enum_v<T>)
+        else if constexpr (is_like_supported_string_v<T>)
         {
             return ParameterType::String;
         }

fly/types/string/string.hpp

@@ -414,7 +414,7 @@ class BasicString
      *       the type of the format string.
      *
      *    3. Any generic type for which an operator<< overload is defined will be converted to a
-     *       string using that overload. Formatting options will then be applied to that string.
+     *       string using that overload.
      *
      *    4. Formatting of strong enumeration types defaults to the format of the enumeration's
      *       underlying type. However, if an overload of operator<< is defined, the type is treated
@@ -474,7 +474,7 @@ class BasicString
      *       the type of the format string.
      *
      *    3. Any generic type for which an operator<< overload is defined will be converted to a
-     *       string using that overload. Formatting options will then be applied to that string.
+     *       string using that overload.
      *
      *    4. Formatting of strong enumeration types defaults to the format of the enumeration's
      *       underlying type. However, if an overload of operator<< is defined, the type is treated

test/types/string/string_formatter.cpp

@@ -21,6 +21,46 @@ namespace {
 
 #define FMT(format) FLY_ARR(char_type, format)
 
+struct GenericType
+{
+};
+
+[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const GenericType &)
+{
+    stream << "GenericType";
+    return stream;
+}
+
+[[maybe_unused]] std::wostream &operator<<(std::wostream &stream, const GenericType &)
+{
+    stream << L"GenericType";
+    return stream;
+}
+
+enum class DefaultFormattedEnum
+{
+    One = 1,
+    Two = 2,
+};
+
+enum class UserFormattedEnum
+{
+    One = 1,
+    Two = 2,
+};
+
+[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const UserFormattedEnum &u)
+{
+    stream << (u == UserFormattedEnum::One ? "One" : "Two");
+    return stream;
+}
+
+[[maybe_unused]] std::wostream &operator<<(std::wostream &stream, const UserFormattedEnum &u)
+{
+    stream << (u == UserFormattedEnum::One ? L"One" : L"Two");
+    return stream;
+}
+
 template <typename StringType, typename... ParameterTypes>
 using FormatString = fly::detail::BasicFormatString<
     fly::detail::is_like_supported_string_t<StringType>,
@@ -62,30 +102,6 @@ StringType reserved_codepoint()
     return result;
 }
 
-enum class DefaultFormattedEnum
-{
-    One = 1,
-    Two = 2,
-};
-
-enum class UserFormattedEnum
-{
-    One = 1,
-    Two = 2,
-};
-
-[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const UserFormattedEnum &u)
-{
-    stream << (u == UserFormattedEnum::One ? "One" : "Two");
-    return stream;
-}
-
-[[maybe_unused]] std::wostream &operator<<(std::wostream &stream, const UserFormattedEnum &u)
-{
-    stream << (u == UserFormattedEnum::One ? "One" : "Two");
-    return stream;
-}
-
 } // namespace
 
 CATCH_TEMPLATE_TEST_CASE(
@@ -460,6 +476,14 @@ CATCH_TEMPLATE_TEST_CASE(
         test_format(FMT("{1:.{0}s}"), FMT("abcdef"), -3, FLY_STR(char_type, "abcdef"));
     }
 
+    CATCH_SECTION("Generic types may be formatted without presentation type")
+    {
+        GenericType gt {};
+        test_format(FMT("{}"), FMT("GenericType"), gt);
+        test_format(FMT("{}"), FMT("One"), UserFormattedEnum::One);
+        test_format(FMT("{}"), FMT("Two"), UserFormattedEnum::Two);
+    }
+
     CATCH_SECTION("Presentation type may be set (character)")
     {
         test_format(FMT("{:c}"), FMT("a"), 'a');
@@ -515,9 +539,6 @@ CATCH_TEMPLATE_TEST_CASE(
 
         test_format(FMT("{:s}"), FMT("true"), true);
         test_format(FMT("{:s}"), FMT("false"), false);
-
-        test_format(FMT("{:s}"), FMT("One"), UserFormattedEnum::One);
-        test_format(FMT("{:s}"), FMT("Two"), UserFormattedEnum::Two);
     }
 
     CATCH_SECTION("Presentation type may be set (pointer)")