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

[njames93]

Summary

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.

[aaron.ballman]

I went through the changes and they look correct to me... yet I'm still mildly terrified. :-D Have you tried running clang-tidy through its paces with ASan/MSan enabled to see if the change introduces any use-after-free issues in practice?

[njames93]

In D124341#3475083, @aaron.ballman wrote:

I went through the changes and they look correct to me... yet I'm still mildly terrified. :-D Have you tried running clang-tidy through its paces with ASan/MSan enabled to see if the change introduces any use-after-free issues in practice?

I can't seem to build LLVM with msan at all. But ASan, which checks things like use after free, ran all clang tools tests without a hitch.

[LegalizeAdulthood]

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

51

Why is StringRef::operator+ considered "better" than std::string::operator+?

56

find takes a StringRef so why convert to std::string here?

123

operator[] takes a StringRef so why convert to std::string here?

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

158

I think I would feel safer if the changes to the infrastructure were pushed separately from the changes to the checks, with some "bake time" in between so we have more confidence in the changes.

While debugging my own checks, I've seen that there are surprises with the lifetimes of StringRef.

[njames93]

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

51

Because 2 strings are created in the second instance, whereas only one is created in the first.

56

Because a concatenation of StringRef results in a Twine, which cannot be passed to find.

123

Again can't use a Twine for operator[].

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

158

These changes on their own don't make any sense without the corresponding changes to the checks.
Also the lifetime of all the checks options is tied to the ClangTidyOptions which outlives the checks.

[aaron.ballman]

In D124341#3476533, @njames93 wrote:

In D124341#3475083, @aaron.ballman wrote:

I went through the changes and they look correct to me... yet I'm still mildly terrified. :-D Have you tried running clang-tidy through its paces with ASan/MSan enabled to see if the change introduces any use-after-free issues in practice?

I can't seem to build LLVM with msan at all. But ASan, which checks things like use after free, ran all clang tools tests without a hitch.

Thanks for checking! I've convinced myself that I don't see any lifetime issues here (in each case, what the StringRef refers to should outlive the StringRef), so this LGTM.

[uabelho]

Hi,

I noticed that this patch isn't NFC.

If I run

clang-tidy -checks='*' empty.c --

on an empty file empty.c I get the following printouts with this patch:

'addr=address'
'arr=array'
'attr=attribute'
'buf=buffer'
'cl=client'
'cnt=count'
'col=column'
'cpy=copy'
'dest=destination'
'dist=distancedst=distance'
'elem=element'
'hght=height'
'i=index'
'idx=index'
'len=length'
'ln=line'
'lst=list'
'nr=number'
'num=number'
'pos=position'
'ptr=pointer'
'ref=reference'
'src=source'
'srv=server'
'stmt=statement'
'str=string'
'val=value'
'var=variable'
'vec=vector'
'wdth=width'

but without this patch it's completely silent.

[njames93]

In D124341#3502659, @uabelho wrote:

Hi,

I noticed that this patch isn't NFC.

Whoops, good catch. I left in some debugging code, fixed in rGa308a55720249749

[uabelho]

In D124341#3504427, @njames93 wrote:

In D124341#3502659, @uabelho wrote:

Hi,

I noticed that this patch isn't NFC.

Whoops, good catch. I left in some debugging code, fixed in rGa308a55720249749

Thanks!

[LegalizeAdulthood]

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

56

Interactions between std::string, StringRef and Twine always make my brain hurt :).

I keep wondering if there's a way to make StringRef and Twine more user-friendly, or perhaps a clang-tidy check that will alert you to things that are "considered harmful".

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

OptionsView(StringRef CheckName,
                 const ClangTidyOptions::OptionMap &CheckOptions,
                 ClangTidyContext *Context);
 
     /// 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, 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``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, return
     /// ``None``.
     ///
     /// If the corresponding key can't be parsed as a ``T``, emit a
     /// diagnostic and return ``None``.
     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;
         diagnoseBadIntegerOption(NamePrefix + LocalName, *Value);
       }
       return None;
     }
 
public:
     /// present, falls back to get global option. If global option is not
     /// present either, return ``None``.
     ///
     /// If the corresponding key can't be parsed as a ``T``, emit a
     /// diagnostic and return ``None``.
     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;
         ValueOr = getLocalOrGlobal(LocalName);
         if (!ValueOr)
           return None;
       }
       T Result{};

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

void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   // callback directly. We keep the run()/check() distinction to avoid interface
   // churn, and to allow us to add cross-cutting logic in the future.
   check(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())
     return IterLocal;
   if (IterLocal->getValue().Priority >= IterGlobal->getValue().Priority)
     return IterLocal;
   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;
 }
 
 static Optional<bool> getAsBool(StringRef Value,
                                 const llvm::Twine &LookupName) {
 
   if (llvm::Optional<bool> Parsed = llvm::yaml::parseBool(Value))
     return *Parsed;
   // To maintain backwards compatability, we support parsing numbers as
   // booleans, even though its not supported in YAML.
   long long Number;
   if (!Value.getAsInteger(10, Number))
     return Number != 0;
   return None;
 }
 
 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);
   }
   return None;
 }
 
 template <>
 llvm::Optional<bool>
 ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName) const {
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName);
   if (Iter != CheckOptions.end()) {
     if (auto Result = getAsBool(Iter->getValue().Value, Iter->getKey()))
       return Result;
     diagnoseBadBooleanOption(Iter->getKey(), Iter->getValue().Value);
   }
   return None;
 }
 
 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,
                                            StringRef LocalName,
                                            int64_t Value) const {
   store(Options, LocalName, llvm::itostr(Value));
 }
 
for (const auto &NameAndEnum : Mapping) {
     unsigned Distance =
         Value.edit_distance(NameAndEnum.second, true, EditDistance);
     if (Distance < EditDistance) {
       EditDistance = Distance;
       Closest = NameAndEnum.second;
     }
   }
   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;
 }
 
 static constexpr llvm::StringLiteral ConfigWarning(
     "invalid configuration value '%0' for option '%1'%select{|; expected a "
     "bool|; expected an integer|; did you mean '%3'?}2");
 
 void ClangTidyCheck::OptionsView::diagnoseBadBooleanOption(
void ClangTidyCheck::OptionsView::diagnoseBadEnumOption(
   auto Diag = Context->configurationDiag(ConfigWarning)
               << Unparsed << Lookup.toStringRef(Buffer);
   if (Suggestion.empty())
     Diag << 0;
   else
     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,
+  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/abseil/StringFindStartswithCheck.h

public:
   StringFindStartswithCheck(StringRef Name, ClangTidyContext *Context);
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   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
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H

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

: ClangTidyCheck(Name, Context),
       IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
                                                utils::IncludeSorter::IS_LLVM),
                       areDiagsSelfContained()),
       AbseilStringsMatchHeader(
           Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {}
 
 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)));
 
   auto StringFind = cxxMemberCallExpr(
       // .find()-call on a string...
       callee(cxxMethodDecl(hasName("find")).bind("findfun")),
       on(hasType(StringType)),
       // ... with some search expression ...

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

 /// http://clang.llvm.org/extra/clang-tidy/checks/abseil-string-find-str-contains.html
 class StringFindStrContainsCheck : public utils::TransformerClangTidyCheck {
 public:
   StringFindStrContainsCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
   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
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H

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

 AST_MATCHER(Type, isCharType) { return Node.isCharType(); }
 
 static const char DefaultStringLikeClasses[] = "::std::basic_string;"
                                                "::std::basic_string_view;"
                                                "::absl::string_view";
 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 =
       hasUnqualifiedDesugaredType(pointerType(pointee(isAnyCharacter())));
   auto CharType = hasUnqualifiedDesugaredType(isCharType());
   auto StringNpos = declRefExpr(
       to(varDecl(hasName("npos"), hasDeclContext(StringLikeClass))));
   auto StringFind = cxxMemberCallExpr(

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

 class ComparisonInTempFailureRetryCheck : public ClangTidyCheck {
 public:
   ComparisonInTempFailureRetryCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawRetryList;
+  const StringRef RawRetryList;
   SmallVector<StringRef, 5> RetryMacros;
 };
 
 } // namespace android
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_COMPARISONINTEMPFAILURERETRYCHECK_H

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

 public:
   AssertSideEffectCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 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
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_ASSERTSIDEEFFECTCHECK_H

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

 
 } // namespace
 
 AssertSideEffectCheck::AssertSideEffectCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : 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);
 }
 
 // The options are explained in AssertSideEffectCheck.h.
 void AssertSideEffectCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "CheckFunctionCalls", CheckFunctionCalls);
   Options.store(Opts, "AssertMacros", RawAssertList);
   Options.store(Opts, "IgnoredFunctions",

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

public:
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   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;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DANGLING_HANDLE_H

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

 } // anonymous namespace
 
 DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
                                          ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       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",
                 utils::options::serializeStringList(HandleClasses));
 }
 
 void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {
   const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle);

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

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus && !LangOpts.ThreadsafeStatics;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
   utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H

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

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
   /// The minimum length of an adjacent swappable parameter range required for
   /// a diagnostic.
   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.
   const bool QualifiersMix;
 
   /// Whether to model implicit conversions "in full" (conditions apply)
   /// during analysis and consider types that are implicitly convertible to
   /// one another mixable.

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

