From fefefeb7f6a896946bba28a26b6ca7b98b54928d Mon Sep 17 00:00:00 2001
From: Pavel Labath <labath@google.com>
Date: Thu, 8 Dec 2016 11:31:19 +0000
Subject: Improve format member detection in llvm::formatv

Summary:
The existing detection of a format member function has a couple of deficiencies:
- the member function does not get detected if one calls formatv with an lvalue,
  because the template parameter gets deduced as T&, which fails the is_class
  check.
- it also did not work if the function was called with a const variable because
  the template parameter would get deduced as const T&, again failing the
  is_class check.

This fixes the problem by stripping the references in the uses_format_member
template, to make sure the type is correctly detected as class. It also provides
specializations of the has_FormatMember template for const and non-const members
of the types in order to enable declaring the format member as a "const"
function. I have added tests that verify that formatv can be now called in these
scenarios. As some scenarios could not be verified at runtime (e.g. making sure
that calling a non-const format member on a const object does *not* compile), I
have also added some static_asserts which test the behaviour of the template
classes used internally by formatv().

Reviewers: zturner

Subscribers: llvm-commits

Differential Revision: https://reviews.llvm.org/D27525

llvm-svn: 289040
---
 llvm/unittests/Support/FormatVariadicTest.cpp | 56 ++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 2 deletions(-)

(limited to 'llvm/unittests/Support/FormatVariadicTest.cpp')

diff --git a/llvm/unittests/Support/FormatVariadicTest.cpp b/llvm/unittests/Support/FormatVariadicTest.cpp
index 7dd23cfa2f8..9c87c9e53b5 100644
--- a/llvm/unittests/Support/FormatVariadicTest.cpp
+++ b/llvm/unittests/Support/FormatVariadicTest.cpp
@@ -13,6 +13,35 @@
 
 using namespace llvm;
 
+// Compile-time tests for the uses_format_member template
+namespace {
+struct ConstFormat {
+  void format(raw_ostream &OS, StringRef Opt) const { OS << "ConstFormat"; }
+};
+
+struct Format {
+  void format(raw_ostream &OS, StringRef Opt) { OS << "Format"; }
+};
+
+using detail::uses_format_member;
+
+static_assert(uses_format_member<Format>::value, "");
+static_assert(uses_format_member<Format &>::value, "");
+static_assert(uses_format_member<Format &&>::value, "");
+static_assert(not uses_format_member<const Format>::value, "");
+static_assert(not uses_format_member<const Format &>::value, "");
+static_assert(not uses_format_member<const volatile Format>::value, "");
+static_assert(not uses_format_member<const volatile Format &>::value, "");
+
+static_assert(uses_format_member<ConstFormat>::value, "");
+static_assert(uses_format_member<ConstFormat &>::value, "");
+static_assert(uses_format_member<ConstFormat &&>::value, "");
+static_assert(uses_format_member<const ConstFormat>::value, "");
+static_assert(uses_format_member<const ConstFormat &>::value, "");
+static_assert(uses_format_member<const volatile ConstFormat>::value, "");
+static_assert(uses_format_member<const volatile ConstFormat &>::value, "");
+}
+
 TEST(FormatVariadicTest, EmptyFormatString) {
   auto Replacements = formatv_object_base::parseFormatString("");
   EXPECT_EQ(0U, Replacements.size());
@@ -511,7 +540,7 @@ TEST(FormatVariadicTest, Adapter) {
 
   public:
     explicit Negative(int N) : N(N) {}
-    void format(raw_ostream &S, StringRef Options) { S << -N; }
+    void format(raw_ostream &S, StringRef Options) const { S << -N; }
   };
 
   EXPECT_EQ("-7", formatv("{0}", Negative(7)).str());
@@ -535,4 +564,27 @@ TEST(FormatVariadicTest, ImplicitConversions) {
 
   SmallString<4> S2 = formatv("{0} {1}", 1, 2);
   EXPECT_EQ("1 2", S2);
-}
\ No newline at end of file
+}
+
+TEST(FormatVariadicTest, FormatMember) {
+  EXPECT_EQ("Format", formatv("{0}", Format()).str());
+
+  Format var;
+  EXPECT_EQ("Format", formatv("{0}", var).str());
+  EXPECT_EQ("Format", formatv("{0}", std::move(var)).str());
+
+  // Not supposed to compile
+  // const Format cvar{};
+  // EXPECT_EQ("Format", formatv("{0}", cvar).str());
+}
+
+TEST(FormatVariadicTest, FormatMemberConst) {
+  EXPECT_EQ("ConstFormat", formatv("{0}", ConstFormat()).str());
+
+  ConstFormat var;
+  EXPECT_EQ("ConstFormat", formatv("{0}", var).str());
+  EXPECT_EQ("ConstFormat", formatv("{0}", std::move(var)).str());
+
+  const ConstFormat cvar{};
+  EXPECT_EQ("ConstFormat", formatv("{0}", cvar).str());
+}
-- 
cgit v1.2.3