Re-use compile-time parsed replacement fields for user-defined types

For user-defined types which:

    1. Are derived from a standard formatter.
    2. Do not define a custom parsing method.

The formatter does not need to reparse the replacement field at runtime.
Instead, the data that was parsed at compile time can be copied into the
derived formatter.

This has the added benefit of allowing nested replacement fields to work
with these kinds of user-defined types. Previously, reparsing the field
would cause BasicFormatParseContext::next_position() to roll past the
end of the format parameters.

Author: trflynn89

fly/types/string/detail/format_parameters.hpp

@@ -313,8 +313,19 @@ inline void format_user_defined_value(
 
     if constexpr (fly::FormattableWithParsing<decltype(parse_context), Formatter>)
     {
-        parse_context.lexer().set_position(specifier.m_parse_index);
-        formatter.parse(parse_context);
+        bool formatter_requires_parsing = true;
+
+        if constexpr (fly::DerivedFrom<Formatter, decltype(specifier)>)
+        {
+            formatter_requires_parsing = !specifier.m_was_parsed_as_standard_formatter;
+            specifier.copy_formatting_options_into(formatter);
+        }
+
+        if (formatter_requires_parsing)
+        {
+            parse_context.lexer().set_position(specifier.m_parse_index);
+            formatter.parse(parse_context);
+        }
     }
 
     formatter.format(*static_cast<const T *>(value), context);

fly/types/string/detail/format_specifier.hpp

@@ -213,6 +213,39 @@ struct BasicFormatSpecifier
     template <typename FormatContext>
     std::size_t precision(FormatContext &context, std::size_t fallback) const;
 
+    /**
+     * Copy formatting options from this replacement field into another replacement field (which may
+     * be an instance of or derived from this class).
+     *
+     * @param formatter The replacement field to copy formatting options into.
+     */
+    template <fly::DerivedFrom<BasicFormatSpecifier> FormatterType>
+    constexpr void copy_formatting_options_into(FormatterType &formatter) const
+    {
+        // Note: This is defined inline due to: https://bugs.llvm.org/show_bug.cgi?id=48020
+        formatter.m_position = m_position;
+
+        formatter.m_fill = m_fill;
+        formatter.m_alignment = m_alignment;
+
+        formatter.m_sign = m_sign;
+        formatter.m_alternate_form = m_alternate_form;
+        formatter.m_zero_padding = m_zero_padding;
+
+        formatter.m_width = m_width;
+        formatter.m_width_position = m_width_position;
+
+        formatter.m_precision = m_precision;
+        formatter.m_precision_position = m_precision_position;
+
+        formatter.m_locale_specific_form = m_locale_specific_form;
+
+        formatter.m_type = m_type;
+        formatter.m_case = m_case;
+
+        formatter.m_was_parsed_as_standard_formatter = m_was_parsed_as_standard_formatter;
+    }
+
     /**
      * Compare two replacement field instances for equality.
      *
@@ -248,6 +281,8 @@ struct BasicFormatSpecifier
     std::size_t m_parse_index {0};
     std::size_t m_size {0};
 
+    bool m_was_parsed_as_standard_formatter {false};
+
 private:
     /**
      * Parse the optional fill and alignment arguments of the replacement field.
@@ -474,6 +509,8 @@ constexpr BasicFormatSpecifier<CharType>::BasicFormatSpecifier(FormatParseContex
 template <fly::StandardCharacter CharType>
 constexpr void BasicFormatSpecifier<CharType>::parse(FormatParseContext &context)
 {
+    m_was_parsed_as_standard_formatter = true;
+
     parse_fill_and_alignment(context);
     parse_sign(context);
     parse_alternate_form_and_zero_padding(context);

fly/types/string/detail/format_string.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "fly/concepts/concepts.hpp"
 #include "fly/fly.hpp"
 #include "fly/types/string/concepts.hpp"
 #include "fly/types/string/detail/format_parameter_type.hpp"
@@ -205,6 +206,11 @@ constexpr void BasicFormatString<CharType, ParameterTypes...>::parse_user_define
         {
             Formatter formatter;
             formatter.parse(m_context);
+
+            if constexpr (fly::DerivedFrom<Formatter, FormatSpecifier>)
+            {
+                formatter.copy_formatting_options_into(specifier);
+            }
         }
         else
         {

test/types/string/format.cpp

@@ -788,6 +788,10 @@ CATCH_TEMPLATE_TEST_CASE(
         test_format(FMT("{:.1s}"), FMT("O"), UserFormattedEnum::One);
         test_format(FMT("{:.2s}"), FMT("On"), UserFormattedEnum::One);
         test_format(FMT("{:.3s}"), FMT("One"), UserFormattedEnum::One);
+
+        test_format(FMT("{:.{}s}"), FMT("T"), UserFormattedEnum::Two, 1);
+        test_format(FMT("{:.{}s}"), FMT("Tw"), UserFormattedEnum::Two, 2);
+        test_format(FMT("{:.{}s}"), FMT("Two"), UserFormattedEnum::Two, 3);
     }
 
     CATCH_SECTION("User-defined types may define a parse method")