Validate replacement fields for user-defined types at compile-time

While the result cannot be stored at compile-time, replacement fields of
user-defined types can be parsed for validation.

A couple of things were moved around to accomplish this. Parsing up to
and including the colon occurs before parsing standard or user-defined
replacement fields. Parsing the closing brace of standard fields now
occurs in FormatSpecifier to align with |parse| requirements.

Author: trflynn89

fly/types/string/detail/format_parameters.hpp

@@ -309,27 +309,15 @@ inline void format_user_defined_value(
     BasicFormatSpecifier<typename FormatContext::char_type> &&specifier)
 {
     using Formatter = typename FormatContext::template formatter_type<T>;
-
     Formatter formatter;
-    parse_context.lexer().set_position(specifier.m_parse_index);
 
     if constexpr (fly::FormattableWithParsing<decltype(parse_context), Formatter>)
     {
+        parse_context.lexer().set_position(specifier.m_parse_index);
         formatter.parse(parse_context);
     }
-    else
-    {
-        if (!parse_context.lexer().consume_if(FLY_CHR(typename FormatContext::char_type, '}')))
-        {
-            parse_context.on_error(
-                "User-defined formatter without a parse method may not have formatting options");
-        }
-    }
 
-    if (!parse_context.has_error())
-    {
-        formatter.format(*static_cast<const T *>(value), context);
-    }
+    formatter.format(*static_cast<const T *>(value), context);
 }
 
 //==================================================================================================

fly/types/string/detail/format_specifier.hpp

@@ -486,6 +486,11 @@ constexpr void BasicFormatSpecifier<CharType>::parse(FormatParseContext &context
     parse_type(context);
 
     validate(context);
+
+    if (!context.has_error() && !context.lexer().consume_if(s_right_brace))
+    {
+        context.on_error("Detected unclosed replacement field - must end with }");
+    }
 }
 
 //==================================================================================================

fly/types/string/detail/format_string.hpp

@@ -6,12 +6,14 @@
 #include "fly/types/string/detail/format_parse_context.hpp"
 #include "fly/types/string/detail/format_specifier.hpp"
 #include "fly/types/string/detail/traits.hpp"
+#include "fly/types/string/formatters.hpp"
 #include "fly/types/string/lexer.hpp"
 #include "fly/types/string/literals.hpp"
 
 #include <array>
 #include <cstdint>
 #include <optional>
+#include <tuple>
 #include <type_traits>
 
 namespace fly::detail {
@@ -68,19 +70,15 @@ class BasicFormatString
     constexpr FormatSpecifier parse_specifier();
 
     /**
-     * Parse a replacement field for a user-defined type.
+     * Parse a replacement field for a user-defined type. If the formatter for the user-defined type
+     * defines a |parse| method, it is invoked to parse any formatting options. Otherwise, it is an
+     * error if any formatting options are specified.
      *
      * @param specifier The replacement field being parsed.
      */
+    template <std::size_t N = 0>
     constexpr void parse_user_defined_specifier(FormatSpecifier &specifier);
 
-    /**
-     * Parse a replacement field for a standard type.
-     *
-     * @param specifier The replacement field being parsed.
-     */
-    constexpr void parse_standard_specifier(FormatSpecifier &specifier);
-
     static constexpr const auto s_left_brace = FLY_CHR(CharType, '{');
     static constexpr const auto s_right_brace = FLY_CHR(CharType, '}');
     static constexpr const auto s_colon = FLY_CHR(CharType, ':');
@@ -164,13 +162,22 @@ constexpr auto BasicFormatString<CharType, ParameterTypes...>::parse_specifier()
     FormatSpecifier specifier(m_context);
     specifier.m_parse_index = m_context.lexer().position();
 
-    if (m_context.parameter_type(specifier.m_position) == ParameterType::UserDefined)
+    if (m_context.lexer().consume_if(s_colon))
     {
-        parse_user_defined_specifier(specifier);
+        specifier.m_parse_index = m_context.lexer().position();
+
+        if (m_context.parameter_type(specifier.m_position) == ParameterType::UserDefined)
+        {
+            parse_user_defined_specifier(specifier);
+        }
+        else
+        {
+            specifier.parse(m_context);
+        }
     }
-    else
+    else if (!m_context.lexer().consume_if(s_right_brace))
     {
-        parse_standard_specifier(specifier);
+        m_context.on_error("Detected unclosed replacement field - must end with }");
     }
 
     specifier.m_size = m_context.lexer().position() - starting_position;
@@ -179,62 +186,35 @@ constexpr auto BasicFormatString<CharType, ParameterTypes...>::parse_specifier()
 
 //==================================================================================================
 template <fly::StandardCharacter CharType, typename... ParameterTypes>
+template <std::size_t N>
 constexpr void BasicFormatString<CharType, ParameterTypes...>::parse_user_defined_specifier(
     FormatSpecifier &specifier)
 {
-    // Replacement fields for user-defined types are parsed at runtime.
-    //
-    // TODO: Formatters that inherit from standard formatters might be parsed at compile time.
-    // TODO: Allow nested format specifiers.
-    std::size_t expected_close_brace_count = 1;
-    std::size_t nested_specifier_count = 0;
-
-    while (expected_close_brace_count != 0)
+    if constexpr (N < sizeof...(ParameterTypes))
     {
-        if (auto ch = m_context.lexer().consume(); ch)
+        if (N != specifier.m_position)
         {
-            if (ch == s_right_brace)
-            {
-                --expected_close_brace_count;
-            }
-            else if (ch == s_left_brace)
-            {
-                ++expected_close_brace_count;
-                ++nested_specifier_count;
-            }
-            else if (ch == s_colon)
-            {
-                specifier.m_parse_index = m_context.lexer().position();
-            }
+            parse_user_defined_specifier<N + 1>(specifier);
+            return;
+        }
+
+        using T = std::tuple_element_t<N, std::tuple<std::remove_cvref_t<ParameterTypes>...>>;
+        using Formatter = fly::Formatter<T, CharType>;
+
+        if constexpr (fly::FormattableWithParsing<FormatParseContext, Formatter>)
+        {
+            Formatter formatter;
+            formatter.parse(m_context);
         }
         else
         {
-            m_context.on_error("Detected unclosed replacement field - must end with }");
-            expected_close_brace_count = 0;
+            if (!m_context.lexer().consume_if(s_right_brace))
+            {
+                m_context.on_error(
+                    "User-defined formatter without a parser may not have formatting options");
+            }
         }
     }
-
-    if (nested_specifier_count != 0)
-    {
-        m_context.on_error("Nested replacement fields are not allowed in user-defined formatters");
-    }
-}
-
-//==================================================================================================
-template <fly::StandardCharacter CharType, typename... ParameterTypes>
-constexpr void
-BasicFormatString<CharType, ParameterTypes...>::parse_standard_specifier(FormatSpecifier &specifier)
-{
-    if (m_context.lexer().consume_if(s_colon))
-    {
-        specifier.m_parse_index = m_context.lexer().position();
-        specifier.parse(m_context);
-    }
-
-    if (!m_context.has_error() && !m_context.lexer().consume_if(s_right_brace))
-    {
-        m_context.on_error("Detected unclosed replacement field - must end with }");
-    }
 }
 
 } // namespace fly::detail

