Fixes breakage with odd format functions.

Author: mordante

libcxx/include/__format/format_arg_store.h

@@ -16,11 +16,15 @@
 
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
+#include <__concepts/semiregular.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_arg.h>
+#include <__format/format_parse_context.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/extent.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/remove_const.h>
 #include <cstdint>
 #include <string>
@@ -227,16 +231,6 @@ template <class _Context, class _Tp>
         { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
       };
 
-  constexpr bool __has_format_function = requires(_Formatter& __f, _Tp&& __t, _Context __fc) {
-    { __f.format(__t, __fc) };
-  };
-  constexpr bool __is_format_function_const_qualified = requires(const _Formatter& __cf, _Tp&& __t, _Context __fc) {
-    { __cf.format(__t, __fc) };
-  };
-  constexpr bool __correct_format_function_return_type = requires(_Formatter& __f, _Tp&& __t, _Context __fc) {
-    { __f.format(__t, __fc)->same_as<typename _Context::iterator> };
-  };
-
   // The reason these static_asserts are placed in an if-constexpr-chain is to
   // only show one error. For example, when the formatter is not specialized it
   // would show all static_assert messages. With this chain the compiler only
@@ -253,17 +247,37 @@ template <class _Context, class _Tp>
   else if constexpr (!__correct_parse_function_return_type)
     static_assert(false, "The required formatter specialization's parse function does not return the required type.");
 
-  else if constexpr (!__has_format_function)
-    static_assert(
-        false, "The required formatter specialization does not have a format function taking the proper arguments.");
-  else if constexpr (!__is_format_function_const_qualified)
-    static_assert(false, "The required formatter specialization's format function is not const qualified.");
-  else if constexpr (!__correct_format_function_return_type)
-    static_assert(false, "The required formatter specialization's format function does not return the required type.");
+  else {
+    // During constant evaluation this function is called, but the format
+    // member function has not been evaluated. This means these functions
+    // can't be evaluated at that time.
+    //
+    // Note this else branch should never been taken during constant
+    // eveluation, the static_asserts in one of the branches above should
+    // trigger.
+    constexpr bool __has_format_function = requires(_Formatter& __f, _Tp&& __t, _Context __fc) {
+      { __f.format(__t, __fc) };
+    };
+    constexpr bool __is_format_function_const_qualified = requires(const _Formatter& __cf, _Tp&& __t, _Context __fc) {
+      { __cf.format(__t, __fc) };
+    };
+    constexpr bool __correct_format_function_return_type = requires(_Formatter& __f, _Tp&& __t, _Context __fc) {
+      { __f.format(__t, __fc)->same_as<typename _Context::iterator> };
+    };
+
+    if constexpr (!__has_format_function)
+      static_assert(
+          false, "The required formatter specialization does not have a format function taking the proper arguments.");
+    else if constexpr (!__is_format_function_const_qualified)
+      static_assert(false, "The required formatter specialization's format function is not const qualified.");
+    else if constexpr (!__correct_format_function_return_type)
+      static_assert(
+          false, "The required formatter specialization's format function does not return the required type.");
 
-  else
-    // This should not happen; it makes sure the code is ill-formed.
-    static_assert(false, "The required formatter specialization is not formattable with its context.");
+    else
+      // This should not happen; it makes sure the code is ill-formed.
+      static_assert(false, "The required formatter specialization is not formattable with its context.");
+  }
 }
 
 // The Psuedo constructor is constrained per [format.arg]/4.

libcxx/include/__format/format_functions.h

@@ -13,6 +13,7 @@
 #include <__algorithm/clamp.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/same_as.h>
+#include <__concepts/semiregular.h>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/format_arg.h>
@@ -78,6 +79,27 @@ template <class... _Args>
 
 namespace __format {
 
+/// A "watered-down" __formattable_with for usage during constant evaluation.
+///
+/// The member function "format" can have a decuded return type. When
+/// constraining the __compile_time_handle this leads to a nested concept
+/// eveluation that is always false. Instead ignore the "format" member function.
+///
+/// In theory the same could happen to the "parse" member function. However
+/// thisfunction does not is less likely to have odd cased, and this function
+/// is "required" to be called during constant evaluation. So if this
+/// function's return type needs to be deduced things will probably not work.
+///
+/// See https://github.com/llvm/llvm-project/issues/81590 and
+/// test/std/utilities/format/format.functions/bug_81590.compile.pass.cpp for
+/// an example of a problematic "format" member function.
+template <class _Tp, class _Context, class _Formatter = typename _Context::template formatter_type<remove_const_t<_Tp>>>
+concept __formattable_with_constexpr =
+    semiregular<_Formatter> &&
+    requires(_Formatter& __f, _Tp&& __t, basic_format_parse_context<typename _Context::char_type> __pc) {
+      { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
+    };
+
 /// Helper class parse and handle argument.
 ///
 /// When parsing a handle which is not enabled the code is ill-formed.
@@ -91,7 +113,7 @@ class _LIBCPP_TEMPLATE_VIS __compile_time_handle {
   }
 
   template <class _Tp>
-    requires __formattable_with<_Tp, __format_context<_CharT>>
+    requires __formattable_with_constexpr<_Tp, __format_context<_CharT>>
   _LIBCPP_HIDE_FROM_ABI constexpr void __enable() {
     __parse_ = [](basic_format_parse_context<_CharT>& __ctx) {
       formatter<_Tp, _CharT> __f;