LLVM_DEBUG(llvm::dbgs() << "\tType name code is '"
                             << "'...\n");
 
     return Lexer::getSourceText(CharSourceRange::getTokenRange(B, E), SM, LO);
   }();
 
   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");
       return true;
     }
   }
 
   return false;

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

 /// The C standard additionally reserves names beginning with a double
 /// underscore, while the C++ standard strengthens this to reserve names with a
 /// double underscore occurring anywhere.
 ///
 /// For the user-facing documentation see:
 /// 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);
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   llvm::Optional<FailureInfo>

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

static std::string getNonReservedFixup(std::string Name) {
   else
     Name.insert(Name.begin(), 2, '_');
   return 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;
 
   // TODO: Check for names identical to language keywords, and other names
   // specifically reserved by language standards, e.g. C++ 'zombie names' and C
   // future library directions
 

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

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   ast_matchers::internal::BindableMatcher<clang::Stmt> charCastExpression(
       bool IsSigned,
       const ast_matchers::internal::Matcher<clang::QualType> &IntegerType,
       const std::string &CastBindName) const;
 
-  const std::string CharTypdefsToIgnoreList;
+  const StringRef CharTypdefsToIgnoreList;
   const bool DiagnoseSignedUnsignedCharComparisons;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIGNEDCHARMISUSECHECK_H

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

 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 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),
       CharTypdefsToIgnoreList(Options.get("CharTypdefsToIgnore", "")),
       DiagnoseSignedUnsignedCharComparisons(
           Options.get("DiagnoseSignedUnsignedCharComparisons", true)) {}
 
 void SignedCharMisuseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "CharTypdefsToIgnore", CharTypdefsToIgnoreList);
   Options.store(Opts, "DiagnoseSignedUnsignedCharComparisons",
                 DiagnoseSignedUnsignedCharComparisons);
 }
 
 // Create a matcher for char -> integer cast.
 BindableMatcher<clang::Stmt> SignedCharMisuseCheck::charCastExpression(
     bool IsSigned, const Matcher<clang::QualType> &IntegerType,
     const std::string &CastBindName) const {
   // 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) {
     CharTypeExpr = expr(hasType(
         qualType(isAnyCharacter(), isSignedInteger(), unless(IntTypedef))));
   } else {
     CharTypeExpr = expr(hasType(qualType(
         isAnyCharacter(), unless(isSignedInteger()), unless(IntTypedef))));

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

public:
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool IsStringviewNullptrCheckEnabled;
   const bool WarnOnLargeLength;
   const unsigned int LargeLengthThreshold;
-  std::vector<std::string> StringNames;
+  std::vector<StringRef> StringNames;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H

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

 AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
   return Node.getValue().getZExtValue() > N;
 }
 
 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) {
     std::string::size_type ColonPos = Name.rfind(':');
     Result.push_back(
         Name.substr(ColonPos == std::string::npos ? 0 : ColonPos + 1));
   }
   return Result;

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

public:
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
   utils::FileExtensionsSet HeaderFileExtensions;
   utils::FileExtensionsSet ImplementationFileExtensions;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
-  const std::string RawStringImplementationFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
+  const StringRef RawStringImplementationFileExtensions;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSINCLUDECHECK_H

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

 }
 
 } // namespace
 
 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(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "SizeThreshold", SizeThreshold);
   Options.store(Opts, "RatioThreshold", std::to_string(RatioThreshold));
   Options.store(Opts, "MaxConcatenatedTokens", MaxConcatenatedTokens);
 }

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

public:
   SuspiciousStringCompareCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool WarnOnImplicitComparison;
   const bool WarnOnLogicalNotComparison;
-  const std::string StringCompareLikeFunctions;
+  const StringRef StringCompareLikeFunctions;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H

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

void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
   // Match relational operators.
   const auto ComparisonUnaryOperator = unaryOperator(hasOperatorName("!"));
   const auto ComparisonBinaryOperator = binaryOperator(isComparisonOperator());
   const auto ComparisonOperator =
       expr(anyOf(ComparisonUnaryOperator, ComparisonBinaryOperator));
 
   // 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(
       hasTrueExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)),
       hasFalseExpression(ignoringParenImpCasts(DirectStringCompareCallExpr))));
   // The implicit cast is not present in C.
   const auto StringCompareCallExpr = ignoringParenImpCasts(
       anyOf(DirectStringCompareCallExpr, MacroStringCompareCallExpr));

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

 }
 
 void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
   auto FunVec = utils::options::parseStringList(CheckedFunctions);
   auto MatchedCallExpr = expr(ignoringImplicit(ignoringParenImpCasts(
       callExpr(callee(functionDecl(
                    // Don't match void overloads of checked functions.
                    unless(returns(voidType())),
-                   isInstantiatedFrom(hasAnyName(
-                       std::vector<StringRef>(FunVec.begin(), FunVec.end()))))))
+                   isInstantiatedFrom(hasAnyName(FunVec)))))
           .bind("match"))));
 
   auto UnusedInCompoundStmt =
       compoundStmt(forEach(MatchedCallExpr),
                    // The checker can't currently differentiate between the
                    // return statement and other statements inside GNU statement
                    // expressions, so disable the checker inside them to avoid
                    // false positives.

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus && !LangOpts.ObjC;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string MemSetNames;
-  const std::string MemCpyNames;
-  const std::string MemCmpNames;
+  const StringRef MemSetNames;
+  const StringRef MemCpyNames;
+  const StringRef MemCmpNames;
 };
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NONTRIVIALTYPESLIBCMEMORYCALLSCHECK_H

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.cpp

 
 namespace {
 AST_MATCHER(CXXRecordDecl, isTriviallyDefaultConstructible) {
   return Node.hasTrivialDefaultConstructor();
 }
 AST_MATCHER(CXXRecordDecl, isTriviallyCopyable) {
   return Node.hasTrivialCopyAssignment() && Node.hasTrivialCopyConstructor();
 }
-AST_MATCHER_P(NamedDecl, hasAnyNameStdString, std::vector<std::string>,
-              String) {
-  return ast_matchers::internal::HasNameMatcher(String).matchesNode(Node);
-}
 } // namespace
 
 static const char BuiltinMemSet[] = "::std::memset;"
                                     "::memset;";
 static const char BuiltinMemCpy[] = "::std::memcpy;"
                                     "::memcpy;"
                                     "::std::memmove;"
                                     "::memmove;"
                                     "::std::strcpy;"
                                     "::strcpy;"
                                     "::memccpy;"
                                     "::stpncpy;"
                                     "::strncpy;";
 static const char BuiltinMemCmp[] = "::std::memcmp;"
                                     "::memcmp;"
                                     "::std::strcmp;"
                                     "::strcmp;"
                                     "::strncmp;";
 static constexpr llvm::StringRef ComparisonOperators[] = {
     "operator==", "operator!=", "operator<",
     "operator>",  "operator<=", "operator>="};
 
