[clang-tidy][NFC] Replace many instances of std::string where a StringRef would suffice.

There's many instances in clang tidy checks where owning strings are used when we already have a stable string from the options, so using a StringRef makes much more sense.

Reviewed By: aaron.ballman

Differential Revision: https://reviews.llvm.org/D124341

Author: njames93

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

@@ -48,22 +48,22 @@ void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
 ClangTidyCheck::OptionsView::OptionsView(
     StringRef CheckName, const ClangTidyOptions::OptionMap &CheckOptions,
     ClangTidyContext *Context)
-    : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions),
+    : NamePrefix((CheckName + ".").str()), CheckOptions(CheckOptions),
       Context(Context) {}
 
-llvm::Optional<std::string>
+llvm::Optional<StringRef>
 ClangTidyCheck::OptionsView::get(StringRef LocalName) const {
-  const auto &Iter = CheckOptions.find(NamePrefix + LocalName.str());
+  const auto &Iter = CheckOptions.find((NamePrefix + LocalName).str());
   if (Iter != CheckOptions.end())
-    return Iter->getValue().Value;
+    return StringRef(Iter->getValue().Value);
   return None;
 }
 
 static ClangTidyOptions::OptionMap::const_iterator
 findPriorityOption(const ClangTidyOptions::OptionMap &Options, StringRef NamePrefix,
           StringRef LocalName) {
   auto IterLocal = Options.find((NamePrefix + LocalName).str());
-  auto IterGlobal = Options.find(LocalName.str());
+  auto IterGlobal = Options.find(LocalName);
   if (IterLocal == Options.end())
     return IterGlobal;
   if (IterGlobal == Options.end())
@@ -73,11 +73,11 @@ findPriorityOption(const ClangTidyOptions::OptionMap &Options, StringRef NamePre
   return IterGlobal;
 }
 
-llvm::Optional<std::string>
+llvm::Optional<StringRef>
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName) const {
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName);
   if (Iter != CheckOptions.end())
-    return Iter->getValue().Value;
+    return StringRef(Iter->getValue().Value);
   return None;
 }
 
@@ -97,7 +97,7 @@ static Optional<bool> getAsBool(StringRef Value,
 template <>
 llvm::Optional<bool>
 ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName) const {
-  if (llvm::Optional<std::string> ValueOr = get(LocalName)) {
+  if (llvm::Optional<StringRef> ValueOr = get(LocalName)) {
     if (auto Result = getAsBool(*ValueOr, NamePrefix + LocalName))
       return Result;
     diagnoseBadBooleanOption(NamePrefix + LocalName, *ValueOr);
@@ -120,7 +120,7 @@ ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName) const {
 void ClangTidyCheck::OptionsView::store(ClangTidyOptions::OptionMap &Options,
                                         StringRef LocalName,
                                         StringRef Value) const {
-  Options[NamePrefix + LocalName.str()] = Value;
+  Options[(NamePrefix + LocalName).str()] = Value;
 }
 
 void ClangTidyCheck::OptionsView::storeInt(ClangTidyOptions::OptionMap &Options,
@@ -167,10 +167,9 @@ llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
     }
   }
   if (EditDistance < 3)
-    diagnoseBadEnumOption(Iter->getKey().str(), Iter->getValue().Value,
-                          Closest);
+    diagnoseBadEnumOption(Iter->getKey(), Iter->getValue().Value, Closest);
   else
-    diagnoseBadEnumOption(Iter->getKey().str(), Iter->getValue().Value);
+    diagnoseBadEnumOption(Iter->getKey(), Iter->getValue().Value);
   return None;
 }
 
@@ -203,18 +202,15 @@ void ClangTidyCheck::OptionsView::diagnoseBadEnumOption(
     Diag << 3 << Suggestion;
 }
 
-std::string ClangTidyCheck::OptionsView::get(StringRef LocalName,
-                                             StringRef Default) const {
-  if (llvm::Optional<std::string> Val = get(LocalName))
-    return std::move(*Val);
-  return Default.str();
+StringRef ClangTidyCheck::OptionsView::get(StringRef LocalName,
+                                           StringRef Default) const {
+  return get(LocalName).getValueOr(Default);
 }
-std::string
+
+StringRef
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
                                               StringRef Default) const {
-  if (llvm::Optional<std::string> Val = getLocalOrGlobal(LocalName))
-    return std::move(*Val);
-  return Default.str();
+  return getLocalOrGlobal(LocalName).getValueOr(Default);
 }
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/ClangTidyCheck.h

@@ -155,30 +155,30 @@ class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, return
     /// ``None``.
-    llvm::Optional<std::string> get(StringRef LocalName) const;
+    llvm::Optional<StringRef> get(StringRef LocalName) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, returns
     /// \p Default.
-    std::string get(StringRef LocalName, StringRef Default) const;
+    StringRef get(StringRef LocalName, StringRef Default) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
     /// present either, return ``None``.
-    llvm::Optional<std::string> getLocalOrGlobal(StringRef LocalName) const;
+    llvm::Optional<StringRef> getLocalOrGlobal(StringRef LocalName) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
     /// present either, returns \p Default.
-    std::string getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
+    StringRef getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
 
     /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
@@ -192,7 +192,7 @@ class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
     template <typename T>
     std::enable_if_t<std::is_integral<T>::value, llvm::Optional<T>>
     get(StringRef LocalName) const {
-      if (llvm::Optional<std::string> Value = get(LocalName)) {
+      if (llvm::Optional<StringRef> Value = get(LocalName)) {
         T Result{};
         if (!StringRef(*Value).getAsInteger(10, Result))
           return Result;
@@ -229,7 +229,7 @@ class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
     template <typename T>
     std::enable_if_t<std::is_integral<T>::value, llvm::Optional<T>>
     getLocalOrGlobal(StringRef LocalName) const {
-      llvm::Optional<std::string> ValueOr = get(LocalName);
+      llvm::Optional<StringRef> ValueOr = get(LocalName);
       bool IsGlobal = false;
       if (!ValueOr) {
         IsGlobal = true;

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

@@ -34,8 +34,7 @@ StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
 
 void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
   auto ZeroLiteral = integerLiteral(equals(0));
-  auto StringClassMatcher = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
-      StringLikeClasses.begin(), StringLikeClasses.end())));
+  auto StringClassMatcher = cxxRecordDecl(hasAnyName(StringLikeClasses));
   auto StringType = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(StringClassMatcher)));
 

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.h

@@ -35,9 +35,9 @@ class StringFindStartswithCheck : public ClangTidyCheck {
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
-  const std::vector<std::string> StringLikeClasses;
+  const std::vector<StringRef> StringLikeClasses;
   utils::IncludeInserter IncludeInserter;
-  const std::string AbseilStringsMatchHeader;
+  const StringRef AbseilStringsMatchHeader;
 };
 
 } // namespace abseil

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.cpp

