[ADT] Rename StringRef case insensitive methods for clarity

[mstorsjo]

Summary

Rename functions with the xx_lower() names to xx_insensitive().
This was requested during the review of D104218.

Test names and variables in llvm/unittests/ADT/StringRefTest.cpp
that refer to "lower" are renamed to "insensitive" correspondingly.

Unused function aliases with the former method names are left
in place (without any deprecation attributes) for transition purposes.

All references within the monorepo will be changed (with essentially
mechanical changes), and then the old names will be removed in a
later commit.

Also remove the superfluous method names at the start of doxygen
comments, for the methods that are touched here. (There are more
occurrances of this left in other methods though.)

[dexonsmith]

Given how large this is, would it be reasonable to split this up a bit more?

What I might do if this were my patch: get a review of the API change + the manual changes in one patch (assuming there aren't many manual changes), then land the remaining mechanical changes in chunks, perhaps vaguely by component, likely using post-commit review. The benefit of committing by chunks is that if there is some problem that comes up (even mechanical changes fail) there's more granularity for bisection (and less churn on revert). WDYT?

Also: is there a reference to this API in the ProgrammersManual? (I honestly don't know, but if there is, please be sure to update it as well.)

[MaskRay]

llvm/include/llvm/ADT/StringRef.h

192

https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

"Don’t duplicate function or class name at the beginning of the comment."

[mstorsjo]

In D104819#2837421, @dexonsmith wrote:

Given how large this is, would it be reasonable to split this up a bit more?

What I might do if this were my patch: get a review of the API change + the manual changes in one patch (assuming there aren't many manual changes), then land the remaining mechanical changes in chunks, perhaps vaguely by component, likely using post-commit review. The benefit of committing by chunks is that if there is some problem that comes up (even mechanical changes fail) there's more granularity for bisection (and less churn on revert). WDYT?

That sounds like a good plan to me, thanks for the suggestion!

Also: is there a reference to this API in the ProgrammersManual? (I honestly don't know, but if there is, please be sure to update it as well.)

I don't think so, at least grepping for _lower didn't hit anything in llvm/docs (and manually browsing it now, the section on StringRef doesn't mention those methods).

llvm/include/llvm/ADT/StringRef.h

192

Thanks, I'll fix those for the methods I'm renaming here, but I'll refrain from touching the other methods in this patch.

[mstorsjo]

Reduced this patch only to updating of the StringRef class itself and its unit test, removing the mechanical changes. Removed superfluous method name duplication in doxygen comments.

[dexonsmith]

LGTM, once @MaskRay is happy. I have a couple of minor comments inline too.

(I also see that there are some clang-format suggestions in the unit tests; not sure any of them are actually improvements so maybe you left those out intentionally? Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

llvm/include/llvm/ADT/StringRef.h

198

You could probably drop the LLVM_NODISCARD from the soon-to-be-deleted _lower variants, but maybe it's not worth fussing with (up to you).

llvm/lib/Support/StringRef.cpp

37

You can drop these duplicate doxygen comments entirely from the .cpp file.

[lattner]

Thank you!

[mstorsjo]

In D104819#2839263, @dexonsmith wrote:

LGTM, once @MaskRay is happy. I have a couple of minor comments inline too.

(I also see that there are some clang-format suggestions in the unit tests; not sure any of them are actually improvements so maybe you left those out intentionally?

Yeah those seem to be intentionally vertically aligned that way, no big opinion either way

Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

Hmm, those would have to be manually reviewed, but I guess I can try to do that (discarding changes where the surrounding code isn't too well formatted now already so it does more extensive reformattings other than for the renaming).

llvm/lib/Support/StringRef.cpp

37

Sure, yeah doxygen in implementation files make little sense anyway.

[dexonsmith]

In D104819#2839315, @mstorsjo wrote:

In D104819#2839263, @dexonsmith wrote:

Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

Hmm, those would have to be manually reviewed, but I guess I can try to do that (discarding changes where the surrounding code isn't too well formatted now already so it does more extensive reformattings other than for the renaming).

Sounds good. (I'm generally in favour of erring on the side of trusting clang-format, especially for large refactorings like this; I wouldn't spend too much time analyzing whether it's an improvement...)

llvm/include/llvm/ADT/StringRef.h

#endif
     /// equals - Check for string equality, this is more efficient than
     /// compare() when the relative ordering of inequal strings isn't needed.
     LLVM_NODISCARD
     bool equals(StringRef RHS) const {
       return (Length == RHS.Length &&
               compareMemory(Data, RHS.Data, RHS.Length) == 0);
     }
 
-    /// equals_lower - Check for string equality, ignoring case.
+    /// Check for string equality, ignoring case.
     LLVM_NODISCARD
-    bool equals_lower(StringRef RHS) const {
-      return Length == RHS.Length && compare_lower(RHS) == 0;
+    bool equals_insensitive(StringRef RHS) const {
+      return Length == RHS.Length && compare_insensitive(RHS) == 0;
     }
 
+    LLVM_NODISCARD
+    bool equals_lower(StringRef RHS) const { return equals_insensitive(RHS); }
+
     /// compare - Compare two strings; the result is -1, 0, or 1 if this string
     /// is lexicographically less than, equal to, or greater than the \p RHS.
     LLVM_NODISCARD
     int compare(StringRef RHS) const {
       // Check the prefix for a mismatch.
       if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length)))
         return Res < 0 ? -1 : 1;
 
       // Otherwise the prefixes match, so we only need to check the lengths.
       if (Length == RHS.Length)
         return 0;
       return Length < RHS.Length ? -1 : 1;
     }
 
-    /// compare_lower - Compare two strings, ignoring case.
+    /// Compare two strings, ignoring case.
     LLVM_NODISCARD
-    int compare_lower(StringRef RHS) const;
+    int compare_insensitive(StringRef RHS) const;
+
+    LLVM_NODISCARD
+    int compare_lower(StringRef RHS) const { return compare_insensitive(RHS); }
 
     /// compare_numeric - Compare two strings, treating sequences of digits as
     /// numbers.
     LLVM_NODISCARD
     int compare_numeric(StringRef RHS) const;
 
     /// Determine the edit distance between this string and another
     /// string.
#endif
     LLVM_NODISCARD
     bool startswith(StringRef Prefix) const {
       return Length >= Prefix.Length &&
              compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
     }
 
     /// Check if this string starts with the given \p Prefix, ignoring case.
     LLVM_NODISCARD
-    bool startswith_lower(StringRef Prefix) const;
+    bool startswith_insensitive(StringRef Prefix) const;
+
+    LLVM_NODISCARD
+    bool startswith_lower(StringRef Prefix) const {
+      return startswith_insensitive(Prefix);
+    }
 
     /// Check if this string ends with the given \p Suffix.
     LLVM_NODISCARD
     bool endswith(StringRef Suffix) const {
       return Length >= Suffix.Length &&
         compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
     }
 
     /// Check if this string ends with the given \p Suffix, ignoring case.
     LLVM_NODISCARD
-    bool endswith_lower(StringRef Suffix) const;
+    bool endswith_insensitive(StringRef Suffix) const;
+
+    LLVM_NODISCARD
+    bool endswith_lower(StringRef Prefix) const {
+      return endswith_insensitive(Prefix);
+    }
 
     /// @}
     /// @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
size_t find(char C, size_t From = 0) const {
       return npos;
     }
 
     /// Search for the first character \p C in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t find_lower(char C, size_t From = 0) const;
+    size_t find_insensitive(char C, size_t From = 0) const;
+
+    LLVM_NODISCARD
+    size_t find_lower(char C, size_t From = 0) const {
+      return find_insensitive(C, From);
+    }
 
     /// Search for the first character satisfying the predicate \p F
     ///
     /// \returns The index of the first character satisfying \p F starting from
     /// \p From, or npos if not found.
     LLVM_NODISCARD
     size_t find_if(function_ref<bool(char)> F, size_t From = 0) const {
       StringRef S = drop_front(From);
#endif
     LLVM_NODISCARD
     size_t find(StringRef Str, size_t From = 0) const;
 
     /// Search for the first string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t find_lower(StringRef Str, size_t From = 0) const;
+    size_t find_insensitive(StringRef Str, size_t From = 0) const;
+
+    LLVM_NODISCARD
+    size_t find_lower(StringRef Str, size_t From = 0) const {
+      return find_insensitive(Str, From);
+    }
 
     /// Search for the last character \p C in the string.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
     size_t rfind(char C, size_t From = npos) const {
       From = std::min(From, Length);
       size_t i = From;
       while (i != 0) {
         --i;
         if (Data[i] == C)
           return i;
       }
       return npos;
     }
 
     /// Search for the last character \p C in the string, ignoring case.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t rfind_lower(char C, size_t From = npos) const;
+    size_t rfind_insensitive(char C, size_t From = npos) const;
+
+    LLVM_NODISCARD
+    size_t rfind_lower(char C, size_t From = npos) const {
+      return rfind_insensitive(C, From);
+    }
 
     /// Search for the last string \p Str in the string.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
     size_t rfind(StringRef Str) const;
 
     /// Search for the last string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t rfind_lower(StringRef Str) const;
+    size_t rfind_insensitive(StringRef Str) const;
+
+    LLVM_NODISCARD
+    size_t rfind_lower(StringRef Str) const { return rfind_insensitive(Str); }
 
     /// Find the first character in the string that is \p C, or npos if not
     /// found. Same as find.
     LLVM_NODISCARD
     size_t find_first_of(char C, size_t From = 0) const {
       return find(C, From);
     }
 
#endif
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
     bool contains(char C) const { return find_first_of(C) != npos; }
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
     LLVM_NODISCARD
+    bool contains_insensitive(StringRef Other) const {
+      return find_insensitive(Other) != npos;
+    }
+
+    LLVM_NODISCARD
     bool contains_lower(StringRef Other) const {
-      return find_lower(Other) != npos;
+      return contains_insensitive(Other);
     }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    bool contains_lower(char C) const { return find_lower(C) != npos; }
+    bool contains_insensitive(char C) const {
+      return find_insensitive(C) != npos;
+    }
+
+    LLVM_NODISCARD
+    bool contains_lower(char C) const { return contains_insensitive(C); }
 
     /// @}
     /// @name Helpful Algorithms
     /// @{
 
     /// Return the number of occurrences of \p C in the string.
     LLVM_NODISCARD
     size_t count(char C) const {
bool consume_front(StringRef 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_lower(StringRef Prefix) {
-      if (!startswith_lower(Prefix))
+    bool consume_front_insensitive(StringRef Prefix) {
+      if (!startswith_insensitive(Prefix))
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
+    bool consume_front_lower(StringRef Prefix) {
+      return consume_front_insensitive(Prefix);
+    }
+
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
     bool consume_back(StringRef Suffix) {
       if (!endswith(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.
-    bool consume_back_lower(StringRef Suffix) {
-      if (!endswith_lower(Suffix))
+    bool consume_back_insensitive(StringRef Suffix) {
+      if (!endswith_insensitive(Suffix))
         return false;
 
       *this = drop_back(Suffix.size());
       return true;
     }
 
+    bool consume_back_lower(StringRef Suffix) {
+      return consume_back_insensitive(Suffix);
+    }
+
     /// Return a reference to the substring from [Start, End).
     ///
     /// \param Start The index of the starting character in the substring; if
     /// the index is npos or greater than the length of the string then the
     /// empty substring will be returned.
     ///
     /// \param End The index following the last character to include in the
     /// substring. If this is npos or exceeds the number of characters

llvm/lib/Support/StringRef.cpp

for (size_t I = 0; I < Length; ++I) {
     unsigned char LHC = toLower(LHS[I]);
     unsigned char RHC = toLower(RHS[I]);
     if (LHC != RHC)
       return LHC < RHC ? -1 : 1;
   }
   return 0;
 }
 
-/// compare_lower - Compare strings, ignoring case.
-int StringRef::compare_lower(StringRef RHS) const {
+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;
 }
 
-/// Check if this string starts with the given \p Prefix, ignoring case.
-bool StringRef::startswith_lower(StringRef Prefix) const {
+bool StringRef::startswith_insensitive(StringRef Prefix) const {
   return Length >= Prefix.Length &&
       ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
 }
 
-/// Check if this string ends with the given \p Suffix, ignoring case.
-bool StringRef::endswith_lower(StringRef Suffix) const {
+bool StringRef::endswith_insensitive(StringRef Suffix) const {
   return Length >= Suffix.Length &&
       ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
 }
 
-size_t StringRef::find_lower(char C, size_t From) const {
+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);
 }
 
 /// compare_numeric - Compare strings, handle embedded numbers.
 int StringRef::compare_numeric(StringRef RHS) const {
   for (size_t I = 0, E = std::min(Length, RHS.Length); I != E; ++I) {
     // Check for sequences of digits.
do {
 
     // Otherwise skip the appropriate number of bytes.
     Start += BadCharSkip[Last];
   } while (Start < Stop);
 
   return npos;
 }
 
-size_t StringRef::find_lower(StringRef Str, size_t From) const {
+size_t StringRef::find_insensitive(StringRef Str, size_t From) const {
   StringRef This = substr(From);
   while (This.size() >= Str.size()) {
-    if (This.startswith_lower(Str))
+    if (This.startswith_insensitive(Str))
       return From;
     This = This.drop_front();
     ++From;
   }
   return npos;
 }
 
-size_t StringRef::rfind_lower(char C, size_t From) const {
+size_t StringRef::rfind_insensitive(char C, size_t From) const {
   From = std::min(From, Length);
   size_t i = From;
   while (i != 0) {
     --i;
     if (toLower(Data[i]) == toLower(C))
       return i;
   }
   return npos;
size_t StringRef::rfind(StringRef Str) const {
   for (size_t i = Length - N + 1, e = 0; i != e;) {
     --i;
     if (substr(i, N).equals(Str))
       return i;
   }
   return npos;
 }
 
-size_t StringRef::rfind_lower(StringRef Str) const {
+size_t StringRef::rfind_insensitive(StringRef Str) const {
   size_t N = Str.size();
   if (N > Length)
     return npos;
   for (size_t i = Length - N + 1, e = 0; i != e;) {
     --i;
-    if (substr(i, N).equals_lower(Str))
+    if (substr(i, N).equals_insensitive(Str))
       return i;
   }
   return npos;
 }
 
 /// find_first_of - Find the first character in the string that is in \arg
 /// Chars, or npos if not found.
 ///

llvm/unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, StringOps) {
   EXPECT_EQ((size_t) 5, StringRef("hello").size());
   EXPECT_EQ(-1, StringRef("aab").compare("aad"));
   EXPECT_EQ( 0, StringRef("aab").compare("aab"));
   EXPECT_EQ( 1, StringRef("aab").compare("aaa"));
   EXPECT_EQ(-1, StringRef("aab").compare("aabb"));
   EXPECT_EQ( 1, StringRef("aab").compare("aa"));
   EXPECT_EQ( 1, StringRef("\xFF").compare("\1"));
 
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("aAd"));
-  EXPECT_EQ( 0, StringRef("AaB").compare_lower("aab"));
-  EXPECT_EQ( 1, StringRef("AaB").compare_lower("AAA"));
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("aaBb"));
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("bb"));
-  EXPECT_EQ( 1, StringRef("aaBb").compare_lower("AaB"));
-  EXPECT_EQ( 1, StringRef("bb").compare_lower("AaB"));
-  EXPECT_EQ( 1, StringRef("AaB").compare_lower("aA"));
-  EXPECT_EQ( 1, StringRef("\xFF").compare_lower("\1"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("aAd"));
+  EXPECT_EQ( 0, StringRef("AaB").compare_insensitive("aab"));
+  EXPECT_EQ( 1, StringRef("AaB").compare_insensitive("AAA"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("aaBb"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("bb"));
+  EXPECT_EQ( 1, StringRef("aaBb").compare_insensitive("AaB"));
+  EXPECT_EQ( 1, StringRef("bb").compare_insensitive("AaB"));
+  EXPECT_EQ( 1, StringRef("AaB").compare_insensitive("aA"));
+  EXPECT_EQ( 1, StringRef("\xFF").compare_insensitive("\1"));
 
   EXPECT_EQ(-1, StringRef("aab").compare_numeric("aad"));
   EXPECT_EQ( 0, StringRef("aab").compare_numeric("aab"));
   EXPECT_EQ( 1, StringRef("aab").compare_numeric("aaa"));
   EXPECT_EQ(-1, StringRef("aab").compare_numeric("aabb"));
   EXPECT_EQ( 1, StringRef("aab").compare_numeric("aa"));
   EXPECT_EQ(-1, StringRef("1").compare_numeric("10"));
   EXPECT_EQ( 0, StringRef("10").compare_numeric("10"));

 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"));
 }
 
-TEST(StringRefTest, StartsWithLower) {
+TEST(StringRefTest, StartsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.startswith_lower(""));
-  EXPECT_TRUE(Str.startswith_lower("he"));
-  EXPECT_TRUE(Str.startswith_lower("hell"));
-  EXPECT_TRUE(Str.startswith_lower("HELlo"));
-  EXPECT_FALSE(Str.startswith_lower("helloworld"));
-  EXPECT_FALSE(Str.startswith_lower("hi"));
+  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"));
 }
 
 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);
   EXPECT_FALSE(Str.consume_front("lloworld"));
   EXPECT_EQ("llo", Str);
   EXPECT_FALSE(Str.consume_front("lol"));
   EXPECT_EQ("llo", Str);
   EXPECT_TRUE(Str.consume_front("llo"));
   EXPECT_EQ("", Str);
   EXPECT_FALSE(Str.consume_front("o"));
   EXPECT_TRUE(Str.consume_front(""));
 }
 
-TEST(StringRefTest, ConsumeFrontLower) {
+TEST(StringRefTest, ConsumeFrontInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.consume_front_lower(""));
+  EXPECT_TRUE(Str.consume_front_insensitive(""));
   EXPECT_EQ("heLLo", Str);
   EXPECT_FALSE(Str.consume_front("HEl"));
   EXPECT_EQ("heLLo", Str);
-  EXPECT_TRUE(Str.consume_front_lower("HEl"));
+  EXPECT_TRUE(Str.consume_front_insensitive("HEl"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_FALSE(Str.consume_front_lower("loworld"));
+  EXPECT_FALSE(Str.consume_front_insensitive("loworld"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_FALSE(Str.consume_front_lower("ol"));
+  EXPECT_FALSE(Str.consume_front_insensitive("ol"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_TRUE(Str.consume_front_lower("lo"));
+  EXPECT_TRUE(Str.consume_front_insensitive("lo"));
   EXPECT_EQ("", Str);
-  EXPECT_FALSE(Str.consume_front_lower("o"));
-  EXPECT_TRUE(Str.consume_front_lower(""));
+  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"));
 }
 
-TEST(StringRefTest, EndsWithLower) {
+TEST(StringRefTest, EndsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.endswith_lower(""));
-  EXPECT_TRUE(Str.endswith_lower("lo"));
-  EXPECT_TRUE(Str.endswith_lower("LO"));
-  EXPECT_TRUE(Str.endswith_lower("ELlo"));
-  EXPECT_FALSE(Str.endswith_lower("helloworld"));
-  EXPECT_FALSE(Str.endswith_lower("hi"));
+  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"));
 }
 
 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);
   EXPECT_FALSE(Str.consume_back("helhel"));
   EXPECT_EQ("hel", Str);
   EXPECT_FALSE(Str.consume_back("hle"));
   EXPECT_EQ("hel", Str);
   EXPECT_TRUE(Str.consume_back("hel"));
   EXPECT_EQ("", Str);
   EXPECT_FALSE(Str.consume_back("h"));
   EXPECT_TRUE(Str.consume_back(""));
 }
 
-TEST(StringRefTest, ConsumeBackLower) {
+TEST(StringRefTest, ConsumeBackInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.consume_back_lower(""));
+  EXPECT_TRUE(Str.consume_back_insensitive(""));
   EXPECT_EQ("heLLo", Str);
   EXPECT_FALSE(Str.consume_back("lO"));
   EXPECT_EQ("heLLo", Str);
-  EXPECT_TRUE(Str.consume_back_lower("lO"));
+  EXPECT_TRUE(Str.consume_back_insensitive("lO"));
   EXPECT_EQ("heL", Str);
-  EXPECT_FALSE(Str.consume_back_lower("helhel"));
+  EXPECT_FALSE(Str.consume_back_insensitive("helhel"));
   EXPECT_EQ("heL", Str);
-  EXPECT_FALSE(Str.consume_back_lower("hle"));
+  EXPECT_FALSE(Str.consume_back_insensitive("hle"));
   EXPECT_EQ("heL", Str);
-  EXPECT_TRUE(Str.consume_back_lower("hEl"));
+  EXPECT_TRUE(Str.consume_back_insensitive("hEl"));
   EXPECT_EQ("", Str);
-  EXPECT_FALSE(Str.consume_back_lower("h"));
-  EXPECT_TRUE(Str.consume_back_lower(""));
+  EXPECT_FALSE(Str.consume_back_insensitive("h"));
+  EXPECT_TRUE(Str.consume_back_insensitive(""));
 }
 
 TEST(StringRefTest, Find) {
   StringRef Str("helloHELLO");
   StringRef LongStr("hellx xello hell ello world foo bar hello HELLO");
 
   struct {
     StringRef Str;
     char C;
     std::size_t From;
     std::size_t Pos;
-    std::size_t LowerPos;
+    std::size_t InsensitivePos;
   } CharExpectations[] = {
       {Str, 'h', 0U, 0U, 0U},
       {Str, 'e', 0U, 1U, 1U},
       {Str, 'l', 0U, 2U, 2U},
       {Str, 'l', 3U, 3U, 3U},
       {Str, 'o', 0U, 4U, 4U},
       {Str, 'L', 0U, 7U, 2U},
       {Str, 'z', 0U, StringRef::npos, StringRef::npos},
   };
 
   struct {
     StringRef Str;
     llvm::StringRef S;
     std::size_t From;
     std::size_t Pos;
-    std::size_t LowerPos;
+    std::size_t InsensitivePos;
   } StrExpectations[] = {
       {Str, "helloword", 0, StringRef::npos, StringRef::npos},
       {Str, "hello", 0, 0U, 0U},
       {Str, "ello", 0, 1U, 1U},
       {Str, "zz", 0, StringRef::npos, StringRef::npos},
       {Str, "ll", 2U, 2U, 2U},
       {Str, "ll", 3U, StringRef::npos, 7U},
       {Str, "LL", 2U, 7U, 2U},
       {Str, "LL", 3U, 7U, 7U},
       {Str, "", 0U, 0U, 0U},
       {LongStr, "hello", 0U, 36U, 36U},
       {LongStr, "foo", 0U, 28U, 28U},
       {LongStr, "hell", 2U, 12U, 12U},
       {LongStr, "HELL", 2U, 42U, 12U},
       {LongStr, "", 0U, 0U, 0U}};
 
   for (auto &E : CharExpectations) {
     EXPECT_EQ(E.Pos, E.Str.find(E.C, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.C, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(toupper(E.C), E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.C, E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(toupper(E.C), E.From));
   }
 
   for (auto &E : StrExpectations) {
     EXPECT_EQ(E.Pos, E.Str.find(E.S, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S.upper(), E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.S, E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.S.upper(), E.From));
   }
 
   EXPECT_EQ(3U, Str.rfind('l'));
   EXPECT_EQ(StringRef::npos, Str.rfind('z'));
   EXPECT_EQ(StringRef::npos, Str.rfind("helloworld"));
   EXPECT_EQ(0U, Str.rfind("hello"));
   EXPECT_EQ(1U, Str.rfind("ello"));
   EXPECT_EQ(StringRef::npos, Str.rfind("zz"));
 
-  EXPECT_EQ(8U, Str.rfind_lower('l'));
-  EXPECT_EQ(8U, Str.rfind_lower('L'));
-  EXPECT_EQ(StringRef::npos, Str.rfind_lower('z'));
-  EXPECT_EQ(StringRef::npos, Str.rfind_lower("HELLOWORLD"));
+  EXPECT_EQ(8U, Str.rfind_insensitive('l'));
+  EXPECT_EQ(8U, Str.rfind_insensitive('L'));
+  EXPECT_EQ(StringRef::npos, Str.rfind_insensitive('z'));
+  EXPECT_EQ(StringRef::npos, Str.rfind_insensitive("HELLOWORLD"));
   EXPECT_EQ(5U, Str.rfind("HELLO"));
   EXPECT_EQ(6U, Str.rfind("ELLO"));
   EXPECT_EQ(StringRef::npos, Str.rfind("ZZ"));
 
   EXPECT_EQ(2U, Str.find_first_of('l'));
   EXPECT_EQ(1U, Str.find_first_of("el"));
   EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz"));