-static std::vector<std::string> parseStringListPair(StringRef LHS,
-                                                    StringRef RHS) {
-  if (LHS.empty()) {
-    if (RHS.empty())
-      return {};
-    return utils::options::parseStringList(RHS);
-  }
-  if (RHS.empty())
-    return utils::options::parseStringList(LHS);
-  llvm::SmallString<512> Buffer;
-  return utils::options::parseStringList((LHS + RHS).toStringRef(Buffer));
-}
-
 NonTrivialTypesLibcMemoryCallsCheck::NonTrivialTypesLibcMemoryCallsCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MemSetNames(Options.get("MemSetNames", "")),
       MemCpyNames(Options.get("MemCpyNames", "")),
       MemCmpNames(Options.get("MemCmpNames", "")) {}
 
 void NonTrivialTypesLibcMemoryCallsCheck::storeOptions(
void NonTrivialTypesLibcMemoryCallsCheck::registerMatchers(
   auto ArgChecker = [&](Matcher<CXXRecordDecl> RecordConstraint,
                         BindableMatcher<Stmt> SecondArg) {
     return allOf(argumentCountIs(3),
                  hasArgument(0, IsStructPointer(RecordConstraint, true)),
                  hasArgument(1, SecondArg), hasArgument(2, IsRecordSizeOf));
   };
 
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
-                   parseStringListPair(BuiltinMemSet, MemSetNames)))),
+      callExpr(callee(namedDecl(hasAnyName(
+                   utils::options::parseListPair(BuiltinMemSet, MemSetNames)))),
                ArgChecker(unless(isTriviallyDefaultConstructible()),
                           expr(integerLiteral(equals(0)))))
           .bind("lazyConstruct"),
       this);
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
-                   parseStringListPair(BuiltinMemCpy, MemCpyNames)))),
+      callExpr(callee(namedDecl(hasAnyName(
+                   utils::options::parseListPair(BuiltinMemCpy, MemCpyNames)))),
                ArgChecker(unless(isTriviallyCopyable()), IsStructPointer()))
           .bind("lazyCopy"),
       this);
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
-                   parseStringListPair(BuiltinMemCmp, MemCmpNames)))),
+      callExpr(callee(namedDecl(hasAnyName(
+                   utils::options::parseListPair(BuiltinMemCmp, MemCmpNames)))),
                ArgChecker(hasMethod(hasAnyName(ComparisonOperators)),
                           IsStructPointer()))
           .bind("lazyCompare"),
       this);
 }
 
 void NonTrivialTypesLibcMemoryCallsCheck::check(
     const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.h

public:
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   utils::IncludeInserter IncludeInserter;
-  const std::string MathHeader;
+  const StringRef MathHeader;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INITVARIABLESCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h

bool isWarningInhibitedByEquivalentSize(const ASTContext &Context,
                                           const BuiltinType &FromType,
                                           const BuiltinType &ToType) const;
 
   const bool WarnOnIntegerNarrowingConversion;
   const bool WarnOnIntegerToFloatingPointNarrowingConversion;
   const bool WarnOnFloatingPointNarrowingConversion;
   const bool WarnWithinTemplateInstantiation;
   const bool WarnOnEquivalentBitWidth;
-  const std::string IgnoreConversionFromTypes;
+  const StringRef IgnoreConversionFromTypes;
   const bool PedanticMode;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NARROWING_CONVERSIONS_H

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

 
 #include <cstdint>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
-namespace {
-auto hasAnyListedName(const std::string &Names) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(Names);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
 
 NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnIntegerNarrowingConversion(
           Options.get("WarnOnIntegerNarrowingConversion", true)),
       WarnOnIntegerToFloatingPointNarrowingConversion(
           Options.get("WarnOnIntegerToFloatingPointNarrowingConversion", true)),
void NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
   // ceil() and floor() are guaranteed to return integers, even though the type
   // is not integral.
   const auto IsCeilFloorCallExpr = expr(callExpr(callee(functionDecl(
       hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor")))));
 
   // We may want to exclude other types from the checks, such as `size_type`
   // and `difference_type`. These are often used to count elements, represented
   // in 64 bits and assigned to `int`. Rarely are people counting >2B elements.
-  const auto IsConversionFromIgnoredType =
-      hasType(namedDecl(hasAnyListedName(IgnoreConversionFromTypes)));
+  const auto IsConversionFromIgnoredType = hasType(namedDecl(
+      hasAnyName(utils::options::parseStringList(IgnoreConversionFromTypes))));
 
   // `IsConversionFromIgnoredType` will ignore narrowing calls from those types,
   // but not expressions that are promoted to an ignored type as a result of a
   // binary expression with one of those types.
   // For example, it will continue to reject:
   // `int narrowed = int_value + container.size()`.
   // We attempt to address common incidents of compound expressions with
   // `IsIgnoredTypeTwoLevelsDeep`, allowing binary expressions that have one

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.h

public:
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
 
   /// Checks matched function calls and gives suggestion to modernize the code.
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   /// Semicolon-separated list of fully qualified names of memory allocation
   /// functions the check warns about. Defaults to `::malloc;::calloc`.
-  const std::string AllocList;
+  const StringRef AllocList;
   /// Semicolon-separated list of fully qualified names of memory reallocation
   /// functions the check warns about. Defaults to `::realloc`.
-  const std::string ReallocList;
+  const StringRef ReallocList;
   /// Semicolon-separated list of fully qualified names of memory deallocation
   /// functions the check warns about. Defaults to `::free`.
-  const std::string DeallocList;
+  const StringRef DeallocList;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NO_MALLOC_H

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.cpp

 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
 void NoMallocCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "Allocations", AllocList);
   Options.store(Opts, "Reallocations", ReallocList);
   Options.store(Opts, "Deallocations", DeallocList);
 }
 
 void NoMallocCheck::registerMatchers(MatchFinder *Finder) {
   // Registering malloc, will suggest RAII.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyListedName(AllocList))))
+  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyName(
+                                  utils::options::parseStringList(AllocList)))))
                          .bind("allocation"),
                      this);
 
   // Registering realloc calls, suggest std::vector or std::string.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(ReallocList))))
+      callExpr(callee(functionDecl(
+                   hasAnyName(utils::options::parseStringList((ReallocList))))))
           .bind("realloc"),
       this);
 
   // Registering free calls, will suggest RAII instead.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(DeallocList))))
+      callExpr(callee(functionDecl(
+                   hasAnyName(utils::options::parseStringList((DeallocList))))))
           .bind("free"),
       this);
 }
 
 void NoMallocCheck::check(const MatchFinder::MatchResult &Result) {
   const CallExpr *Call = nullptr;
   StringRef Recommendation;
 

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

private:
   bool handleAssignmentAndInit(const ast_matchers::BoundNodes &Nodes);
   bool handleAssignmentFromNewOwner(const ast_matchers::BoundNodes &Nodes);
   bool handleReturnValues(const ast_matchers::BoundNodes &Nodes);
   bool handleOwnerMembers(const ast_matchers::BoundNodes &Nodes);
 
   /// List of old C-style functions that create resources.
   /// Defaults to
   /// `::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile`.
-  const std::string LegacyResourceProducers;
+  const StringRef LegacyResourceProducers;
   /// List of old C-style functions that consume or release resources.
   /// Defaults to `::free;::realloc;::freopen;::fclose`.
-  const std::string LegacyResourceConsumers;
+  const StringRef LegacyResourceConsumers;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-// FIXME: Copied from 'NoMallocCheck.cpp'. Has to be refactored into 'util' or
-// something like that.
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
 void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
   Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);
 }
 
 /// Match common cases, where the owner semantic is relevant, like function
 /// calls, delete expressions and others.
 void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
   const auto OwnerDecl = typeAliasTemplateDecl(hasName("::gsl::owner"));
   const auto IsOwnerType = hasType(OwnerDecl);
 
-  const auto LegacyCreatorFunctions = hasAnyListedName(LegacyResourceProducers);
+  const auto LegacyCreatorFunctions =
+      hasAnyName(utils::options::parseStringList(LegacyResourceProducers));
   const auto LegacyConsumerFunctions =
