[ADT] Introduce StringRef::{starts,ends}_width{,_insensitive}

[kazu]

Summary

This patch introduces:

StringRef::starts_with
StringRef::starts_with_insensitive
StringRef::ends_with
StringRef::ends_with_insensitive

to be more compatible with std::string and std::string_view.

I'm planning to deprecate the existing functions in favor of the new
ones.

[MaskRay]

LGTM.

[aaron.ballman]

I'm planning to deprecate the existing functions in favor of the new ones.

This landed 7 months ago and no deprecations have materialized. There are 58 uses of endswith_insensitive, there are uses 9 of ends_with_insensitive (all of which were introduced in this patch). 71 and 9 for startswith_insensitive vs starts_with_insensitive. What is the plan for cleaning this up? Alternatively, can we revert this patch as it doesn't seem particularly motivated?

[kazu]

In D136030#4329337, @aaron.ballman wrote:

I'm planning to deprecate the existing functions in favor of the new ones.

This landed 7 months ago and no deprecations have materialized. There are 58 uses of endswith_insensitive, there are uses 9 of ends_with_insensitive (all of which were introduced in this patch). 71 and 9 for startswith_insensitive vs starts_with_insensitive. What is the plan for cleaning this up? Alternatively, can we revert this patch as it doesn't seem particularly motivated?

Oops. Apparently I dropped the ball. Let me migrate startswith_insensitive and endswith_insensitive.

[aaron.ballman]

In D136030#4336939, @kazu wrote:

In D136030#4329337, @aaron.ballman wrote:

I'm planning to deprecate the existing functions in favor of the new ones.

This landed 7 months ago and no deprecations have materialized. There are 58 uses of endswith_insensitive, there are uses 9 of ends_with_insensitive (all of which were introduced in this patch). 71 and 9 for startswith_insensitive vs starts_with_insensitive. What is the plan for cleaning this up? Alternatively, can we revert this patch as it doesn't seem particularly motivated?

Oops. Apparently I dropped the ball. Let me migrate startswith_insensitive and endswith_insensitive.

Thank you!

llvm/include/llvm/ADT/StringRef.h

operator std::string_view() const {
       return std::string_view(data(), size());
     }
 
     /// @}
     /// @name String Predicates
     /// @{
 
     /// Check if this string starts with the given \p Prefix.
