ADT: Make StringRef::size() and StringRef::empty() constexpr

[dexonsmith]

Summary

This unblocks using StringLiteral::size() for a SmallVector size in
another patch.

[dblaikie]

Sounds good!

llvm/include/llvm/ADT/StringRef.h

#endif
 
     /// data - Get a pointer to the start of the string (which may not be null
     /// terminated).
     LLVM_NODISCARD
     const char *data() const { return Data; }
 
     /// empty - Check if the string is empty.
     LLVM_NODISCARD
-    bool empty() const { return Length == 0; }
+    constexpr bool empty() const { return Length == 0; }
 
     /// size - Get the string size.
     LLVM_NODISCARD
-    size_t size() const { return Length; }
+    constexpr size_t size() const { return Length; }
 
     /// front - Get the first character in the string.
     LLVM_NODISCARD
     char front() const {
       assert(!empty());
       return Data[0];
     }
 

llvm/unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, DropWhileUntil) {
   StringRef EmptyString = "";
   Taken = EmptyString.drop_while([](char c) { return true; });
   EXPECT_EQ("", Taken);
 }
 
 TEST(StringRefTest, StringLiteral) {
   constexpr StringRef StringRefs[] = {"Foo", "Bar"};
   EXPECT_EQ(StringRef("Foo"), StringRefs[0]);
+  EXPECT_EQ(3u, (std::integral_constant<size_t, StringRefs[0].size()>::value));
+  EXPECT_EQ(false, (std::integral_constant<bool, StringRefs[0].empty()>::value));
   EXPECT_EQ(StringRef("Bar"), StringRefs[1]);
 
   constexpr StringLiteral Strings[] = {"Foo", "Bar"};
   EXPECT_EQ(StringRef("Foo"), Strings[0]);
+  EXPECT_EQ(3u, (std::integral_constant<size_t, Strings[0].size()>::value));
+  EXPECT_EQ(false, (std::integral_constant<bool, Strings[0].empty()>::value));
   EXPECT_EQ(StringRef("Bar"), Strings[1]);
 }
 
 // Check gtest prints StringRef as a string instead of a container of chars.
 // The code is in utils/unittest/googletest/internal/custom/gtest-printers.h
 TEST(StringRefTest, GTestPrinter) {
   EXPECT_EQ(R"("foo")", ::testing::PrintToString(StringRef("foo")));
 }
 
 static_assert(std::is_trivially_copyable<StringRef>::value,
               "trivially copyable");
 
 } // end anonymous namespace