-      hasAnyListedName(LegacyResourceConsumers);
+      hasAnyName(utils::options::parseStringList(LegacyResourceConsumers));
 
   // Legacy functions that are use for resource management but cannot be
   // updated to use `gsl::owner<>`, like standard C memory management.
   const auto CreatesLegacyOwner =
       callExpr(callee(functionDecl(LegacyCreatorFunctions)));
   // C-style functions like `::malloc()` sometimes create owners as void*
   // which is expected to be cast to the correct type in C++. This case
   // must be caught explicitly.

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.h

 namespace cppcoreguidelines {
 
 /// This checks that all array subscriptions on static arrays and std::arrays
 /// have a constant index and are within bounds
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html
 class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck {
-  const std::string GslHeader;
+  const StringRef GslHeader;
   utils::IncludeInserter Inserter;
 
 public:
   ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,

clang-tools-extra/clang-tidy/google/GlobalNamesInHeadersCheck.h

 class GlobalNamesInHeadersCheck : public ClangTidyCheck {
 public:
   GlobalNamesInHeadersCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
   utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace readability
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H

clang-tools-extra/clang-tidy/google/IntegerTypesCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus && !LangOpts.ObjC;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Options) override;
 
 private:
-  const std::string UnsignedTypePrefix;
-  const std::string SignedTypePrefix;
-  const std::string TypeSuffix;
+  const StringRef UnsignedTypePrefix;
+  const StringRef SignedTypePrefix;
+  const StringRef TypeSuffix;
 
   std::unique_ptr<IdentifierTable> IdentTable;
 };
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H

clang-tools-extra/clang-tidy/google/UnnamedNamespaceInHeaderCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string RawStringHeaderFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
   utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H

clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h

bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool UseHeaderFileExtension;
-  const std::string RawStringHeaderFileExtensions;
+  const StringRef RawStringHeaderFileExtensions;
   utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h

 
 /// Class used to determine if any declarations used in a Stmt would conflict
 /// with a particular identifier. This search includes the names that don't
 /// actually appear in the AST (i.e. created by a refactoring tool) by including
 /// a map from Stmts to generated names associated with those stmts.
 class DeclFinderASTVisitor
     : public clang::RecursiveASTVisitor<DeclFinderASTVisitor> {
 public:
-  DeclFinderASTVisitor(const std::string &Name,
+  DeclFinderASTVisitor(const StringRef &Name,
                        const StmtGeneratedVarNameMap *GeneratedDecls)
       : Name(Name), GeneratedDecls(GeneratedDecls), Found(false) {}
 
   /// Attempts to find any usages of variables name Name in Body, returning
   /// true when it is used in Body. This includes the generated loop variables
   /// of ForStmts which have already been transformed.
   bool findUsages(const clang::Stmt *Body) {
     Found = false;

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h

protected:
 
   /// Returns whether the C++ version is compatible with current check.
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
 
   static const char PointerType[];
 
 private:
   utils::IncludeInserter Inserter;
-  const std::string MakeSmartPtrFunctionHeader;
-  const std::string MakeSmartPtrFunctionName;
+  const StringRef MakeSmartPtrFunctionHeader;
+  const StringRef MakeSmartPtrFunctionName;
   const bool IgnoreMacros;
   const bool IgnoreDefaultInitialization;
 
   void checkConstruct(SourceManager &SM, ASTContext *Ctx,
                       const CXXConstructExpr *Construct, const QualType *Type,
                       const CXXNewExpr *New);
   void checkReset(SourceManager &SM, ASTContext *Ctx,
                   const CXXMemberCallExpr *Member, const CXXNewExpr *New);

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.h

ReplaceDisallowCopyAndAssignMacroCheck(StringRef Name,
                                          ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
-  const std::string &getMacroName() const { return MacroName; }
+  const StringRef &getMacroName() const { return MacroName; }
 
 private:
-  const std::string MacroName;
+  const StringRef MacroName;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACEDISALLOWCOPYANDASSIGNMACROCHECK_H

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.h

bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const bool IgnoreImplicitConstructors;
-  const std::vector<std::string> ContainersWithPushBack;
-  const std::vector<std::string> SmartPointers;
-  const std::vector<std::string> TupleTypes;
-  const std::vector<std::string> TupleMakeFunctions;
+  const std::vector<StringRef> ContainersWithPushBack;
+  const std::vector<StringRef> SmartPointers;
+  const std::vector<StringRef> TupleTypes;
+  const std::vector<StringRef> TupleMakeFunctions;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EMPLACE_H

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   // and std::deque.
   // + add handling of `push` for std::stack, std::queue, std::priority_queue
   // + add handling of `insert` for stl associative container, but be careful
   // because this requires special treatment (it could cause performance
   // regression)
   // + match for emplace calls that should be replaced with insertion
   auto CallPushBack = cxxMemberCallExpr(
       hasDeclaration(functionDecl(hasName("push_back"))),
-      on(hasType(cxxRecordDecl(hasAnyName(SmallVector<StringRef, 5>(
-          ContainersWithPushBack.begin(), ContainersWithPushBack.end()))))));
+      on(hasType(cxxRecordDecl(hasAnyName(ContainersWithPushBack)))));
 
   // We can't replace push_backs of smart pointer because
   // if emplacement fails (f.e. bad_alloc in vector) we will have leak of
   // passed pointer because smart pointer won't be constructed
   // (and destructed) as in push_back case.
-  auto IsCtorOfSmartPtr = hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
-      SmallVector<StringRef, 5>(SmartPointers.begin(), SmartPointers.end())))));
+  auto IsCtorOfSmartPtr =
+      hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(SmartPointers))));
 
   // Bitfields binds only to consts and emplace_back take it by universal ref.
   auto BitFieldAsArgument = hasAnyArgument(
       ignoringImplicit(memberExpr(hasDeclaration(fieldDecl(isBitField())))));
 
   // Initializer list can't be passed to universal reference.
   auto InitializerListAsArgument = hasAnyArgument(
       ignoringImplicit(cxxConstructExpr(isListInitialization())));