@@ -40,10 +40,9 @@ static const char DefaultStringLikeClasses[] = "::std::basic_string;"
 static const char DefaultAbseilStringsMatchHeader[] = "absl/strings/match.h";
 
 static transformer::RewriteRuleWith<std::string>
-makeRewriteRule(const std::vector<std::string> &StringLikeClassNames,
+makeRewriteRule(ArrayRef<StringRef> StringLikeClassNames,
                 StringRef AbseilStringsMatchHeader) {
-  auto StringLikeClass = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
-      StringLikeClassNames.begin(), StringLikeClassNames.end())));
+  auto StringLikeClass = cxxRecordDecl(hasAnyName(StringLikeClassNames));
   auto StringType =
       hasUnqualifiedDesugaredType(recordType(hasDeclaration(StringLikeClass)));
   auto CharStarType =

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.h

@@ -28,8 +28,8 @@ class StringFindStrContainsCheck : public utils::TransformerClangTidyCheck {
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
-  const std::vector<std::string> StringLikeClassesOption;
-  const std::string AbseilStringsMatchHeaderOption;
+  const std::vector<StringRef> StringLikeClassesOption;
+  const StringRef AbseilStringsMatchHeaderOption;
 };
 
 } // namespace abseil

clang-tools-extra/clang-tidy/android/ComparisonInTempFailureRetryCheck.h

@@ -31,7 +31,7 @@ class ComparisonInTempFailureRetryCheck : public ClangTidyCheck {
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawRetryList;
+  const StringRef RawRetryList;
   SmallVector<StringRef, 5> RetryMacros;
 };
 

clang-tools-extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp

@@ -78,8 +78,8 @@ AssertSideEffectCheck::AssertSideEffectCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       CheckFunctionCalls(Options.get("CheckFunctionCalls", false)),
       RawAssertList(Options.get("AssertMacros", "assert,NSAssert,NSCAssert")),
