[Support] Add format_provider for StringLiteral

[labath]

Summary

Even though it inherits from StringRef, we need to mention it
explicitly, as the formatter selection mechanism does not take
inheritance into account.

[dblaikie]

include/llvm/Support/FormatProviders.h

49–50 ↗

(On Diff #88219)

Perhaps this should use "is_convertible" which would match the implementation (well, not quite - the implementation should probably use "StringRef S = V" rather than StringRef S(V))?

[zturner]

include/llvm/Support/FormatProviders.h

49–50 ↗

(On Diff #88219)

If it works I'm all for simplifying. Need to be careful with potentially overlapping conditions though.

[labath]

Using is_convertible will work right now. What will this prevent is someone
defining their own format_provider on a class which has a conversion operator
for StringRef. I've debated this with myself a bit. On one hand, it adds more
predictability (if something behaves enough like StringRef that in can be
converted to one, it should also be formatted like it). On the other hand, I'm
sure somebody somewhere will invent a case where it still makes sense to do
that.

But I suppose we can cross that bridge when we come to it.

[dblaikie]

Looks good to me - but please wait for Zach to take a look & sign off.

llvm/trunk/include/llvm/Support/FormatProviders.h

 template <typename T>
 struct is_cstring
     : public std::integral_constant<bool,
                                     is_one_of<T, char *, const char *>::value> {
 };
 
 template <typename T>
 struct use_string_formatter
-    : public std::integral_constant<
-          bool, is_one_of<T, llvm::StringRef, std::string>::value ||
-                    is_cstring<T>::value> {};
+    : public std::integral_constant<bool,
+                                    std::is_convertible<T, llvm::StringRef>::value> {};
 
 template <typename T>
 struct use_pointer_formatter
     : public std::integral_constant<bool, std::is_pointer<T>::value &&
                                               !is_cstring<T>::value> {};
 
 template <typename T>
 struct use_double_formatter

 template <typename T>
 struct format_provider<
     T, typename std::enable_if<detail::use_string_formatter<T>::value>::type> {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     size_t N = StringRef::npos;
     if (!Style.empty() && Style.getAsInteger(10, N)) {
       assert(false && "Style is not a valid integer");
     }
-    llvm::StringRef S(V);
+    llvm::StringRef S = V;
     Stream << S.substr(0, N);
   }
 };
 
 /// Implementation of format_provider<T> for characters.
 ///
 /// The options string of a character type has the grammar:
 ///

llvm/trunk/unittests/Support/FormatVariadicTest.cpp

TEST(FormatVariadicTest, IntegralNumberFormatting) {
   EXPECT_EQ("     -1,000", formatv("{0,11:N}", -1000).str());
   EXPECT_EQ("   -100,000", formatv("{0,11:N}", -100000).str());
 }
 
 TEST(FormatVariadicTest, StringFormatting) {
   const char FooArray[] = "FooArray";
   const char *FooPtr = "FooPtr";
   llvm::StringRef FooRef("FooRef");
+  constexpr StringLiteral FooLiteral("FooLiteral");
   std::string FooString("FooString");
   // 1. Test that we can print various types of strings.
   EXPECT_EQ(FooArray, formatv("{0}", FooArray).str());
   EXPECT_EQ(FooPtr, formatv("{0}", FooPtr).str());
   EXPECT_EQ(FooRef, formatv("{0}", FooRef).str());
+  EXPECT_EQ(FooLiteral, formatv("{0}", FooLiteral).str());
   EXPECT_EQ(FooString, formatv("{0}", FooString).str());
 
   // 2. Test that the precision specifier prints the correct number of
   // characters.
   EXPECT_EQ("FooA", formatv("{0:4}", FooArray).str());
   EXPECT_EQ("FooP", formatv("{0:4}", FooPtr).str());
   EXPECT_EQ("FooR", formatv("{0:4}", FooRef).str());
   EXPECT_EQ("FooS", formatv("{0:4}", FooString).str());