[llvm] 3eed57e - [ADT] Rename StringRef case insensitive methods for clarity
Martin Storsjö via llvm-commits
llvm-commits at lists.llvm.org
Thu Jun 24 14:23:25 PDT 2021
Author: Martin Storsjö
Date: 2021-06-25T00:22:00+03:00
New Revision: 3eed57e7ef7da5eda765ccc19fd26fb8dfcd8d41
URL: https://github.com/llvm/llvm-project/commit/3eed57e7ef7da5eda765ccc19fd26fb8dfcd8d41
DIFF: https://github.com/llvm/llvm-project/commit/3eed57e7ef7da5eda765ccc19fd26fb8dfcd8d41.diff
LOG: [ADT] Rename StringRef case insensitive methods for clarity
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.) Also remove
duplicate doxygen comments from the implementation file.
Differential Revision: https://reviews.llvm.org/D104819
Added:
Modified:
llvm/include/llvm/ADT/StringRef.h
llvm/lib/Support/StringRef.cpp
llvm/unittests/ADT/StringRefTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ADT/StringRef.h b/llvm/include/llvm/ADT/StringRef.h
index bb1ab530f66ab..493f26adbb5d0 100644
--- a/llvm/include/llvm/ADT/StringRef.h
+++ b/llvm/include/llvm/ADT/StringRef.h
@@ -189,12 +189,15 @@ namespace llvm {
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
@@ -209,9 +212,12 @@ namespace llvm {
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.
@@ -290,7 +296,12 @@ namespace llvm {
/// 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
@@ -301,7 +312,12 @@ namespace llvm {
/// 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
@@ -327,7 +343,12 @@ namespace llvm {
/// \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
///
@@ -365,7 +386,12 @@ namespace llvm {
/// \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.
///
@@ -388,7 +414,12 @@ namespace llvm {
/// \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.
///
@@ -402,7 +433,10 @@ namespace llvm {
/// \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.
@@ -468,15 +502,25 @@ namespace llvm {
/// 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
@@ -687,14 +731,18 @@ namespace llvm {
/// 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) {
@@ -707,14 +755,18 @@ namespace llvm {
/// 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
diff --git a/llvm/lib/Support/StringRef.cpp b/llvm/lib/Support/StringRef.cpp
index ab67ef9ce85c1..c532a1abe906f 100644
--- a/llvm/lib/Support/StringRef.cpp
+++ b/llvm/lib/Support/StringRef.cpp
@@ -34,8 +34,7 @@ static int ascii_strncasecmp(const char *LHS, const char *RHS, size_t Length) {
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)
@@ -43,19 +42,17 @@ int StringRef::compare_lower(StringRef RHS) const {
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);
}
@@ -173,10 +170,10 @@ size_t StringRef::find(StringRef Str, size_t From) const {
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;
@@ -184,7 +181,7 @@ size_t StringRef::find_lower(StringRef Str, size_t From) const {
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) {
@@ -211,13 +208,13 @@ size_t StringRef::rfind(StringRef Str) const {
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;
diff --git a/llvm/unittests/ADT/StringRefTest.cpp b/llvm/unittests/ADT/StringRefTest.cpp
index ed11a2aae8a8d..87285e0e61ce5 100644
--- a/llvm/unittests/ADT/StringRefTest.cpp
+++ b/llvm/unittests/ADT/StringRefTest.cpp
@@ -98,15 +98,15 @@ TEST(StringRefTest, StringOps) {
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"));
@@ -366,14 +366,14 @@ TEST(StringRefTest, StartsWith) {
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) {
@@ -392,22 +392,22 @@ TEST(StringRefTest, ConsumeFront) {
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) {
@@ -419,14 +419,14 @@ TEST(StringRefTest, EndsWith) {
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) {
@@ -445,22 +445,22 @@ TEST(StringRefTest, ConsumeBack) {
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) {
@@ -472,7 +472,7 @@ TEST(StringRefTest, Find) {
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},
@@ -488,7 +488,7 @@ TEST(StringRefTest, Find) {
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},
@@ -507,14 +507,14 @@ TEST(StringRefTest, Find) {
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'));
@@ -524,10 +524,10 @@ TEST(StringRefTest, Find) {
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"));
More information about the llvm-commits
mailing list