fly/types/string/string.hpp

@@ -477,12 +477,19 @@ class BasicString
      *     };
      *
      * The |parse| method is optional. If defined, it is provided a BasicFormatParseContext which
-     * contains a lexer that may be used to parse the format string. The lexer is positioned such
-     * that it is pointed at the first character after the ":" in the replacement field (if there is
-     * one), or after the opening "{" character. The |parse| method is expected to consume up to and
-     * including the closing "}" character. It may indicate any parsing errors through the parsing
-     * context; if an error occurs, the error is written to the formatted string, and formatting
-     * will halt.
+     * contains a lexer that may be used to parse the format string. The position of the lexer
+     * will be one of the following within the replacement field:
+     *
+     *     1. The position immediately after the colon, if there is one.
+     *     2. Otherwise, the position immediately after the format parameter index, if there is one.
+     *     3. Otherwise, the position immeidately after the opening brace.
+     *
+     * The |parse| method is expected to consume up to and including the closing "}" character. It
+     * must be declared constexpr, as it will be invoked at compile time to validate the replacement
+     * field. The parser may indicate any parsing errors through the parsing context; if an error
+     * occurs, the error is handled the same as any standard replacement field (see above). Even
+     * though the parser is invoked at compile time, the result of user-defined parsing cannot be
+     * stored generically. Thus, parsing is invoked again at runtime immediately before |format|.
      *
      * @tparam ParameterTypes Variadic format parameter types.
      *
@@ -969,12 +976,6 @@ void BasicString<CharType>::format_to(
 
                     const auto parameter = context.arg(specifier.m_position);
                     parameter.format(parse_context, context, std::move(specifier));
-
-                    if (parse_context.has_error())
-                    {
-                        format_to(output, FLY_ARR(char_type, "{}"), parse_context.error());
-                        return;
-                    }
                 }
                 break;
 

test/types/string/format.cpp

@@ -781,7 +781,7 @@ CATCH_TEMPLATE_TEST_CASE(
     using char_type = typename BasicString::char_type;
 
     UserDefinedType u {};
-    UserDefinedTypeWithParser p {};
+    UserDefinedTypeWithParser up {};
 
     CATCH_SECTION("User-defined types inherit parent's parse method")
     {
@@ -792,13 +792,16 @@ CATCH_TEMPLATE_TEST_CASE(
 
     CATCH_SECTION("User-defined types may define a parse method")
     {
-        test_format(FMT("{}"), FMT("false"), p);
-        test_format(FMT("{:o}"), FMT("true"), p);
+        test_format(FMT("{}"), FMT("false"), up);
+        test_format(FMT("{:o}"), FMT("true"), up);
     }
 
     CATCH_SECTION("User-defined types with a parse method may report errors")
     {
-        test_format(FMT("{:x}"), FMT("UserDefinedTypeWithParser error!"), p);
+        test_format(
+            FMT("{:x}"),
+            FMT("Ignored invalid formatter: UserDefinedTypeWithParser error!"),
+            up);
     }
 
     CATCH_SECTION("User-defined types do not need to define a parse method")
@@ -808,15 +811,17 @@ CATCH_TEMPLATE_TEST_CASE(
         test_format(FMT("{:}"), FMT("UserDefinedType"), u);
     }
 
-    CATCH_SECTION("User-defined formatter without a parse method may not have formatting options")
+    CATCH_SECTION("User-defined formatter without a parser may not have formatting options")
     {
         test_format(
             FMT("{:s}"),
-            FMT("User-defined formatter without a parse method may not have formatting options"),
+            FMT("Ignored invalid formatter: User-defined formatter without a parser may not have "
+                "formatting options"),
             u);
         test_format(
             FMT("{:.3}"),
-            FMT("User-defined formatter without a parse method may not have formatting options"),
+            FMT("Ignored invalid formatter: User-defined formatter without a parser may not have "
+                "formatting options"),
             u);
     }
 }