[ADT] Complete the StringRef case insensitive method renaming

[mstorsjo]

Summary

Remove the old name for the methods. These were only left behind to
ease the transition for downstreams.

This goes on top of D104819.

[dexonsmith]

LGTM, once all the code is migrated.

llvm/include/llvm/ADT/StringRef.h

#endif
     }
 
     /// Check for string equality, ignoring case.
     LLVM_NODISCARD
     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 two strings, ignoring case.
     LLVM_NODISCARD
     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.
     ///
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_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_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
     /// found.
#endif
 
     /// 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_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);
       while (!S.empty()) {
#endif
 
     /// 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_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_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_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);
     }
 
     /// Find the first character in the string that is in \p Chars, or npos if
#endif
 
     /// 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 contains_insensitive(Other);
-    }
-
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
     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 {
       size_t Count = 0;
#endif
     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_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