auto SoughtConstructExpr =
       cxxConstructExpr(
           unless(anyOf(IsCtorOfSmartPtr, HasInitList, BitFieldAsArgument,
                        InitializerListAsArgument, NewExprAsArgument,
                        ConstructingDerived, IsPrivateCtor)))
           .bind("ctor");
   auto HasConstructExpr = has(ignoringImplicit(SoughtConstructExpr));
 
   auto MakeTuple = ignoringImplicit(
-      callExpr(
-          callee(expr(ignoringImplicit(declRefExpr(
+      callExpr(callee(expr(ignoringImplicit(declRefExpr(
                    unless(hasExplicitTemplateArgs()),
-              to(functionDecl(hasAnyName(SmallVector<StringRef, 2>(
-                  TupleMakeFunctions.begin(), TupleMakeFunctions.end())))))))))
+                   to(functionDecl(hasAnyName(TupleMakeFunctions))))))))
           .bind("make"));
 
   // make_something can return type convertible to container's element type.
   // Allow the conversion only on containers of pairs.
   auto MakeTupleCtor = ignoringImplicit(cxxConstructExpr(
       has(materializeTemporaryExpr(MakeTuple)),
-      hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
-          SmallVector<StringRef, 2>(TupleTypes.begin(), TupleTypes.end())))))));
+      hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(TupleTypes))))));
 
   auto SoughtParam = materializeTemporaryExpr(
       anyOf(has(MakeTuple), has(MakeTupleCtor),
             HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr))));
 
   Finder->addMatcher(
       traverse(TK_AsIs, cxxMemberCallExpr(CallPushBack, has(SoughtParam),
                                           unless(isInTemplateInstantiation()))

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.h

 public:
   UseNodiscardCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string NoDiscardMacro;
+  const StringRef NoDiscardMacro;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USENODISCARDCHECK_H

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.cpp

void UseNodiscardCheck::check(const MatchFinder::MatchResult &Result) {
   // Check for the existence of the keyword being used as the ``[[nodiscard]]``.
   if (!doesNoDiscardMacroExist(Context, NoDiscardMacro))
     return;
 
   // Possible false positives include:
   // 1. A const member function which returns a variable which is ignored
   // but performs some external I/O operation and the return value could be
   // ignored.
-  Diag << FixItHint::CreateInsertion(RetLoc, NoDiscardMacro + " ");
+  Diag << FixItHint::CreateInsertion(RetLoc, (NoDiscardMacro + " ").str());
 }
 
 bool UseNodiscardCheck::isLanguageVersionSupported(
     const LangOptions &LangOpts) const {
   // If we use ``[[nodiscard]]`` attribute, we require at least C++17. Use a
   // macro or ``__attribute__`` with pre c++17 compilers by using
   // ReplacementString option.
 

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string NoexceptMacro;
+  const StringRef NoexceptMacro;
   const bool UseNoexceptFalse;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.cpp

void UseNoexceptCheck::check(const MatchFinder::MatchResult &Result) {
   assert(Range.isValid() && "Exception Source Range is invalid.");
 
   CharSourceRange CRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Range), *Result.SourceManager,
       Result.Context->getLangOpts());
 
   bool IsNoThrow = FnTy->isNothrow();
   StringRef ReplacementStr =
-      IsNoThrow
-          ? NoexceptMacro.empty() ? "noexcept" : NoexceptMacro.c_str()
-          : NoexceptMacro.empty()
-                ? (DtorOrOperatorDel || UseNoexceptFalse) ? "noexcept(false)"
-                                                          : ""
-                : "";
+      IsNoThrow ? NoexceptMacro.empty() ? "noexcept" : NoexceptMacro
+          ? (DtorOrOperatorDel || UseNoexceptFalse) ? "noexcept(false)" : ""
 
   FixItHint FixIt;
   if ((IsNoThrow || NoexceptMacro.empty()) && CRange.isValid())
     FixIt = FixItHint::CreateReplacement(CRange, ReplacementStr);
 
   diag(Range.getBegin(), "dynamic exception specification '%0' is deprecated; "
                          "consider %select{using '%2'|removing it}1 instead")
       << Lexer::getSourceText(CRange, *Result.SourceManager,
                               Result.Context->getLangOpts())
       << ReplacementStr.empty() << ReplacementStr << FixIt;
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.h

bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     // erroneously fail.
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const std::string NullMacrosStr;
+  const StringRef NullMacrosStr;
   SmallVector<StringRef, 1> NullMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.h

public:
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const bool IgnoreDestructors;
   const bool AllowOverrideAndFinal;
-  const std::string OverrideSpelling;
-  const std::string FinalSpelling;
+  const StringRef OverrideSpelling;
+  const StringRef FinalSpelling;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USEOVERRIDECHECK_H

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

void UseOverrideCheck::check(const MatchFinder::MatchResult &Result) {
   // FIXME: Instead of re-lexing and looking for specific macros such as
   // 'ABSTRACT', properly store the location of 'virtual' and '= 0' in each
   // FunctionDecl.
   SmallVector<Token, 16> Tokens = parseTokens(FileRange, Result);
 
   // Add 'override' on inline declarations that don't already have it.
   if (!HasFinal && !HasOverride) {
     SourceLocation InsertLoc;
-    std::string ReplacementText = OverrideSpelling + " ";
+    std::string ReplacementText = (OverrideSpelling + " ").str();
     SourceLocation MethodLoc = Method->getLocation();
 
     for (Token T : Tokens) {
       if (T.is(tok::kw___attribute) &&
           !Sources.isBeforeInTranslationUnit(T.getLocation(), MethodLoc)) {
         InsertLoc = T.getLocation();
         break;
       }
if (!HasFinal && !HasOverride) {
     }
 
     if (InsertLoc.isInvalid() && Method->doesThisDeclarationHaveABody() &&
         Method->getBody() && !Method->isDefaulted()) {
       // For methods with inline definition, add the override keyword at the
       // end of the declaration of the function, but prefer to put it on the
       // same line as the declaration if the beginning brace for the start of
       // the body falls on the next line.
-      ReplacementText = " " + OverrideSpelling;
+      ReplacementText = (" " + OverrideSpelling).str();
       auto *LastTokenIter = std::prev(Tokens.end());
       // When try statement is used instead of compound statement as
       // method body - insert override keyword before it.
       if (LastTokenIter->is(tok::kw_try))
         LastTokenIter = std::prev(LastTokenIter);
       InsertLoc = LastTokenIter->getEndLoc();
     }
 
     if (!InsertLoc.isValid()) {
       // For declarations marked with "= 0" or "= [default|delete]", the end
       // location will point until after those markings. Therefore, the override
       // keyword shouldn't be inserted at the end, but before the '='.
       if (Tokens.size() > 2 &&
           (getText(Tokens.back(), Sources) == "0" ||
            Tokens.back().is(tok::kw_default) ||
            Tokens.back().is(tok::kw_delete)) &&
           getText(Tokens[Tokens.size() - 2], Sources) == "=") {
         InsertLoc = Tokens[Tokens.size() - 2].getLocation();
         // Check if we need to insert a space.
         if ((Tokens[Tokens.size() - 2].getFlags() & Token::LeadingSpace) == 0)
-          ReplacementText = " " + OverrideSpelling + " ";
+          ReplacementText = (" " + OverrideSpelling + " ").str();
       } else if (getText(Tokens.back(), Sources) == "ABSTRACT")
         InsertLoc = Tokens.back().getLocation();
     }
 
     if (!InsertLoc.isValid()) {
       InsertLoc = FileRange.getEnd();
-      ReplacementText = " " + OverrideSpelling;
+      ReplacementText = (" " + OverrideSpelling).str();
     }
 
     // If the override macro has been specified just ensure it exists,
     // if not don't apply a fixit but keep the warning.
     if (OverrideSpelling != "override" &&
         !Context.Idents.get(OverrideSpelling).hasMacroDefinition())
       return;
 

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.h

 //===--- ForbiddenSubclassingCheck.h - clang-tidy ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_FORBIDDEN_SUBCLASSING_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_FORBIDDEN_SUBCLASSING_CHECK_H
 
 #include "../ClangTidyCheck.h"
 #include "llvm/ADT/StringRef.h"
-#include <string>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 namespace objc {
 
 /// Finds Objective-C classes which have a superclass which is
 /// documented to not support subclassing.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/objc-forbidden-subclassing.html
 class ForbiddenSubclassingCheck : public ClangTidyCheck {
 public:
   ForbiddenSubclassingCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.ObjC;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Options) override;
 
 private:
-  const std::vector<std::string> ForbiddenSuperClassNames;
+  const std::vector<StringRef> ForbiddenSuperClassNames;
 };
 
 } // namespace objc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_FORBIDDEN_SUBCLASSING_CHECK_H

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.cpp

: ClangTidyCheck(Name, Context),
       ForbiddenSuperClassNames(
           utils::options::parseStringList(
               Options.get("ClassNames", DefaultForbiddenSuperClassNames))) {
 }
 
 void ForbiddenSubclassingCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       objcInterfaceDecl(
-          isDerivedFrom(
-              objcInterfaceDecl(
-                  hasAnyName(
-                      std::vector<StringRef>(
-                          ForbiddenSuperClassNames.begin(),
-                          ForbiddenSuperClassNames.end())))
+          isDerivedFrom(objcInterfaceDecl(hasAnyName(ForbiddenSuperClassNames))
                             .bind("superclass")))
           .bind("subclass"),
       this);
 }
 
 void ForbiddenSubclassingCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *SubClass = Result.Nodes.getNodeAs<ObjCInterfaceDecl>(
       "subclass");
   assert(SubClass != nullptr);

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
-  const std::vector<std::string> StringLikeClasses;
+  const std::vector<StringRef> StringLikeClasses;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_FASTER_STRING_FIND_H

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

const auto StringFindFunctions =
       hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",
                  "find_last_of", "find_last_not_of");
 
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(functionDecl(StringFindFunctions).bind("func")),
           anyOf(argumentCountIs(1), argumentCountIs(2)),
           hasArgument(0, SingleChar),
-          on(expr(
-              hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
-                  recordDecl(hasAnyName(SmallVector<StringRef, 4>(
-                      StringLikeClasses.begin(), StringLikeClasses.end()))))))),
+          on(expr(hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
+                      recordDecl(hasAnyName(StringLikeClasses)))))),
                   unless(hasSubstitutedType())))),
       this);
 }
 
 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   auto Replacement = makeCharacterLiteral(Literal);

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.h

private:
   // Checks if the loop variable is a non-const value and whether only
   // const methods are invoked on it or whether it is only used as a const
   // reference argument. If so it suggests it be made a const reference.
   bool handleCopyIsOnlyConstReferenced(const VarDecl &LoopVar,
                                        const CXXForRangeStmt &ForRange,
                                        ASTContext &Context);
 
   const bool WarnOnAllAutoCopies;
-  const std::vector<std::string> AllowedTypes;
+  const std::vector<StringRef> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_FORRANGECOPYCHECK_H

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   void addMatcher(const ast_matchers::DeclarationMatcher &TargetRecordDecl,
                   StringRef VarDeclName, StringRef VarDeclStmtName,
                   const ast_matchers::DeclarationMatcher &AppendMethodDecl,
                   StringRef AppendCallName, ast_matchers::MatchFinder *Finder);
-  const std::vector<std::string> VectorLikeClasses;
+  const std::vector<StringRef> VectorLikeClasses;
 
   // If true, also check inefficient operations for proto repeated fields.
   bool EnableProto;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENT_VECTOR_OPERATION_H

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