-    [[nodiscard]] bool startswith(StringRef Prefix) const {
+    [[nodiscard]] bool starts_with(StringRef Prefix) const {
       return Length >= Prefix.Length &&
              compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
     }
+    [[nodiscard]] bool startswith(StringRef Prefix) const {
+      return starts_with(Prefix);
+    }
 
     /// Check if this string starts with the given \p Prefix, ignoring case.
-    [[nodiscard]] bool startswith_insensitive(StringRef Prefix) const;
+    [[nodiscard]] bool starts_with_insensitive(StringRef Prefix) const;
+    [[nodiscard]] bool startswith_insensitive(StringRef Prefix) const {
+      return starts_with_insensitive(Prefix);
+    }
 
     /// Check if this string ends with the given \p Suffix.
-    [[nodiscard]] bool endswith(StringRef Suffix) const {
+    [[nodiscard]] bool ends_with(StringRef Suffix) const {
       return Length >= Suffix.Length &&
-        compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
+             compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) ==
+                 0;
+    }
+    [[nodiscard]] bool endswith(StringRef Suffix) const {
+      return ends_with(Suffix);
     }
 
     /// Check if this string ends with the given \p Suffix, ignoring case.
-    [[nodiscard]] bool endswith_insensitive(StringRef Suffix) const;
+    [[nodiscard]] bool ends_with_insensitive(StringRef Suffix) const;
+    [[nodiscard]] bool endswith_insensitive(StringRef Suffix) const {
+      return ends_with_insensitive(Suffix);
+    }
 
     /// @}
     /// @name String Searching
     /// @{
 
     /// Search for the first character \p C in the string.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
#endif
     /// satisfying the given predicate dropped from the beginning of the string.
     [[nodiscard]] StringRef drop_until(function_ref<bool(char)> F) const {
       return substr(find_if(F));
     }
 
     /// Returns true if this StringRef has the given prefix and removes that
     /// prefix.
     bool consume_front(StringRef Prefix) {
-      if (!startswith(Prefix))
+      if (!starts_with(Prefix))
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given prefix, ignoring case,
     /// and removes that prefix.
     bool consume_front_insensitive(StringRef Prefix) {
       if (!startswith_insensitive(Prefix))
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
     bool consume_back(StringRef Suffix) {
-      if (!endswith(Suffix))
+      if (!ends_with(Suffix))
         return false;
 
       *this = drop_back(Suffix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix, ignoring case,
     /// and removes that suffix.

llvm/lib/Support/StringRef.cpp

 int StringRef::compare_insensitive(StringRef RHS) const {
   if (int Res = ascii_strncasecmp(Data, RHS.Data, std::min(Length, RHS.Length)))
     return Res;
   if (Length == RHS.Length)
     return 0;
   return Length < RHS.Length ? -1 : 1;
 }
 
-bool StringRef::startswith_insensitive(StringRef Prefix) const {
+bool StringRef::starts_with_insensitive(StringRef Prefix) const {
   return Length >= Prefix.Length &&
       ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
 }
 
-bool StringRef::endswith_insensitive(StringRef Suffix) const {
+bool StringRef::ends_with_insensitive(StringRef Suffix) const {
   return Length >= Suffix.Length &&
       ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
 }
 
 size_t StringRef::find_insensitive(char C, size_t From) const {
   char L = toLower(C);
   return find_if([L](char D) { return toLower(D) == L; }, From);
 }

llvm/unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, Trim) {
   EXPECT_EQ(StringRef(""), StringRef(" ").trim());
   EXPECT_EQ(StringRef("\0", 1), StringRef(" \0 ", 3).trim());
   EXPECT_EQ(StringRef("\0\0", 2), StringRef("\0\0", 2).trim());
   EXPECT_EQ(StringRef("x"), StringRef("\0\0x\0\0", 5).trim('\0'));
 }
 
 TEST(StringRefTest, StartsWith) {
   StringRef Str("hello");
-  EXPECT_TRUE(Str.startswith(""));
-  EXPECT_TRUE(Str.startswith("he"));
-  EXPECT_FALSE(Str.startswith("helloworld"));
-  EXPECT_FALSE(Str.startswith("hi"));
+  EXPECT_TRUE(Str.starts_with(""));
+  EXPECT_TRUE(Str.starts_with("he"));
+  EXPECT_FALSE(Str.starts_with("helloworld"));
+  EXPECT_FALSE(Str.starts_with("hi"));
 }
 
 TEST(StringRefTest, StartsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.startswith_insensitive(""));
-  EXPECT_TRUE(Str.startswith_insensitive("he"));
-  EXPECT_TRUE(Str.startswith_insensitive("hell"));
-  EXPECT_TRUE(Str.startswith_insensitive("HELlo"));
-  EXPECT_FALSE(Str.startswith_insensitive("helloworld"));
-  EXPECT_FALSE(Str.startswith_insensitive("hi"));
+  EXPECT_TRUE(Str.starts_with_insensitive(""));
+  EXPECT_TRUE(Str.starts_with_insensitive("he"));
+  EXPECT_TRUE(Str.starts_with_insensitive("hell"));
+  EXPECT_TRUE(Str.starts_with_insensitive("HELlo"));
+  EXPECT_FALSE(Str.starts_with_insensitive("helloworld"));
+  EXPECT_FALSE(Str.starts_with_insensitive("hi"));
 }
 
 TEST(StringRefTest, ConsumeFront) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.consume_front(""));
   EXPECT_EQ("hello", Str);
   EXPECT_TRUE(Str.consume_front("he"));
   EXPECT_EQ("llo", Str);
TEST(StringRefTest, ConsumeFrontInsensitive) {
   EXPECT_TRUE(Str.consume_front_insensitive("lo"));
   EXPECT_EQ("", Str);
   EXPECT_FALSE(Str.consume_front_insensitive("o"));
   EXPECT_TRUE(Str.consume_front_insensitive(""));
 }
 
 TEST(StringRefTest, EndsWith) {
   StringRef Str("hello");
-  EXPECT_TRUE(Str.endswith(""));
-  EXPECT_TRUE(Str.endswith("lo"));
-  EXPECT_FALSE(Str.endswith("helloworld"));
-  EXPECT_FALSE(Str.endswith("worldhello"));
-  EXPECT_FALSE(Str.endswith("so"));
+  EXPECT_TRUE(Str.ends_with(""));
+  EXPECT_TRUE(Str.ends_with("lo"));
+  EXPECT_FALSE(Str.ends_with("helloworld"));
+  EXPECT_FALSE(Str.ends_with("worldhello"));
+  EXPECT_FALSE(Str.ends_with("so"));
 }
 
 TEST(StringRefTest, EndsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.endswith_insensitive(""));
-  EXPECT_TRUE(Str.endswith_insensitive("lo"));
-  EXPECT_TRUE(Str.endswith_insensitive("LO"));
-  EXPECT_TRUE(Str.endswith_insensitive("ELlo"));
-  EXPECT_FALSE(Str.endswith_insensitive("helloworld"));
-  EXPECT_FALSE(Str.endswith_insensitive("hi"));
+  EXPECT_TRUE(Str.ends_with_insensitive(""));
+  EXPECT_TRUE(Str.ends_with_insensitive("lo"));
+  EXPECT_TRUE(Str.ends_with_insensitive("LO"));
+  EXPECT_TRUE(Str.ends_with_insensitive("ELlo"));
+  EXPECT_FALSE(Str.ends_with_insensitive("helloworld"));
+  EXPECT_FALSE(Str.ends_with_insensitive("hi"));
 }
 
 TEST(StringRefTest, ConsumeBack) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.consume_back(""));
   EXPECT_EQ("hello", Str);
   EXPECT_TRUE(Str.consume_back("lo"));
   EXPECT_EQ("hel", Str);