Fixes breakage with odd format functions.

Author: mordante

libcxx/include/__format/format_arg_store.h

@@ -227,16 +227,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 +243,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

@@ -78,6 +78,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 +112,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;

libcxx/test/libcxx/utilities/format/format.functions/format.verify.cpp

@@ -1,3 +1,4 @@
+//===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,6 +16,7 @@
 // diagnoses the issue.
 
 #include <format>
+#include <variant>
 
 struct no_formatter_specialization {};
 void test_no_formatter_specialization() {
@@ -36,7 +38,9 @@ struct std::formatter<correct_formatter_specialization, CharT> {
   }
 
   template <class FormatContext>
-  typename FormatContext::iterator format(correct_formatter_specialization&, FormatContext&) const;
+  typename FormatContext::iterator format(correct_formatter_specialization&, FormatContext& ctx) const {
+    return ctx.out();
+  }
 };
 void test_correct_formatter_specialization() {
   correct_formatter_specialization t;
@@ -52,7 +56,9 @@ struct std::formatter<formatter_not_semiregular, CharT> {
   formatter(int);
 
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
 
   template <class FormatContext>
   typename FormatContext::iterator format(formatter_not_semiregular&, FormatContext&) const;
@@ -87,7 +93,9 @@ struct parse_function_invalid_arguments {};
 template <class CharT>
 struct std::formatter<parse_function_invalid_arguments, CharT> {
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&, int);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx, int) {
+    return ctx.begin();
+  }
 
   template <class FormatContext>
   typename FormatContext::iterator format(parse_function_invalid_arguments&, FormatContext&) const;
@@ -106,7 +114,9 @@ struct parse_function_invalid_return_type {};
 template <class CharT>
 struct std::formatter<parse_function_invalid_return_type, CharT> {
   template <class ParseContext>
-  constexpr int parse(ParseContext&);
+  constexpr int parse(ParseContext&) {
+    return 42;
+  }
 
   template <class FormatContext>
   typename FormatContext::iterator format(parse_function_invalid_return_type&, FormatContext&) const;
@@ -125,7 +135,9 @@ struct no_format_function {};
 template <class CharT>
 struct std::formatter<no_format_function, CharT> {
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
 };
 void test_no_format_function() {
   no_format_function t;
@@ -141,7 +153,9 @@ struct format_function_invalid_arguments {};
 template <class CharT>
 struct std::formatter<format_function_invalid_arguments, CharT> {
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
 
   template <class FormatContext>
   typename FormatContext::iterator format(format_function_invalid_arguments&) const;
@@ -160,7 +174,9 @@ struct format_function_invalid_return_type {};
 template <class CharT>
 struct std::formatter<format_function_invalid_return_type, CharT> {
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
 
   template <class FormatContext>
   int format(format_function_invalid_return_type&, FormatContext&) const;
@@ -179,7 +195,9 @@ struct format_function_not_const_qualified {};
 template <class CharT>
 struct std::formatter<format_function_not_const_qualified, CharT> {
   template <class ParseContext>
-  constexpr typename ParseContext::iterator parse(ParseContext&);
+  constexpr typename ParseContext::iterator parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
 
   template <class FormatContext>
   typename FormatContext::iterator format(format_function_not_const_qualified&, FormatContext&);
@@ -193,3 +211,193 @@ void test_format_function_not_const_qualified() {
   (void)std::format(L"{}", t);
 #endif
 }
+
+struct auto_deduction_correct_formatter_specialization
+    : std::variant<auto_deduction_correct_formatter_specialization*> {
+  auto_deduction_correct_formatter_specialization* p = nullptr;
+  constexpr const std::variant<auto_deduction_correct_formatter_specialization*>& decay() const noexcept {
+    return *this;
+  }
+};
+
+template <>
+struct std::formatter<auto_deduction_correct_formatter_specialization, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+  static constexpr auto format(const auto_deduction_correct_formatter_specialization& x, auto& ctx) {
+    if (!x.p)
+      return ctx.out();
+    auto m = [&](const auto_deduction_correct_formatter_specialization* t) {
+      return std::format_to(ctx.out(), "{}", *t);
+    };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_correct_formatter_specialization() {
+  auto_deduction_correct_formatter_specialization t;
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_no_parse_function : std::variant<auto_deduction_no_parse_function*> {
+  auto_deduction_no_parse_function* p = nullptr;
+  constexpr const std::variant<auto_deduction_no_parse_function*>& decay() const noexcept { return *this; }
+};
+
+template <>
+struct std::formatter<auto_deduction_no_parse_function, char> {
+  static constexpr auto format(const auto_deduction_no_parse_function& x, auto& ctx) {
+    if (!x.p)
+      return ctx.out();
+    auto m = [&](const auto_deduction_no_parse_function* t) { return std::format_to(ctx.out(), "{}", *t); };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_no_parse_function() {
+  auto_deduction_no_parse_function t;
+  // expected-error@*:* {{static assertion failed: The required formatter specialization does not have a parse function taking the proper arguments.}}
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_parse_function_invalid_arguments
+    : std::variant<auto_deduction_parse_function_invalid_arguments*> {
+  auto_deduction_parse_function_invalid_arguments* p = nullptr;
+  constexpr const std::variant<auto_deduction_parse_function_invalid_arguments*>& decay() const noexcept {
+    return *this;
+  }
+};
+
+template <>
+struct std::formatter<auto_deduction_parse_function_invalid_arguments, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext& ctx, int) {
+    return ctx.begin();
+  }
+  static constexpr auto format(const auto_deduction_parse_function_invalid_arguments& x, auto& ctx) {
+    if (!x.p)
+      return ctx.out();
+    auto m = [&](const auto_deduction_parse_function_invalid_arguments* t) {
+      return std::format_to(ctx.out(), "{}", *t);
+    };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_parse_function_invalid_arguments() {
+  auto_deduction_parse_function_invalid_arguments t;
+  // expected-error@*:* {{static assertion failed: The required formatter specialization does not have a parse function taking the proper arguments.}}
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_parse_function_invalid_return_types
+    : std::variant<auto_deduction_parse_function_invalid_return_types*> {
+  auto_deduction_parse_function_invalid_return_types* p = nullptr;
+  constexpr const std::variant<auto_deduction_parse_function_invalid_return_types*>& decay() const noexcept {
+    return *this;
+  }
+};
+
+template <>
+struct std::formatter<auto_deduction_parse_function_invalid_return_types, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext&) {
+    return 42;
+  }
+  static constexpr auto format(const auto_deduction_parse_function_invalid_return_types& x, auto& ctx) {
+    if (!x.p)
+      return ctx.out();
+    auto m = [&](const auto_deduction_parse_function_invalid_return_types* t) {
+      return std::format_to(ctx.out(), "{}", *t);
+    };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_parse_function_invalid_return_types() {
+  // expected-error@*:* {{static assertion failed: The required formatter specialization's parse function does not return the required type.}}
+  auto_deduction_parse_function_invalid_return_types t;
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_no_format_function : std::variant<auto_deduction_no_format_function*> {
+  auto_deduction_no_format_function* p = nullptr;
+  // expected-error@*:* 2 {{static assertion failed: The required formatter specialization's format function does not return the required type.}}
+  constexpr const std::variant<auto_deduction_no_format_function*>& decay() const noexcept { return *this; }
+};
+
+template <>
+struct std::formatter<auto_deduction_no_format_function, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+};
+
+void test_auto_deduction_no_format_function() {
+  // expected-error@*:* {{static assertion failed: The required formatter specialization does not have a format function taking the proper arguments.}}
+  auto_deduction_no_format_function t;
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_format_function_invalid_arguments
+    : std::variant<auto_deduction_format_function_invalid_arguments*> {
+  auto_deduction_format_function_invalid_arguments* p = nullptr;
+  constexpr const std::variant<auto_deduction_format_function_invalid_arguments*>& decay() const noexcept {
+    return *this;
+  }
+};
+
+template <>
+struct std::formatter<auto_deduction_format_function_invalid_arguments, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+  static constexpr auto format(const auto_deduction_format_function_invalid_arguments& x, auto& ctx, int) {
+    if (!x.p)
+      return ctx.out();
+    auto m = [&](const auto_deduction_format_function_invalid_arguments* t) {
+      return std::format_to(ctx.out(), "{}", *t);
+    };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_format_function_invalid_arguments() {
+  // expected-error@*:* {{static assertion failed: The required formatter specialization does not have a format function taking the proper arguments.}}
+  auto_deduction_format_function_invalid_arguments t;
+  (void)std::format("{}", t);
+}
+
+struct auto_deduction_format_function_invalid_return_types
+    : std::variant<auto_deduction_format_function_invalid_return_types*> {
+  auto_deduction_format_function_invalid_return_types* p = nullptr;
+  constexpr const std::variant<auto_deduction_format_function_invalid_return_types*>& decay() const noexcept {
+    return *this;
+  }
+};
+
+template <>
+struct std::formatter<auto_deduction_format_function_invalid_return_types, char> {
+  template <class ParseContext>
+  static constexpr auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+  static constexpr auto format(const auto_deduction_format_function_invalid_return_types& x, auto& ctx) {
+    if (!x.p)
+      return 42;
+    auto m = [&](const auto_deduction_format_function_invalid_return_types* t) {
+      std::format_to(ctx.out(), "{}", *t);
+      return 42;
+    };
+    return std::visit(m, x.decay());
+  }
+};
+
+void test_auto_deduction_format_function_invalid_return_types() {
+  auto_deduction_format_function_invalid_return_types t;
+  (void)std::format("{}", t);
+}