Finder->addMatcher(
                     memberExpr(hasObjectExpression(unless(hasSideEffects())),
                                supportedContainerTypesMatcher()))),
           HasInterestingLoopBody, InInterestingCompoundStmt)
           .bind(RangeLoopName),
       this);
 }
 
 void InefficientVectorOperationCheck::registerMatchers(MatchFinder *Finder) {
-  const auto VectorDecl = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 5>(
-      VectorLikeClasses.begin(), VectorLikeClasses.end())));
+  const auto VectorDecl = cxxRecordDecl(hasAnyName(VectorLikeClasses));
   const auto AppendMethodDecl =
       cxxMethodDecl(hasAnyName("push_back", "emplace_back"));
   addMatcher(VectorDecl, VectorVarDeclName, VectorVarDeclStmtName,
              AppendMethodDecl, PushBackOrEmplaceBackCallName, Finder);
 
   if (EnableProto) {
     const auto ProtoDecl =
         cxxRecordDecl(isDerivedFrom("::proto2::MessageLite"));

clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
-  const std::vector<std::string> AllowedTypes;
+  const std::vector<StringRef> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOAUTOMATICMOVECHECK_H

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.h

 private:
   void handleCopyFromMethodReturn(const VarDecl &Var, const Stmt &BlockStmt,
                                   const DeclStmt &Stmt, bool IssueFix,
                                   const VarDecl *ObjectArg,
                                   ASTContext &Context);
   void handleCopyFromLocalVar(const VarDecl &NewVar, const VarDecl &OldVar,
                               const Stmt &BlockStmt, const DeclStmt &Stmt,
                               bool IssueFix, ASTContext &Context);
-  const std::vector<std::string> AllowedTypes;
-  const std::vector<std::string> ExcludedContainerTypes;
+  const std::vector<StringRef> AllowedTypes;
+  const std::vector<StringRef> ExcludedContainerTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_COPY_INITIALIZATION_H

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

if (Tok && PastNewLine) {
     Diagnostic << FixItHint::CreateRemoval(
         SourceRange(Stmt.getBeginLoc(), End));
   } else {
     Diagnostic << FixItHint::CreateRemoval(Stmt.getSourceRange());
   }
 }
 
 AST_MATCHER_FUNCTION_P(StatementMatcher, isConstRefReturningMethodCall,
-                       std::vector<std::string>, ExcludedContainerTypes) {
+                       std::vector<StringRef>, ExcludedContainerTypes) {
   // Match method call expressions where the `this` argument is only used as
   // const, this will be checked in `check()` part. This returned const
   // reference is highly likely to outlive the local const reference of the
   // variable being declared. The assumption is that the const reference being
   // returned either points to a global static variable or to a member of the
   // called object.
   const auto MethodDecl =
       cxxMethodDecl(returns(hasCanonicalType(matchers::isReferenceToConst())))
AST_MATCHER_FUNCTION(StatementMatcher, isConstRefReturningFunctionCall) {
   return callExpr(callee(functionDecl(returns(hasCanonicalType(
                                           matchers::isReferenceToConst())))
                              .bind(FunctionDeclId)),
                   argumentCountIs(0), unless(callee(cxxMethodDecl())))
       .bind(InitFunctionCallId);
 }
 
 AST_MATCHER_FUNCTION_P(StatementMatcher, initializerReturnsReferenceToConst,
-                       std::vector<std::string>, ExcludedContainerTypes) {
+                       std::vector<StringRef>, ExcludedContainerTypes) {
   auto OldVarDeclRef =
       declRefExpr(to(varDecl(hasLocalStorage()).bind(OldVarDeclId)));
   return expr(
       anyOf(isConstRefReturningFunctionCall(),
             isConstRefReturningMethodCall(ExcludedContainerTypes),
             ignoringImpCasts(OldVarDeclRef),
             ignoringImpCasts(unaryOperator(hasOperatorName("&"),
                                            hasUnaryOperand(OldVarDeclRef)))));
 }
 
 // This checks that the variable itself is only used as const, and also makes
 // sure that it does not reference another variable that could be modified in
 // the BlockStmt. It does this by checking the following:
 // 1. If the variable is neither a reference nor a pointer then the
 // isOnlyUsedAsConst() check is sufficient.
 // 2. If the (reference or pointer) variable is not initialized in a DeclStmt in
 // the BlockStmt. In this case its pointee is likely not modified (unless it
 // is passed as an alias into the method as well).
 // 3. If the reference is initialized from a reference to const. This is
 // the same set of criteria we apply when identifying the unnecessary copied
 // variable in this check to begin with. In this case we check whether the
 // object arg or variable that is referenced is immutable as well.
 static bool isInitializingVariableImmutable(
     const VarDecl &InitializingVar, const Stmt &BlockStmt, ASTContext &Context,
-    const std::vector<std::string> &ExcludedContainerTypes) {
+    const std::vector<StringRef> &ExcludedContainerTypes) {
   if (!isOnlyUsedAsConst(InitializingVar, BlockStmt, Context))
     return false;
 
   QualType T = InitializingVar.getType().getCanonicalType();
   // The variable is a value type and we know it is only used as const. Safe
   // to reference it and avoid the copy.
   if (!isa<ReferenceType, PointerType>(T))
     return true;

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.h

 
 private:
   void handleMoveFix(const ParmVarDecl &Var, const DeclRefExpr &CopyArgument,
                      const ASTContext &Context);
 
   llvm::DenseMap<const FunctionDecl *, FunctionParmMutationAnalyzer>
       MutationAnalyzers;
   utils::IncludeInserter Inserter;
-  const std::vector<std::string> AllowedTypes;
+  const std::vector<StringRef> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_VALUE_PARAM_H

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

private:
 
   const FileStyle &getStyleForFile(StringRef FileName) const;
 
   /// Stores the style options as a vector, indexed by the specified \ref
   /// StyleKind, for a given directory.
   mutable llvm::StringMap<FileStyle> NamingStylesCache;
   FileStyle *MainFileStyle;
   ClangTidyContext *Context;
-  const std::string CheckName;
+  const StringRef CheckName;
   const bool GetConfigPerFile;
   const bool IgnoreFailedSplit;
   HungarianNotation HungarianNotation;
 };
 
 } // namespace readability
 template <>
 struct OptionEnumMapping<readability::IdentifierNamingCheck::CaseType> {
   static llvm::ArrayRef<
       std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>>
   getEnumMapping();
 };
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

