fix format ambiguity if implicitly convertible to std::tuple

src/detail/arg_fmt.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "src/detail/is_range.hpp"
+#include "src/detail/is_specialization_of.hpp"
 #include "src/detail/priority.hpp"
 #include "src/detail/type_name.hpp"
 #include "src/rope.hpp"
@@ -38,9 +39,16 @@ class arg_fmt_fn
   }
 
   template <
-      class... Ts,
-      std::enable_if_t<not is_ostreamable_v<std::tuple<Ts...>>, bool> = true>
-  static constexpr auto impl(priority<2>, const std::tuple<Ts...>& arg)
+      class T,
+      std::enable_if_t<
+          is_specialization_of_v<T, std::tuple> and not is_ostreamable_v<T>,
+          bool> = true>
+  static constexpr auto impl(priority<2>, const T& arg)
+  {
+    return tuple_impl(arg);
+  }
+  template <class... Ts>
+  static constexpr auto tuple_impl(const std::tuple<Ts...>& arg)
   {
     return tuple_fmt<Ts...>{arg};
   }

test/BUILD.bazel

@@ -130,6 +130,7 @@ skytest_test(
     stdout = [
         "empty(\\[1, 2, 3\\])",
         "empty({4}{5})",
+        "custom_tuple != custom_tuple",
         "wrapped{...} == wrapped{...}",
     ],
 )

test/arg_fmt_test.cpp

@@ -27,6 +27,16 @@ struct array : std::array<T, N>
   }
 };
 
+template <class... Ts>
+struct custom_tuple : std::tuple<Ts...>
+{
+  friend auto& operator<<(std::ostream& os, const custom_tuple&)
+  {
+    os << "custom_tuple";
+    return os;
+  }
+};
+
 struct wrapped
 {
   int value;
@@ -39,6 +49,7 @@ auto main() -> int
   using namespace ::skytest::literals;
   using ::skytest::eq;
   using ::skytest::expect;
+  using ::skytest::ne;
 
   "array uses default range arg fmt"_test = [] {
     return expect(empty(std::array{1, 2, 3}));
@@ -48,6 +59,10 @@ auto main() -> int
     return expect(empty(array<int, 2>{4, 5}));
   };
 
+  "custom tuple uses custom fmt"_test = [] {
+    return expect(ne(custom_tuple{}, custom_tuple{}));
+  };
+
   "type without operator<< is displayed"_test = [] {
     return expect(eq(wrapped{1}, wrapped{2}));
   };