-      IgnoredFunctions(utils::options::parseStringList(
-          "__builtin_expect;" + Options.get("IgnoredFunctions", ""))) {
+      IgnoredFunctions(utils::options::parseListPair(
+          "__builtin_expect;", Options.get("IgnoredFunctions", ""))) {
   StringRef(RawAssertList).split(AssertMacros, ",", -1, false);
 }
 

clang-tools-extra/clang-tidy/bugprone/AssertSideEffectCheck.h

@@ -40,9 +40,9 @@ class AssertSideEffectCheck : public ClangTidyCheck {
 
 private:
   const bool CheckFunctionCalls;
-  const std::string RawAssertList;
+  const StringRef RawAssertList;
   SmallVector<StringRef, 5> AssertMacros;
-  const std::vector<std::string> IgnoredFunctions;
+  const std::vector<StringRef> IgnoredFunctions;
 };
 
 } // namespace bugprone

clang-tools-extra/clang-tidy/bugprone/DanglingHandleCheck.cpp

@@ -94,9 +94,7 @@ DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
       HandleClasses(utils::options::parseStringList(Options.get(
           "HandleClasses",
           "std::basic_string_view;std::experimental::basic_string_view"))),
-      IsAHandle(cxxRecordDecl(hasAnyName(std::vector<StringRef>(
-                                  HandleClasses.begin(), HandleClasses.end())))
-                    .bind("handle")) {}
+      IsAHandle(cxxRecordDecl(hasAnyName(HandleClasses)).bind("handle")) {}
 
 void DanglingHandleCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HandleClasses",

clang-tools-extra/clang-tidy/bugprone/DanglingHandleCheck.h

@@ -31,7 +31,7 @@ class DanglingHandleCheck : public ClangTidyCheck {
   void registerMatchersForVariables(ast_matchers::MatchFinder *Finder);
   void registerMatchersForReturn(ast_matchers::MatchFinder *Finder);
 
-  const std::vector<std::string> HandleClasses;
+  const std::vector<StringRef> HandleClasses;
   const ast_matchers::internal::Matcher<RecordDecl> IsAHandle;
 };
 

clang-tools-extra/clang-tidy/bugprone/DynamicStaticInitializersCheck.h

@@ -36,7 +36,7 @@ class DynamicStaticInitializersCheck : public ClangTidyCheck {
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
   utils::FileExtensionsSet HeaderFileExtensions;
 };
 

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