for (unsigned I = 0; I < SK_Count; ++I) {
     auto HPTOpt =
         Options.get<IdentifierNamingCheck::HungarianPrefixType>(StyleString);
     if (!HungarianNotation.checkOptionValid(I, StyleString) &&
         HPTOpt.hasValue())
       configurationDiag("invalid identifier naming option '%0'") << StyleString;
     StyleString.resize(StyleSize);
 
     StyleString.append("IgnoredRegexp");
-    std::string IgnoredRegexpStr = Options.get(StyleString, "");
+    StringRef IgnoredRegexpStr = Options.get(StyleString, "");
     StyleString.resize(StyleSize);
     StyleString.append("Prefix");
     std::string Prefix(Options.get(StyleString, ""));
     // Fast replacement of [Pre]fix -> [Suf]fix.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     std::string Postfix(Options.get(StyleString, ""));
     memcpy(&StyleString[StyleSize], "Case", 4);
     StyleString.pop_back();
     StyleString.pop_back();
     auto CaseOptional =
         Options.get<IdentifierNamingCheck::CaseType>(StyleString);
 
     if (CaseOptional || !Prefix.empty() || !Postfix.empty() ||
         !IgnoredRegexpStr.empty() || HPTOpt)
       Styles[I].emplace(std::move(CaseOptional), std::move(Prefix),
-                        std::move(Postfix), std::move(IgnoredRegexpStr),
+                        std::move(Postfix), IgnoredRegexpStr.str(),
                         HPTOpt.getValueOr(IdentifierNamingCheck::HPT_Off));
   }
   bool IgnoreMainLike = Options.get("IgnoreMainLikeFunctions", false);
   return {std::move(Styles), std::move(HNOption), IgnoreMainLike};
 }
 
 std::string IdentifierNamingCheck::HungarianNotation::getDeclTypeName(
     const NamedDecl *ND) const {
void IdentifierNamingCheck::HungarianNotation::loadFileConfig(
   static constexpr StringRef HNDerivedTypes[] = {"Array", "Pointer",
                                                  "FunctionPointer"};
 
   StringRef Section = "HungarianNotation.";
 
   SmallString<128> Buffer;
   for (const auto &Opt : HNOpts) {
     Buffer.assign({Section, "General.", Opt});
-    std::string Val = Options.get(Buffer, "");
+    StringRef Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.General[Opt] = std::move(Val);
+      HNOption.General[Opt] = Val.str();
   }
 
   for (const auto &Type : HNDerivedTypes) {
     Buffer.assign({Section, "DerivedType.", Type});
-    std::string Val = Options.get(Buffer, "");
+    StringRef Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.DerivedType[Type] = std::move(Val);
+      HNOption.DerivedType[Type] = Val.str();
   }
 
   static constexpr std::pair<StringRef, StringRef> HNCStrings[] = {
       {"CharPrinter", "char*"},
       {"CharArray", "char[]"},
       {"WideCharPrinter", "wchar_t*"},
       {"WideCharArray", "wchar_t[]"}};
 
   for (const auto &CStr : HNCStrings) {
     Buffer.assign({Section, "CString.", CStr.first});
-    std::string Val = Options.get(Buffer, "");
+    StringRef Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.CString[CStr.first] = std::move(Val);
+      HNOption.CString[CStr.first] = Val.str();
   }
 
   for (const auto &PrimType : HungarainNotationPrimitiveTypes) {
     Buffer.assign({Section, "PrimitiveType.", PrimType});
-    std::string Val = Options.get(Buffer, "");
+    StringRef Val = Options.get(Buffer, "");
     if (!Val.empty()) {
       std::string Type = PrimType.str();
       std::replace(Type.begin(), Type.end(), '-', ' ');
-      HNOption.PrimitiveType[Type] = std::move(Val);
+      HNOption.PrimitiveType[Type] = Val.str();
     }
   }
 
   for (const auto &Type : HungarainNotationUserDefinedTypes) {
     Buffer.assign({Section, "UserDefinedType.", Type});
-    std::string Val = Options.get(Buffer, "");
+    StringRef Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.UserDefinedType[Type] = std::move(Val);
+      HNOption.UserDefinedType[Type] = Val.str();
   }
 }
 
 std::string IdentifierNamingCheck::HungarianNotation::getPrefix(
     const Decl *D,
     const IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
   if (!D)
     return {};

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.h

void checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result,
     diag(MatchedLiteral->getLocation(),
          "%0 is a magic number; consider replacing it with a named constant")
         << LiteralSourceText;
   }
 
   const bool IgnoreAllFloatingPointValues;
   const bool IgnoreBitFieldsWidths;
   const bool IgnorePowersOf2IntegerValues;
-  const std::string RawIgnoredIntegerValues;
-  const std::string RawIgnoredFloatingPointValues;
+  const StringRef RawIgnoredIntegerValues;
+  const StringRef RawIgnoredFloatingPointValues;
 
   constexpr static unsigned SensibleNumberOfMagicValueExceptions = 16;
 
   constexpr static llvm::APFloat::roundingMode DefaultRoundingMode =
       llvm::APFloat::rmNearestTiesToEven;
 
   llvm::SmallVector<int64_t, SensibleNumberOfMagicValueExceptions>
       IgnoredIntegerValues;

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.cpp

: ClangTidyCheck(Name, Context),
       IgnoreBitFieldsWidths(Options.get("IgnoreBitFieldsWidths", true)),
       IgnorePowersOf2IntegerValues(
           Options.get("IgnorePowersOf2IntegerValues", false)),
       RawIgnoredIntegerValues(
           Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues)),
       RawIgnoredFloatingPointValues(Options.get(
           "IgnoredFloatingPointValues", DefaultIgnoredFloatingPointValues)) {
   // Process the set of ignored integer values.
-  const std::vector<std::string> IgnoredIntegerValuesInput =
+  const std::vector<StringRef> IgnoredIntegerValuesInput =
       utils::options::parseStringList(RawIgnoredIntegerValues);
   IgnoredIntegerValues.resize(IgnoredIntegerValuesInput.size());
   llvm::transform(IgnoredIntegerValuesInput, IgnoredIntegerValues.begin(),
-                  [](const std::string &Value) { return std::stoll(Value); });
+                  [](StringRef Value) {
+                    int64_t Res;
+                    Value.getAsInteger(10, Res);
+                    return Res;
+                  });
   llvm::sort(IgnoredIntegerValues);
 
   if (!IgnoreAllFloatingPointValues) {
     // Process the set of ignored floating point values.
-    const std::vector<std::string> IgnoredFloatingPointValuesInput =
+    const std::vector<StringRef> IgnoredFloatingPointValuesInput =
         utils::options::parseStringList(RawIgnoredFloatingPointValues);
     IgnoredFloatingPointValues.reserve(IgnoredFloatingPointValuesInput.size());
     IgnoredDoublePointValues.reserve(IgnoredFloatingPointValuesInput.size());
     for (const auto &InputValue : IgnoredFloatingPointValuesInput) {
       llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle());
       auto StatusOrErr =
           FloatValue.convertFromString(InputValue, DefaultRoundingMode);
       assert(StatusOrErr && "Invalid floating point representation");

clang-tools-extra/clang-tidy/readability/RedundantStringInitCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  std::vector<std::string> StringNames;
+  std::vector<StringRef> StringNames;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H

clang-tools-extra/clang-tidy/readability/RedundantStringInitCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 const char DefaultStringNames[] =
     "::std::basic_string_view;::std::basic_string";
 
-static ast_matchers::internal::Matcher<NamedDecl>
-hasAnyNameStdString(std::vector<std::string> Names) {
-  return ast_matchers::internal::Matcher<NamedDecl>(
-      new ast_matchers::internal::HasNameMatcher(std::move(Names)));
-}
-
-static std::vector<std::string>
-removeNamespaces(const std::vector<std::string> &Names) {
-  std::vector<std::string> Result;
+static std::vector<StringRef> removeNamespaces(ArrayRef<StringRef> Names) {
+  std::vector<StringRef> Result;
   Result.reserve(Names.size());
-  for (const std::string &Name : Names) {
-    std::string::size_type ColonPos = Name.rfind(':');
+  for (StringRef Name : Names) {
+    StringRef::size_type ColonPos = Name.rfind(':');
     Result.push_back(
-        Name.substr(ColonPos == std::string::npos ? 0 : ColonPos + 1));
+        Name.drop_front(ColonPos == StringRef::npos ? 0 : ColonPos + 1));
   }
   return Result;
 }
 
 static const CXXConstructExpr *
 getConstructExpr(const CXXCtorInitializer &CtorInit) {
   const Expr *InitExpr = CtorInit.getInit();
   if (const auto *CleanUpExpr = dyn_cast<ExprWithCleanups>(InitExpr))
: ClangTidyCheck(Name, Context),
       StringNames(utils::options::parseStringList(
           Options.get("StringNames", DefaultStringNames))) {}
 
 void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringNames", DefaultStringNames);
 }
 
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
-  const auto HasStringTypeName = hasAnyNameStdString(StringNames);
-  const auto HasStringCtorName =
-      hasAnyNameStdString(removeNamespaces(StringNames));
+  const auto HasStringTypeName = hasAnyName(StringNames);
+  const auto HasStringCtorName = hasAnyName(removeNamespaces(StringNames));
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(
       anyOf(cxxConstructExpr(argumentCountIs(1),
                              hasDeclaration(cxxMethodDecl(HasStringCtorName))),
             // If present, the second argument is the alloc object which must
             // not be present explicitly.
             cxxConstructExpr(argumentCountIs(2),

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.h

public:
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap& Opts) override;
   llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
     return TK_IgnoreUnlessSpelledInSource;
   }
 
 private:
-  const std::vector<std::string> Types;
+  const std::vector<StringRef> Types;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFYSUBSCRIPTEXPRCHECK_H

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.cpp

 SimplifySubscriptExprCheck::SimplifySubscriptExprCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), Types(utils::options::parseStringList(
                                          Options.get("Types", KDefaultTypes))) {
 }
 
 void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
   const auto TypesMatcher = hasUnqualifiedDesugaredType(
-      recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
-          llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));
+      recordType(hasDeclaration(cxxRecordDecl(hasAnyName(Types)))));
 
   Finder->addMatcher(
       arraySubscriptExpr(hasBase(
           cxxMemberCallExpr(
               has(memberExpr().bind("member")),
               on(hasType(qualType(
                   unless(anyOf(substTemplateTypeParmType(),
                                hasDescendant(substTemplateTypeParmType()))),

clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.cpp

for (std::size_t Idx = 0; Idx < HeuristicCount; ++Idx) {
     auto H = static_cast<Heuristic>(Idx);
     if (GetToggleOpt(H))
       AppliedHeuristics.emplace_back(H);
     ConfiguredBounds.emplace_back(
         std::make_pair(GetBoundOpt(H, BoundKind::DissimilarBelow),
                        GetBoundOpt(H, BoundKind::SimilarAbove)));
   }
 
-  for (const std::string &Abbreviation : optutils::parseStringList(
+  for (StringRef Abbreviation : optutils::parseStringList(
            Options.get("Abbreviations", DefaultAbbreviations))) {
-    auto KeyAndValue = StringRef{Abbreviation}.split("=");
+    auto KeyAndValue = Abbreviation.split("=");
+    llvm::errs() << "'" << Abbreviation << "'\n";
     assert(!KeyAndValue.first.empty() && !KeyAndValue.second.empty());
     AbbreviationDictionary.insert(
-        std::make_pair(KeyAndValue.first.str(), KeyAndValue.second.str()));
+        std::make_pair(KeyAndValue.first, KeyAndValue.second.str()));
   }
 }
 
 void SuspiciousCallArgumentCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinimumIdentifierNameLength",
                 MinimumIdentifierNameLength);
   const auto &SetToggleOpt = [this, &Opts](Heuristic H) -> void {
for (const auto &Abbreviation : AbbreviationDictionary) {
     EqualSignJoined.append(Abbreviation.first());
     EqualSignJoined.append("=");
     EqualSignJoined.append(Abbreviation.second);
 
     if (!Abbreviation.second.empty())
       Abbreviations.emplace_back(EqualSignJoined.str());
   }
   Options.store(Opts, "Abbreviations",
-                optutils::serializeStringList(Abbreviations));
+                optutils::serializeStringList(std::vector<StringRef>(
+                    Abbreviations.begin(), Abbreviations.end())));
 }
 
 bool SuspiciousCallArgumentCheck::isHeuristicEnabled(Heuristic H) const {
   return llvm::is_contained(AppliedHeuristics, H);
 }
 
 Optional<int8_t> SuspiciousCallArgumentCheck::getBound(Heuristic H,
                                                        BoundKind BK) const {

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.h

public:
   llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
     return TK_IgnoreUnlessSpelledInSource;
   }
 
 private:
   template <typename LiteralType>
   bool checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result);
 
-  const std::vector<std::string> NewSuffixes;
+  const std::vector<StringRef> NewSuffixes;
   const bool IgnoreMacros;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

llvm::Optional<SourceRange> getMacroAwareSourceRange(SourceRange Loc,
   llvm::Optional<SourceLocation> End = getMacroAwareLocation(Loc.getEnd(), SM);
   if (!Begin || !End)
     return llvm::None;
   return SourceRange(*Begin, *End);
 }
 
 llvm::Optional<std::string>
 getNewSuffix(llvm::StringRef OldSuffix,
-             const std::vector<std::string> &NewSuffixes) {
+             const std::vector<StringRef> &NewSuffixes) {
   // If there is no config, just uppercase the entirety of the suffix.
   if (NewSuffixes.empty())
     return OldSuffix.upper();
   // Else, find matching suffix, case-*insensitive*ly.
-  auto NewSuffix = llvm::find_if(
-      NewSuffixes, [OldSuffix](const std::string &PotentialNewSuffix) {
+  auto NewSuffix =
+      llvm::find_if(NewSuffixes, [OldSuffix](StringRef PotentialNewSuffix) {
         return OldSuffix.equals_insensitive(PotentialNewSuffix);
       });
   // Have a match, return it.
   if (NewSuffix != NewSuffixes.end())
-    return *NewSuffix;
+    return NewSuffix->str();
   // Nope, I guess we have to keep it as-is.
   return llvm::None;
 }
 
 template <typename LiteralType>
 llvm::Optional<NewSuffix>
 shouldReplaceLiteralSuffix(const Expr &Literal,
-                           const std::vector<std::string> &NewSuffixes,
+                           const std::vector<StringRef> &NewSuffixes,
                            const SourceManager &SM, const LangOptions &LO) {
   NewSuffix ReplacementDsc;
 
   const auto &L = cast<typename LiteralType::type>(Literal);
 
   // The naive location of the literal. Is always valid.
   ReplacementDsc.LiteralLocation = L.getSourceRange();
 

clang-tools-extra/clang-tidy/utils/Matchers.h

 }
 
 // A matcher implementation that matches a list of type name regular expressions
 // against a NamedDecl. If a regular expression contains the substring "::"
 // matching will occur against the qualified name, otherwise only the typename.
 class MatchesAnyListedNameMatcher
     : public ast_matchers::internal::MatcherInterface<NamedDecl> {
 public:
-  explicit MatchesAnyListedNameMatcher(llvm::ArrayRef<std::string> NameList) {
+  explicit MatchesAnyListedNameMatcher(llvm::ArrayRef<StringRef> NameList) {
     std::transform(
         NameList.begin(), NameList.end(), std::back_inserter(NameMatchers),
         [](const llvm::StringRef Name) { return NameMatcher(Name); });
   }
   bool matches(
       const NamedDecl &Node, ast_matchers::internal::ASTMatchFinder *Finder,
       ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override {
     return llvm::any_of(NameMatchers, [&Node](const NameMatcher &NM) {
private:
 
   std::vector<NameMatcher> NameMatchers;
 };
 
 // Returns a matcher that matches NamedDecl's against a list of provided regular
 // expressions. If a regular expression contains starts ':' the NamedDecl's
 // qualified name will be used for matching, otherwise its name will be used.
 inline ::clang::ast_matchers::internal::Matcher<NamedDecl>
-matchesAnyListedName(llvm::ArrayRef<std::string> NameList) {
+matchesAnyListedName(llvm::ArrayRef<StringRef> NameList) {
   return ::clang::ast_matchers::internal::makeMatcher(
       new MatchesAnyListedNameMatcher(NameList));
 }
 
 } // namespace matchers
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H

clang-tools-extra/clang-tidy/utils/OptionsUtils.h

 //===--- DanglingHandleCheck.h - clang-tidy----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_OPTIONUTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_OPTIONUTILS_H
 
-#include "../ClangTidy.h"
+#include "clang/Basic/LLVM.h"
+#include <string>
+#include <vector>
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace options {
 
 /// Parse a semicolon separated list of strings.
-std::vector<std::string> parseStringList(StringRef Option);
+std::vector<StringRef> parseStringList(StringRef Option);
+
+std::vector<StringRef> parseListPair(StringRef L, StringRef R);
 
 /// Serialize a sequence of names that can be parsed by
 /// ``parseStringList``.
-std::string serializeStringList(ArrayRef<std::string> Strings);
+std::string serializeStringList(ArrayRef<StringRef> Strings);
 
 } // namespace options
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_OPTIONUTILS_H

clang-tools-extra/clang-tidy/utils/OptionsUtils.cpp

 //===-- OptionsUtils.cpp - clang-tidy -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OptionsUtils.h"
+#include "llvm/ADT/StringExtras.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace options {
 
 static const char StringsDelimiter[] = ";";
 
-std::vector<std::string> parseStringList(StringRef Option) {
-  SmallVector<StringRef, 4> Names;
-  Option.split(Names, StringsDelimiter);
-  std::vector<std::string> Result;
-  for (StringRef &Name : Names) {
-    Name = Name.trim();
-    if (!Name.empty())
-      Result.emplace_back(Name);
+std::vector<StringRef> parseStringList(StringRef Option) {
+  Option = Option.trim().trim(StringsDelimiter);
+  if (Option.empty())
+    return {};
+  std::vector<StringRef> Result;
+  Result.reserve(Option.count(StringsDelimiter) + 1);
+  StringRef Cur;
+  while (std::tie(Cur, Option) = Option.split(StringsDelimiter),
+         !Option.empty()) {
+    Cur = Cur.trim();
+    if (!Cur.empty())
+      Result.push_back(Cur);
   }
+  Cur = Cur.trim();
+  if (!Cur.empty())
+    Result.push_back(Cur);
   return Result;
 }
 
-std::string serializeStringList(ArrayRef<std::string> Strings) {
+std::vector<StringRef> parseListPair(StringRef L, StringRef R) {
+  L = L.trim().trim(StringsDelimiter);
+  if (L.empty())
+    return parseStringList(R);
+  R = R.trim().trim(StringsDelimiter);
+  if (R.empty())
+    return parseStringList(L);
+  std::vector<StringRef> Result;
+  Result.reserve(2 + L.count(StringsDelimiter) + R.count(StringsDelimiter));
+  for (StringRef Option : {L, R}) {
+    StringRef Cur;
+    while (std::tie(Cur, Option) = Option.split(StringsDelimiter),
+           !Option.empty()) {
+      Cur = Cur.trim();
+      if (!Cur.empty())
+        Result.push_back(Cur);
+    }
+    Cur = Cur.trim();
+    if (!Cur.empty())
+      Result.push_back(Cur);
+  }
+  return Result;
+}
+
+std::string serializeStringList(ArrayRef<StringRef> Strings) {
   return llvm::join(Strings, StringsDelimiter);
 }
 
 } // namespace options
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.h

public:
   TemporaryObjectsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         Names(utils::options::parseStringList(Options.get("Names", ""))) {}
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  std::vector<std::string> Names;
+  std::vector<StringRef> Names;
 };
 
 } // namespace zircon
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ZIRCON_TEMPORARYOBJECTSCHECK_H

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.cpp

 #include <string>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace zircon {
 
-AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<std::string>, Names) {
+AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<StringRef>, Names) {
   std::string QualifiedName = Node.getQualifiedNameAsString();
   return llvm::any_of(Names,
                       [&](StringRef Name) { return QualifiedName == Name; });
 }
 
 void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) {
   // Matcher for default constructors.
   Finder->addMatcher(