Add support for incomplete types

Author: localspook

include/fmt/base.h

@@ -1033,6 +1033,10 @@ enum {
 
 struct view {};
 
+template <typename T, bool = true> struct is_view : std::false_type {};
+template <typename T>
+struct is_view<T, sizeof(T) != 0> : std::is_base_of<view, T> {};
+
 template <typename Char, typename T> struct named_arg;
 template <typename T> struct is_named_arg : std::false_type {};
 template <typename T> struct is_static_named_arg : std::false_type {};
@@ -2726,7 +2730,7 @@ template <typename... T> struct fstring {
   template <size_t N>
   FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) {
     using namespace detail;
-    static_assert(count<(std::is_base_of<view, remove_reference_t<T>>::value &&
+    static_assert(count<(is_view<remove_cvref_t<T>>::value &&
                          std::is_reference<T>::value)...>() == 0,
                   "passing views as lvalues is disallowed");
     if (FMT_USE_CONSTEVAL) parse_format_string<char>(s, checker(s, arg_pack()));

include/fmt/color.h

@@ -468,12 +468,14 @@ template <typename Char> inline void reset_color(buffer<Char>& buffer) {
   buffer.append(reset_color.begin(), reset_color.end());
 }
 
-template <typename T> struct styled_arg : view {
+template <typename T> struct styled_arg {
   const T& value;
   text_style style;
   styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };
 
+template <typename T> struct is_view<styled_arg<T>> : std::true_type {};
+
 template <typename Char>
 void vformat_to(buffer<Char>& buf, text_style ts, basic_string_view<Char> fmt,
                 basic_format_args<buffered_context<Char>> args) {

include/fmt/ranges.h

@@ -620,7 +620,7 @@ struct formatter<
 };
 
 template <typename It, typename Sentinel, typename Char = char>
-struct join_view : detail::view {
+struct join_view {
   It begin;
   Sentinel end;
   basic_string_view<Char> sep;
@@ -629,6 +629,13 @@ struct join_view : detail::view {
       : begin(std::move(b)), end(e), sep(s) {}
 };
 
+namespace detail {
+
+template <typename It, typename Sentinel, typename Char>
+struct is_view<join_view<It, Sentinel, Char>> : std::true_type {};
+
+}  // namespace detail
+
 template <typename It, typename Sentinel, typename Char>
 struct formatter<join_view<It, Sentinel, Char>, Char> {
  private:
@@ -670,14 +677,21 @@ struct formatter<join_view<It, Sentinel, Char>, Char> {
   }
 };
 
-template <typename Char, typename Tuple> struct tuple_join_view : detail::view {
+template <typename Char, typename Tuple> struct tuple_join_view {
   const Tuple& tuple;
   basic_string_view<Char> sep;
 
   tuple_join_view(const Tuple& t, basic_string_view<Char> s)
       : tuple(t), sep{s} {}
 };
 
+namespace detail {
+
+template <typename Char, typename Tuple>
+struct is_view<tuple_join_view<Char, Tuple>> : std::true_type {};
+
+}  // namespace detail
+
 // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
 // support in tuple_join. It is disabled by default because of issues with
 // the dynamic width and precision.

test/format-test.cc

@@ -2540,3 +2540,33 @@ TEST(base_test, format_byte) {
   EXPECT_EQ(s, "42");
 }
 #endif
+
+// Only defined after the test case.
+struct incomplete_type;
+extern const incomplete_type& external_instance;
+
+FMT_BEGIN_NAMESPACE
+
+template <> struct formatter<incomplete_type> : formatter<int> {
+  auto format(const incomplete_type& x, context& ctx) const
+      -> decltype(ctx.out());
+};
+
+FMT_END_NAMESPACE
+
+TEST(incomplete_type_test, format) {
+  EXPECT_EQ(fmt::format("{}", external_instance), fmt::format("{}", 42));
+  EXPECT_EQ(fmt::format("{:4}", external_instance), fmt::format("{:4}", 42));
+}
+
+struct incomplete_type {
+  int i;
+};
+
+const incomplete_type& external_instance{42};
+
+auto fmt::formatter<incomplete_type>::format(const incomplete_type& x,
+                                             fmt::context& ctx) const
+    -> decltype(ctx.out()) {
+  return fmt::formatter<int>::format(x.i, ctx);
+}