@@ -1552,7 +1552,7 @@ static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node) {
   LLVM_DEBUG(llvm::dbgs() << "\tType name is '" << NodeTypeName << "'\n");
   if (!NodeTypeName.empty()) {
     if (llvm::any_of(Check.IgnoredParameterTypeSuffixes,
-                     [NodeTypeName](const std::string &E) {
+                     [NodeTypeName](StringRef E) {
                        return !E.empty() && NodeTypeName.endswith(E);
                      })) {
       LLVM_DEBUG(llvm::dbgs() << "\tType suffix ignored.\n");

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

@@ -33,11 +33,11 @@ class EasilySwappableParametersCheck : public ClangTidyCheck {
   const std::size_t MinimumLength;
 
   /// The parameter names (as written in the source text) to be ignored.
-  const std::vector<std::string> IgnoredParameterNames;
+  const std::vector<StringRef> IgnoredParameterNames;
 
   /// The parameter typename suffixes (as written in the source code) to be
   /// ignored.
-  const std::vector<std::string> IgnoredParameterTypeSuffixes;
+  const std::vector<StringRef> IgnoredParameterTypeSuffixes;
 
   /// Whether to consider differently qualified versions of the same type
   /// mixable.

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.cpp

@@ -109,7 +109,7 @@ static std::string getNonReservedFixup(std::string Name) {
 static Optional<RenamerClangTidyCheck::FailureInfo>
 getFailureInfoImpl(StringRef Name, bool IsInGlobalNamespace,
                    const LangOptions &LangOpts, bool Invert,
-                   ArrayRef<std::string> AllowedIdentifiers) {
+                   ArrayRef<StringRef> AllowedIdentifiers) {
   assert(!Name.empty());
   if (llvm::is_contained(AllowedIdentifiers, Name))
     return None;

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.h

@@ -32,7 +32,7 @@ namespace bugprone {
 /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-reserved-identifier.html
 class ReservedIdentifierCheck final : public RenamerClangTidyCheck {
   const bool Invert;
-  const std::vector<std::string> AllowedIdentifiers;
+  const std::vector<StringRef> AllowedIdentifiers;
 
 public:
   ReservedIdentifierCheck(StringRef Name, ClangTidyContext *Context);

clang-tools-extra/clang-tidy/bugprone/SignedCharMisuseCheck.cpp

@@ -20,12 +20,6 @@ namespace bugprone {
 
 static constexpr int UnsignedASCIIUpperBound = 127;
 
-static Matcher<TypedefDecl> hasAnyListedName(const std::string &Names) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(Names);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-
 SignedCharMisuseCheck::SignedCharMisuseCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
@@ -46,8 +40,8 @@ BindableMatcher<clang::Stmt> SignedCharMisuseCheck::charCastExpression(
   // We can ignore typedefs which are some kind of integer types
   // (e.g. typedef char sal_Int8). In this case, we don't need to
   // worry about the misinterpretation of char values.
-  const auto IntTypedef = qualType(
-      hasDeclaration(typedefDecl(hasAnyListedName(CharTypdefsToIgnoreList))));
+  const auto IntTypedef = qualType(hasDeclaration(typedefDecl(
+      hasAnyName(utils::options::parseStringList(CharTypdefsToIgnoreList)))));
 
   auto CharTypeExpr = expr();
   if (IsSigned) {

clang-tools-extra/clang-tidy/bugprone/SignedCharMisuseCheck.h

@@ -37,7 +37,7 @@ class SignedCharMisuseCheck : public ClangTidyCheck {
       const ast_matchers::internal::Matcher<clang::QualType> &IntegerType,
       const std::string &CastBindName) const;
 
-  const std::string CharTypdefsToIgnoreList;
+  const StringRef CharTypdefsToIgnoreList;
   const bool DiagnoseSignedUnsignedCharComparisons;
 };
 

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.cpp

@@ -27,7 +27,7 @@ const char DefaultStringNames[] =
     "::std::basic_string;::std::basic_string_view";
 
 static std::vector<StringRef>
-removeNamespaces(const std::vector<std::string> &Names) {
+removeNamespaces(const std::vector<StringRef> &Names) {
   std::vector<StringRef> Result;
   Result.reserve(Names.size());
   for (StringRef Name : Names) {

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.h

@@ -33,7 +33,7 @@ class StringConstructorCheck : public ClangTidyCheck {
   const bool IsStringviewNullptrCheckEnabled;
   const bool WarnOnLargeLength;
   const unsigned int LargeLengthThreshold;
-  std::vector<std::string> StringNames;
+  std::vector<StringRef> StringNames;
 };
 
 } // namespace bugprone

clang-tools-extra/clang-tidy/bugprone/SuspiciousIncludeCheck.h

@@ -46,8 +46,8 @@ class SuspiciousIncludeCheck : public ClangTidyCheck {
   utils::FileExtensionsSet ImplementationFileExtensions;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
-  const std::string RawStringImplementationFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
+  const StringRef RawStringImplementationFileExtensions;
 };
 
 } // namespace bugprone

clang-tools-extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

@@ -73,7 +73,7 @@ SuspiciousMissingCommaCheck::SuspiciousMissingCommaCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       SizeThreshold(Options.get("SizeThreshold", 5U)),
-      RatioThreshold(std::stod(Options.get("RatioThreshold", ".2"))),
+      RatioThreshold(std::stod(Options.get("RatioThreshold", ".2").str())),
       MaxConcatenatedTokens(Options.get("MaxConcatenatedTokens", 5U)) {}
 
 void SuspiciousMissingCommaCheck::storeOptions(

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

@@ -91,15 +91,12 @@ void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
 
   // Add the list of known string compare-like functions and add user-defined
   // functions.
-  std::vector<std::string> FunctionNames = utils::options::parseStringList(
-      (llvm::Twine(KnownStringCompareFunctions) + StringCompareLikeFunctions)
-          .str());
+  std::vector<StringRef> FunctionNames = utils::options::parseListPair(
+      KnownStringCompareFunctions, StringCompareLikeFunctions);
 
   // Match a call to a string compare functions.
   const auto FunctionCompareDecl =
-      functionDecl(hasAnyName(std::vector<StringRef>(FunctionNames.begin(),
-                                                     FunctionNames.end())))
-          .bind("decl");
+      functionDecl(hasAnyName(FunctionNames)).bind("decl");
   const auto DirectStringCompareCallExpr =
       callExpr(hasDeclaration(FunctionCompareDecl)).bind("call");
   const auto MacroStringCompareCallExpr = conditionalOperator(anyOf(

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.h

@@ -29,7 +29,7 @@ class SuspiciousStringCompareCheck : public ClangTidyCheck {
 private:
   const bool WarnOnImplicitComparison;
   const bool WarnOnLogicalNotComparison;
-  const std::string StringCompareLikeFunctions;
+  const StringRef StringCompareLikeFunctions;
 };
 
 } // namespace bugprone