[clang-tidy][WIP] create API for extracting option types.

[njames93]

Summary

Create an API as well as a command line option that dump all available check options as well as allowed values.
This infrastructure should drastically simplify 3rd party tools that would like to use clang-tidy but would prefer to handle options themselves, rather than letting users write their own .clang-tidy configuration files.

[njames93]

Fix failing test case

[njames93]

Add a test to demonstraight behaviour

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

 
 /// Fills the list of check names that are enabled when the provided
 /// filters are applied.
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options,
                                        bool AllowEnablingAnalyzerAlphaCheckers);
 
 struct NamesAndOptions {
   llvm::StringSet<> Names;
-  llvm::StringSet<> Options;
+  OptionsCollection Options;
 };
 
 NamesAndOptions
-getAllChecksAndOptions(bool AllowEnablingAnalyzerAlphaCheckers = true);
+getAllChecksAndOptions(StringRef EnabledChecks = "*",
+                       bool AllowEnablingAnalyzerAlphaCheckers = true);
 
 /// Returns the effective check-specific options.
 ///
 /// The method configures ClangTidy with the specified \p Options and collects
 /// effective options from all created checks. The returned set of options
 /// includes default check-specific options for all keys not overridden by \p
 /// Options.
 ClangTidyOptions::OptionMap

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

for (const auto &Error : Errors) {
     TUD.Diagnostics.insert(TUD.Diagnostics.end(), Diag);
   }
 
   yaml::Output YAML(OS);
   YAML << TUD;
 }
 
 NamesAndOptions
-getAllChecksAndOptions(bool AllowEnablingAnalyzerAlphaCheckers) {
+getAllChecksAndOptions(StringRef EnabledChecks,
+                       bool AllowEnablingAnalyzerAlphaCheckers) {
   NamesAndOptions Result;
   ClangTidyOptions Opts;
-  Opts.Checks = "*";
+  Opts.Checks.emplace(EnabledChecks);
   clang::tidy::ClangTidyContext Context(
       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(), Opts),
       AllowEnablingAnalyzerAlphaCheckers);
   ClangTidyCheckFactories Factories;
   for (const ClangTidyModuleRegistry::entry &Module :
        ClangTidyModuleRegistry::entries()) {
     Module.instantiate()->addCheckFactories(Factories);
   }
for (const auto &AnalyzerCheck : AnalyzerOptions::getRegisteredCheckers(
     Buffer.truncate(DefSize);
     Buffer.append(AnalyzerCheck);
     Result.Names.insert(Buffer);
   }
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 
   Context.setOptionsCollector(&Result.Options);
   for (const auto &Factory : Factories) {
+    if (Context.isCheckEnabled(Factory.getKey()))
       Factory.getValue()(Factory.getKey(), &Context);
   }
 
   return Result;
 }
 } // namespace tidy
 } // namespace clang

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

public:
 
     /// 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.
     StringRef get(StringRef LocalName, StringRef Default) const;
 
+    StringRef getList(StringRef LocalName, StringRef Default) const;
+    llvm::Optional<StringRef> getList(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, return ``None``.
     llvm::Optional<StringRef> getLocalOrGlobal(StringRef LocalName) const;
 
+    llvm::Optional<StringRef> getLocalOrGlobalList(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.
     StringRef getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
+    StringRef getLocalOrGlobalList(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<StringRef> Value = get(LocalName)) {
+      if (llvm::Optional<StringRef> Value = getInternal(
+              LocalName, std::is_signed_v<T> ? OptionType::Signed
+                                             : OptionType::Unsigned)) {
         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<StringRef> ValueOr = get(LocalName);
+      static constexpr OptionType::Type Type =
+          std::is_signed_v<T> ? OptionType::Signed : OptionType::Unsigned;
+      llvm::Optional<StringRef> ValueOr = getInternal(LocalName, Type);
       bool IsGlobal = false;
       if (!ValueOr) {
         IsGlobal = true;
-        ValueOr = getLocalOrGlobal(LocalName);
+        ValueOr = getInternalGlobal(LocalName, Type);
         if (!ValueOr)
           return None;
       }
       T Result{};
       if (!StringRef(*ValueOr).getAsInteger(10, Result))
         return Result;
       diagnoseBadIntegerOption(
           IsGlobal ? Twine(LocalName) : NamePrefix + LocalName, *ValueOr);
typeEraseMapping() const {
                             MappedItem.second);
       }
       return Result;
     }
 
     void storeInt(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                   int64_t Value) const;
 
-
+    Optional<StringRef> getInternal(StringRef Name,
+                                    OptionType::Type Type) const;
+    Optional<StringRef> getInternalGlobal(StringRef Name,
+                                          OptionType::Type Type) const;
     std::string NamePrefix;
     const ClangTidyOptions::OptionMap &CheckOptions;
     ClangTidyContext *Context;
   };
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }

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

 //===--- ClangTidyCheck.cpp - 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyCheck.h"
+#include "ClangTidyDiagnosticConsumer.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/YAMLParser.h"
 
 namespace clang {
 namespace tidy {
 

 
 ClangTidyCheck::OptionsView::OptionsView(
     StringRef CheckName, const ClangTidyOptions::OptionMap &CheckOptions,
     ClangTidyContext *Context)
     : NamePrefix((CheckName + ".").str()), CheckOptions(CheckOptions),
       Context(Context) {}
 
 llvm::Optional<StringRef>
-ClangTidyCheck::OptionsView::get(StringRef LocalName) const {
+ClangTidyCheck::OptionsView::getInternal(StringRef LocalName,
+                                         OptionType::Type Type) const {
   if (Context->getOptionsCollector())
-    Context->getOptionsCollector()->insert((NamePrefix + LocalName).str());
+    Context->getOptionsCollector()->try_emplace((NamePrefix + LocalName).str(),
+                                                Type);
   const auto &Iter = CheckOptions.find((NamePrefix + LocalName).str());
   if (Iter != CheckOptions.end())
     return StringRef(Iter->getValue().Value);
   return None;
 }
 
+llvm::Optional<StringRef>
+ClangTidyCheck::OptionsView::get(StringRef LocalName) const {
+  return getInternal(LocalName, OptionType::String);
+}
+
 static ClangTidyOptions::OptionMap::const_iterator
 findPriorityOption(const ClangTidyOptions::OptionMap &Options,
                    StringRef NamePrefix, StringRef LocalName,
-                   llvm::StringSet<> *Collector) {
+                   OptionsCollection *Collector, OptionType::Type Type) {
   if (Collector) {
-    Collector->insert((NamePrefix + LocalName).str());
-    Collector->insert(LocalName);
+    Collector->try_emplace((NamePrefix + LocalName).str(), Type);
+    Collector->try_emplace(LocalName, Type);
   }
   auto IterLocal = Options.find((NamePrefix + 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<StringRef>
-ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName) const {
+ClangTidyCheck::OptionsView::getInternalGlobal(StringRef LocalName,
+                                               OptionType::Type Type) const {
+
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName,
-                                 Context->getOptionsCollector());
+                                 Context->getOptionsCollector(), Type);
   if (Iter != CheckOptions.end())
     return StringRef(Iter->getValue().Value);
   return None;
 }
 
-static Optional<bool> getAsBool(StringRef Value,
-                                const llvm::Twine &LookupName) {
+llvm::Optional<StringRef>
+ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName) const {
+  return getInternalGlobal(LocalName, OptionType::String);
+}
+
+llvm::Optional<StringRef>
+ClangTidyCheck::OptionsView::getLocalOrGlobalList(StringRef LocalName) const {
+  return getInternalGlobal(LocalName, OptionType::List);
+}
+
+static Optional<bool> getAsBool(StringRef Value) {
 
   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<StringRef> ValueOr = get(LocalName)) {
-    if (auto Result = getAsBool(*ValueOr, NamePrefix + LocalName))
+  if (llvm::Optional<StringRef> ValueOr =
+          getInternal(LocalName, OptionType::Boolean)) {
+    if (auto Result = getAsBool(*ValueOr))
       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,
-                                 Context->getOptionsCollector());
+  auto Iter =
+      findPriorityOption(CheckOptions, NamePrefix, LocalName,
+                         Context->getOptionsCollector(), OptionType::Boolean);
   if (Iter != CheckOptions.end()) {
-    if (auto Result = getAsBool(Iter->getValue().Value, Iter->getKey()))
+    if (auto Result = getAsBool(Iter->getValue().Value))
       return Result;
     diagnoseBadBooleanOption(Iter->getKey(), Iter->getValue().Value);
   }
   return None;
 }
 
 void ClangTidyCheck::OptionsView::store(ClangTidyOptions::OptionMap &Options,
                                         StringRef LocalName,
void ClangTidyCheck::OptionsView::store<bool>(
     ClangTidyOptions::OptionMap &Options, StringRef LocalName,
     bool Value) const {
   store(Options, LocalName, Value ? StringRef("true") : StringRef("false"));
 }
 
 llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
     StringRef LocalName, ArrayRef<NameAndValue> Mapping, bool CheckGlobal,
     bool IgnoreCase) const {
-  if (!CheckGlobal && Context->getOptionsCollector())
-    Context->getOptionsCollector()->insert((NamePrefix + LocalName).str());
+  if (Context->getOptionsCollector()) {
+    auto ItemRange = llvm::make_second_range(Mapping);
+    auto Items = std::make_unique<std::vector<StringRef>>(ItemRange.begin(),
+                                                          ItemRange.end());
+    if (CheckGlobal)
+      Context->getOptionsCollector()->try_emplace(
+          LocalName, std::make_unique<std::vector<StringRef>>(*Items.get()));
+    Context->getOptionsCollector()->try_emplace((NamePrefix + LocalName).str(),
+                                                std::move(Items));
+  }
   auto Iter = CheckGlobal
                   ? findPriorityOption(CheckOptions, NamePrefix, LocalName,
-                                       Context->getOptionsCollector())
+                                       nullptr, OptionType::Custom)
                   : CheckOptions.find((NamePrefix + LocalName).str());
   if (Iter == CheckOptions.end())
     return None;
 
   StringRef Value = Iter->getValue().Value;
   StringRef Closest;
   unsigned EditDistance = 3;
   for (const auto &NameAndEnum : Mapping) {
StringRef ClangTidyCheck::OptionsView::get(StringRef LocalName,
   return get(LocalName).value_or(Default);
 }
 
 StringRef
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
                                               StringRef Default) const {
   return getLocalOrGlobal(LocalName).value_or(Default);
 }
+
+StringRef
+ClangTidyCheck::OptionsView::getLocalOrGlobalList(StringRef LocalName,
+                                                  StringRef Default) const {
+  return getLocalOrGlobalList(LocalName).value_or(Default);
+}
+
+StringRef ClangTidyCheck::OptionsView::getList(StringRef LocalName,
+                                               StringRef Default) const {
+  return getList(LocalName).value_or(Default);
+}
+
+llvm::Optional<StringRef>
+ClangTidyCheck::OptionsView::getList(StringRef LocalName) const {
+  return getInternal(LocalName, OptionType::List);
+}
 } // namespace tidy
 } // namespace clang

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

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
 #include "ClangTidyProfiling.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Regex.h"
+#include <memory>
 
 namespace clang {
 
 class ASTContext;
 class SourceManager;
 
 namespace tidy {
 class CachedGlobList;
struct ClangTidyStats {
   unsigned ErrorsIgnoredLineFilter = 0;
 
   unsigned errorsIgnored() const {
     return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
            ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
   }
 };
 
+class OptionType {
+public:
+  enum Type { String, Boolean, Unsigned, Signed, List, Custom };
+  OptionType(const OptionType &) = delete;
+  OptionType(OptionType &&) = delete;
+  OptionType &operator=(const OptionType &) = delete;
+  OptionType &operator=(OptionType &&) = delete;
+
+  explicit OptionType(Type T) : Data(nullptr, T){};
+  explicit OptionType(std::unique_ptr<std::vector<StringRef>> EnumValues)
+      : Data(EnumValues.release(), Custom) {}
+
+  Type getType() const { return Data.getInt(); }
+  bool hasEnum() const {
+    return getType() == Custom && Data.getPointer() != nullptr;
+  }
+
+  ArrayRef<StringRef> getEnumValue() const {
+    assert(hasEnum());
+    return *Data.getPointer();
+  }
+
+  ~OptionType() {
+    if (hasEnum()) {
+      delete Data.getPointer();
+    }
+  }
+
+private:
+  llvm::PointerIntPair<std::vector<StringRef> *, 3, Type> Data;
+};
+
+using OptionsCollection = llvm::StringMap<OptionType>;
+
 /// Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
DiagLevelAndFormatString getDiagLevelAndFormatString(unsigned DiagnosticID,
                                                        SourceLocation Loc) {
     return DiagLevelAndFormatString(
         static_cast<DiagnosticIDs::Level>(
             DiagEngine->getDiagnosticLevel(DiagnosticID, Loc)),
         std::string(
             DiagEngine->getDiagnosticIDs()->getDescription(DiagnosticID)));
   }
 
-  void setOptionsCollector(llvm::StringSet<> *Collector) {
+  void setOptionsCollector(OptionsCollection *Collector) {
     OptionsCollector = Collector;
   }
-  llvm::StringSet<> *getOptionsCollector() const { return OptionsCollector; }
+  OptionsCollection *getOptionsCollector() const { return OptionsCollector; }
 
 private:
   // Writes to Stats.
   friend class ClangTidyDiagnosticConsumer;
 
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
private:
   bool Profile;
   std::string ProfilePrefix;
 
   bool AllowEnablingAnalyzerAlphaCheckers;
 
   bool SelfContainedDiags;
 
   NoLintDirectiveHandler NoLintHandler;
-  llvm::StringSet<> *OptionsCollector = nullptr;
+  OptionsCollection *OptionsCollector = nullptr;
 };
 
 /// Gets the Fix attached to \p Diagnostic.
 /// If there isn't a Fix attached to the diagnostic and \p AnyFix is true, Check
 /// to see if exactly one note has a Fix and return it. Otherwise return
 /// nullptr.
 const llvm::StringMap<tooling::Replacements> *
 getFixIt(const tooling::Diagnostic &Diagnostic, bool AnyFix);

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

 namespace clang {
 namespace tidy {
 namespace abseil {
 
 StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses", "::std::basic_string"))),
+          Options.getList("StringLikeClasses", "::std::basic_string"))),
       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));

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

RewriteRuleWith<std::string> Rule = applyFirst(
                "of find() != npos"))});
   return Rule;
 }
 
 StringFindStrContainsCheck::StringFindStrContainsCheck(
     StringRef Name, ClangTidyContext *Context)
     : TransformerClangTidyCheck(Name, Context),
       StringLikeClassesOption(utils::options::parseStringList(
-          Options.get("StringLikeClasses", DefaultStringLikeClasses))),
+          Options.getList("StringLikeClasses", DefaultStringLikeClasses))),
       AbseilStringsMatchHeaderOption(Options.get(
           "AbseilStringsMatchHeader", DefaultAbseilStringsMatchHeader)) {
   setRule(
       makeRewriteRule(StringLikeClassesOption, AbseilStringsMatchHeaderOption));
 }
 
 bool StringFindStrContainsCheck::isLanguageVersionSupported(
     const LangOptions &LangOpts) const {

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

 
 namespace clang {
 namespace tidy {
 namespace android {
 
 ComparisonInTempFailureRetryCheck::ComparisonInTempFailureRetryCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      RawRetryList(Options.get("RetryMacros", "TEMP_FAILURE_RETRY")) {
+      RawRetryList(Options.getList("RetryMacros", "TEMP_FAILURE_RETRY")) {
   StringRef(RawRetryList).split(RetryMacros, ",", -1, false);
 }
 
 void ComparisonInTempFailureRetryCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "RetryMacros", RawRetryList);
 }
 

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::parseListPair(
-          "__builtin_expect;", Options.get("IgnoredFunctions", ""))) {
+          "__builtin_expect;", Options.getList("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.cpp

return callExpr(
                               hasOverloadedOperatorName("[]"))));
 }
 
 } // anonymous namespace
 
 DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
                                          ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      HandleClasses(utils::options::parseStringList(Options.get(
+      HandleClasses(utils::options::parseStringList(Options.getList(
           "HandleClasses",
           "std::basic_string_view;std::experimental::basic_string_view"))),
       IsAHandle(cxxRecordDecl(hasAnyName(HandleClasses)).bind("handle")) {}
 
 void DanglingHandleCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HandleClasses",
                 utils::options::serializeStringList(HandleClasses));
 }

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

AST_MATCHER(clang::VarDecl, hasConstantDeclaration) {
   if (Init && !Init->isValueDependent()) {
     if (Node.isConstexpr())
       return true;
     return Node.evaluateValue();
   }
   return false;
 }
 
-DynamicStaticInitializersCheck::DynamicStaticInitializersCheck(StringRef Name,
-                                                               ClangTidyContext *Context)
+DynamicStaticInitializersCheck::DynamicStaticInitializersCheck(
+    StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
   if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                   HeaderFileExtensions,
                                   utils::defaultFileExtensionDelimiters())) {
     this->configurationDiag("Invalid header file extension: '%0'")
         << RawStringHeaderFileExtensions;
   }
 }
 

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

 
 } // namespace
 
 EasilySwappableParametersCheck::EasilySwappableParametersCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MinimumLength(clampMinimumLength(
           Options.get("MinimumLength", DefaultMinimumLength))),
-      IgnoredParameterNames(optutils::parseStringList(
-          Options.get("IgnoredParameterNames", DefaultIgnoredParameterNames))),
+      IgnoredParameterNames(optutils::parseStringList(Options.getList(
+          "IgnoredParameterNames", DefaultIgnoredParameterNames))),
       IgnoredParameterTypeSuffixes(optutils::parseStringList(
-          Options.get("IgnoredParameterTypeSuffixes",
+          Options.getList("IgnoredParameterTypeSuffixes",
                           DefaultIgnoredParameterTypeSuffixes))),
       QualifiersMix(Options.get("QualifiersMix", DefaultQualifiersMix)),
       ModelImplicitConversions(Options.get("ModelImplicitConversions",
                                            DefaultModelImplicitConversions)),
       SuppressParametersUsedTogether(
           Options.get("SuppressParametersUsedTogether",
                       DefaultSuppressParametersUsedTogether)),
       NamePrefixSuffixSilenceDissimilarityTreshold(
           Options.get("NamePrefixSuffixSilenceDissimilarityTreshold",

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

static int getMessageSelectIndex(StringRef Tag) {
   return 0;
 }
 
 ReservedIdentifierCheck::ReservedIdentifierCheck(StringRef Name,
                                                  ClangTidyContext *Context)
     : RenamerClangTidyCheck(Name, Context),
       Invert(Options.get("Invert", false)),
       AllowedIdentifiers(utils::options::parseStringList(
-          Options.get("AllowedIdentifiers", ""))) {}
+          Options.getList("AllowedIdentifiers", ""))) {}
 
 void ReservedIdentifierCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   RenamerClangTidyCheck::storeOptions(Opts);
   Options.store(Opts, "Invert", Invert);
   Options.store(Opts, "AllowedIdentifiers",
                 utils::options::serializeStringList(AllowedIdentifiers));
 }
 

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

 namespace tidy {
 namespace bugprone {
 
 static constexpr int UnsignedASCIIUpperBound = 127;
 
 SignedCharMisuseCheck::SignedCharMisuseCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      CharTypdefsToIgnoreList(Options.get("CharTypdefsToIgnore", "")),
+      CharTypdefsToIgnoreList(Options.getList("CharTypdefsToIgnore", "")),
       DiagnoseSignedUnsignedCharComparisons(
           Options.get("DiagnoseSignedUnsignedCharComparisons", true)) {}
 
 void SignedCharMisuseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "CharTypdefsToIgnore", CharTypdefsToIgnoreList);
   Options.store(Opts, "DiagnoseSignedUnsignedCharComparisons",
                 DiagnoseSignedUnsignedCharComparisons);
 }

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

 StringConstructorCheck::StringConstructorCheck(StringRef Name,
                                                ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IsStringviewNullptrCheckEnabled(
           Context->isCheckEnabled("bugprone-stringview-nullptr")),
       WarnOnLargeLength(Options.get("WarnOnLargeLength", true)),
       LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)),
       StringNames(utils::options::parseStringList(
-          Options.get("StringNames", DefaultStringNames))) {}
+          Options.getList("StringNames", DefaultStringNames))) {}
 
 void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
   Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);
   Options.store(Opts, "StringNames", DefaultStringNames);
 }
 
 void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {

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

private:
   SuspiciousIncludeCheck &Check;
   Preprocessor *PP;
 };
 } // namespace
 
 SuspiciousIncludeCheck::SuspiciousIncludeCheck(StringRef Name,
                                                ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())),
       RawStringImplementationFileExtensions(Options.getLocalOrGlobal(
           "ImplementationFileExtensions",
           utils::defaultImplementationFileExtensions())) {
   if (!utils::parseFileExtensions(RawStringImplementationFileExtensions,
                                   ImplementationFileExtensions,
                                   utils::defaultFileExtensionDelimiters())) {
     this->configurationDiag("Invalid implementation file extension: '%0'")

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

 
 SuspiciousStringCompareCheck::SuspiciousStringCompareCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnImplicitComparison(Options.get("WarnOnImplicitComparison", true)),
       WarnOnLogicalNotComparison(
           Options.get("WarnOnLogicalNotComparison", false)),
       StringCompareLikeFunctions(
-          Options.get("StringCompareLikeFunctions", "")) {}
+          Options.getList("StringCompareLikeFunctions", "")) {}
 
 void SuspiciousStringCompareCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnImplicitComparison", WarnOnImplicitComparison);
   Options.store(Opts, "WarnOnLogicalNotComparison", WarnOnLogicalNotComparison);
   Options.store(Opts, "StringCompareLikeFunctions", StringCompareLikeFunctions);
 }
 

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

return InnerMatcher.matches(InstantiatedFrom ? *InstantiatedFrom : Node,
                               Finder, Builder);
 }
 
 } // namespace
 
 UnusedReturnValueCheck::UnusedReturnValueCheck(llvm::StringRef Name,
                                                ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      CheckedFunctions(Options.get("CheckedFunctions",
+      CheckedFunctions(Options.getList("CheckedFunctions",
                                        "::std::async;"
                                        "::std::launder;"
                                        "::std::remove;"
                                        "::std::remove_if;"
                                        "::std::unique;"
                                        "::std::unique_ptr::release;"
                                        "::std::basic_string::empty;"
                                        "::std::vector::empty;"
                                        "::std::back_inserter;"
                                        "::std::distance;"
                                        "::std::find;"
                                        "::std::find_if;"
                                        "::std::inserter;"
                                        "::std::lower_bound;"
                                        "::std::make_pair;"
                                        "::std::map::count;"
                                        "::std::map::find;"
                                        "::std::map::lower_bound;"
                                        "::std::multimap::equal_range;"
                                        "::std::multimap::upper_bound;"
                                        "::std::set::count;"
                                        "::std::set::find;"
                                        "::std::setfill;"
                                        "::std::setprecision;"
                                        "::std::setw;"
                                        "::std::upper_bound;"
                                        "::std::vector::at;"
                                        // C standard library
                                        "::bsearch;"
                                        "::ferror;"
                                        "::feof;"
                                        "::isalnum;"
                                        "::isalpha;"
                                        "::isblank;"
                                        "::iscntrl;"
                                        "::isdigit;"
                                        "::isgraph;"
                                        "::islower;"
                                        "::isprint;"
                                        "::ispunct;"
                                        "::isspace;"
                                        "::isupper;"
                                        "::iswalnum;"
                                        "::iswprint;"
                                        "::iswspace;"
                                        "::isxdigit;"
                                        "::memchr;"
                                        "::memcmp;"
                                        "::strcmp;"
                                        "::strcoll;"
                                        "::strncmp;"
                                        "::strpbrk;"
                                        "::strrchr;"
                                        "::strspn;"
                                        "::strstr;"
                                        "::wcscmp;"
                                        // POSIX
                                        "::access;"
                                        "::bind;"
                                        "::connect;"
                                        "::difftime;"
                                        "::dlsym;"
                                        "::fnmatch;"
                                        "::getaddrinfo;"
                                        "::getopt;"
                                        "::htonl;"
                                        "::htons;"
                                        "::iconv_open;"
                                        "::inet_addr;"
                                        "::isascii;"
                                        "::isatty;"
                                        "::mmap;"
                                        "::newlocale;"
                                        "::openat;"
                                        "::pathconf;"
                                        "::pthread_equal;"
                                        "::pthread_getspecific;"
                                        "::pthread_mutex_trylock;"
                                        "::readdir;"
                                        "::readlink;"
                                        "::recvmsg;"
                                        "::regexec;"
                                        "::scandir;"
                                        "::semget;"
                                        "::setjmp;"
                                        "::shm_open;"
                                        "::shmget;"
                                        "::sigismember;"
                                        "::strcasecmp;"
                                        "::strsignal;"
                                        "::ttyname")) {}
 
 void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "CheckedFunctions", CheckedFunctions);
 }
 
 void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
   auto FunVec = utils::options::parseStringList(CheckedFunctions);
   auto MatchedCallExpr = expr(ignoringImplicit(ignoringParenImpCasts(

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

static const char BuiltinMemCmp[] = "::std::memcmp;"
                                     "::strncmp;";
 static constexpr llvm::StringRef ComparisonOperators[] = {
     "operator==", "operator!=", "operator<",
     "operator>",  "operator<=", "operator>="};
 
 NonTrivialTypesLibcMemoryCallsCheck::NonTrivialTypesLibcMemoryCallsCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      MemSetNames(Options.get("MemSetNames", "")),
-      MemCpyNames(Options.get("MemCpyNames", "")),
-      MemCmpNames(Options.get("MemCmpNames", "")) {}
+      MemSetNames(Options.getList("MemSetNames", "")),
+      MemCpyNames(Options.getList("MemCpyNames", "")),
+      MemCmpNames(Options.getList("MemCmpNames", "")) {}
 
 void NonTrivialTypesLibcMemoryCallsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MemSetNames", MemSetNames);
   Options.store(Opts, "MemCpyNames", MemCpyNames);
   Options.store(Opts, "MemCmpNames", MemCmpNames);
 }
 

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

: ClangTidyCheck(Name, Context),
           Options.get("WarnOnIntegerNarrowingConversion", true)),
       WarnOnIntegerToFloatingPointNarrowingConversion(
           Options.get("WarnOnIntegerToFloatingPointNarrowingConversion", true)),
       WarnOnFloatingPointNarrowingConversion(
           Options.get("WarnOnFloatingPointNarrowingConversion", true)),
       WarnWithinTemplateInstantiation(
           Options.get("WarnWithinTemplateInstantiation", false)),
       WarnOnEquivalentBitWidth(Options.get("WarnOnEquivalentBitWidth", true)),
-      IgnoreConversionFromTypes(Options.get("IgnoreConversionFromTypes", "")),
+      IgnoreConversionFromTypes(
+          Options.getList("IgnoreConversionFromTypes", "")),
       PedanticMode(Options.get("PedanticMode", false)) {}
 
 void NarrowingConversionsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnIntegerNarrowingConversion",
                 WarnOnIntegerNarrowingConversion);
   Options.store(Opts, "WarnOnIntegerToFloatingPointNarrowingConversion",
                 WarnOnIntegerToFloatingPointNarrowingConversion);

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

 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines/no-malloc.html
 class NoMallocCheck : public ClangTidyCheck {
 public:
   /// Construct Checker and read in configuration for function names.
   NoMallocCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        AllocList(Options.get("Allocations", "::malloc;::calloc")),
-        ReallocList(Options.get("Reallocations", "::realloc")),
-        DeallocList(Options.get("Deallocations", "::free")) {}
+        AllocList(Options.getList("Allocations", "::malloc;::calloc")),
+        ReallocList(Options.getList("Reallocations", "::realloc")),
+        DeallocList(Options.getList("Deallocations", "::free")) {}
 
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
 
   /// Make configuration of checker discoverable.
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 

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

 /// nature of it whenever possible.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines/owning-memory.html
 class OwningMemoryCheck : public ClangTidyCheck {
 public:
   OwningMemoryCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        LegacyResourceProducers(Options.get(
+        LegacyResourceProducers(Options.getList(
             "LegacyResourceProducers", "::malloc;::aligned_alloc;::realloc;"
                                        "::calloc;::fopen;::freopen;::tmpfile")),
-        LegacyResourceConsumers(Options.get(
+        LegacyResourceConsumers(Options.getList(
             "LegacyResourceConsumers", "::free;::realloc;::freopen;::fclose")) {
   }
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
 
   /// Make configuration of checker discoverable.
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;

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

 namespace clang {
 namespace tidy {
 namespace google {
 namespace readability {
 
 GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
   if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                   HeaderFileExtensions,
                                   utils::defaultFileExtensionDelimiters())) {
     this->configurationDiag("Invalid header file extension: '%0'")
         << RawStringHeaderFileExtensions;
   }
 }

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

 namespace clang {
 namespace tidy {
 namespace google {
 namespace build {
 
 UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
   if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                   HeaderFileExtensions,
                                   utils::defaultFileExtensionDelimiters())) {
     this->configurationDiag("Invalid header file extension: '%0'")
         << RawStringHeaderFileExtensions;
   }
 }

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

 }
 
 } // namespace
 
 DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       UseHeaderFileExtension(Options.get("UseHeaderFileExtension", true)),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
   if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                   HeaderFileExtensions,
                                   utils::defaultFileExtensionDelimiters())) {
     this->configurationDiag("Invalid header file extension: '%0'")
         << RawStringHeaderFileExtensions;
   }
 }

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

const auto DefaultEmplacyFunctions =
     "unordered_multiset::emplace; unordered_multiset::emplace_hint;"
     "unordered_multimap::emplace; unordered_multimap::emplace_hint;"
     "stack::emplace; queue::emplace; priority_queue::emplace";
 } // namespace
 
 UseEmplaceCheck::UseEmplaceCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), IgnoreImplicitConstructors(Options.get(
                                          "IgnoreImplicitConstructors", false)),
-      ContainersWithPushBack(utils::options::parseStringList(Options.get(
+      ContainersWithPushBack(utils::options::parseStringList(Options.getList(
           "ContainersWithPushBack", DefaultContainersWithPushBack))),
       ContainersWithPush(utils::options::parseStringList(
           Options.get("ContainersWithPush", DefaultContainersWithPush))),
-      ContainersWithPushFront(utils::options::parseStringList(Options.get(
+      ContainersWithPushFront(utils::options::parseStringList(Options.getList(
           "ContainersWithPushFront", DefaultContainersWithPushFront))),
       SmartPointers(utils::options::parseStringList(
-          Options.get("SmartPointers", DefaultSmartPointers))),
+          Options.getList("SmartPointers", DefaultSmartPointers))),
       TupleTypes(utils::options::parseStringList(
-          Options.get("TupleTypes", DefaultTupleTypes))),
+          Options.getList("TupleTypes", DefaultTupleTypes))),
       TupleMakeFunctions(utils::options::parseStringList(
-          Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))),
+          Options.getList("TupleMakeFunctions", DefaultTupleMakeFunctions))),
       EmplacyFunctions(utils::options::parseStringList(
-          Options.get("EmplacyFunctions", DefaultEmplacyFunctions))) {}
+          Options.getList("EmplacyFunctions", DefaultEmplacyFunctions))) {}
 
 void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   // FIXME: Bunch of functionality that could be easily added:
   // + 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(

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

constexpr char DefaultForbiddenSuperClassNames[] =
     "UIActionSheet;"
     "UIAlertView;"
     "UIImagePickerController;"
     "UITextInputMode;"
     "UIWebView";
 
 } // namespace
 
-ForbiddenSubclassingCheck::ForbiddenSubclassingCheck(
-    StringRef Name,
+ForbiddenSubclassingCheck::ForbiddenSubclassingCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      ForbiddenSuperClassNames(
-          utils::options::parseStringList(
-              Options.get("ClassNames", DefaultForbiddenSuperClassNames))) {
-}
+      ForbiddenSuperClassNames(utils::options::parseStringList(
+          Options.getList("ClassNames", DefaultForbiddenSuperClassNames))) {}
 
 void ForbiddenSubclassingCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       objcInterfaceDecl(
           isDerivedFrom(objcInterfaceDecl(hasAnyName(ForbiddenSuperClassNames))
                             .bind("superclass")))
           .bind("subclass"),
       this);

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

 }
 
 } // namespace
 
 FasterStringFindCheck::FasterStringFindCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses",
+          Options.getList("StringLikeClasses",
                           "::std::basic_string;::std::basic_string_view"))) {}
 
 void FasterStringFindCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringLikeClasses",
                 utils::options::serializeStringList(StringLikeClasses));
 }
 
 void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
   const auto SingleChar =

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

 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", false)),
-      AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
+      AllowedTypes(utils::options::parseStringList(
+          Options.getList("AllowedTypes", ""))) {}
 
 void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnAllAutoCopies", WarnOnAllAutoCopies);
   Options.store(Opts, "AllowedTypes",
                 utils::options::serializeStringList(AllowedTypes));
 }
 
 void ForRangeCopyCheck::registerMatchers(MatchFinder *Finder) {

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

 }
 
 } // namespace
 
 InefficientVectorOperationCheck::InefficientVectorOperationCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       VectorLikeClasses(utils::options::parseStringList(
-          Options.get("VectorLikeClasses", "::std::vector"))),
+          Options.getList("VectorLikeClasses", "::std::vector"))),
       EnableProto(Options.getLocalOrGlobal("EnableProto", false)) {}
 
 void InefficientVectorOperationCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "VectorLikeClasses",
                 utils::options::serializeStringList(VectorLikeClasses));
   Options.store(Opts, "EnableProto", EnableProto);
 }

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

 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 NoAutomaticMoveCheck::NoAutomaticMoveCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
+      AllowedTypes(utils::options::parseStringList(
+          Options.getList("AllowedTypes", ""))) {}
 
 void NoAutomaticMoveCheck::registerMatchers(MatchFinder *Finder) {
   const auto ConstLocalVariable =
       varDecl(hasLocalStorage(), unless(hasType(lValueReferenceType())),
               hasType(qualType(
                   isConstQualified(),
                   hasCanonicalType(matchers::isExpensiveToCopy()),
                   unless(hasDeclaration(namedDecl(

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

 }
 
 } // namespace
 
 UnnecessaryCopyInitialization::UnnecessaryCopyInitialization(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))),
+          utils::options::parseStringList(Options.getList("AllowedTypes", ""))),
       ExcludedContainerTypes(utils::options::parseStringList(
-          Options.get("ExcludedContainerTypes", ""))) {}
+          Options.getList("ExcludedContainerTypes", ""))) {}
 
 void UnnecessaryCopyInitialization::registerMatchers(MatchFinder *Finder) {
   auto LocalVarCopiedFrom = [this](const internal::Matcher<Expr> &CopyCtorArg) {
     return compoundStmt(
                forEachDescendant(
                    declStmt(
                        unless(has(decompositionDecl())),
                        has(varDecl(hasLocalStorage(),

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

 } // namespace
 
 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       Inserter(Options.getLocalOrGlobal("IncludeStyle",
                                         utils::IncludeSorter::IS_LLVM),
                areDiagsSelfContained()),
-      AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
+      AllowedTypes(utils::options::parseStringList(
+          Options.getList("AllowedTypes", ""))) {}
 
 void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
   const auto ExpensiveValueParamDecl = parmVarDecl(
       hasType(qualType(
           hasCanonicalType(matchers::isExpensiveToCopy()),
           unless(anyOf(hasCanonicalType(referenceType()),
                        hasDeclaration(namedDecl(
                            matchers::matchesAnyListedName(AllowedTypes))))))),

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

 MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreAllFloatingPointValues(
           Options.get("IgnoreAllFloatingPointValues", false)),
       IgnoreBitFieldsWidths(Options.get("IgnoreBitFieldsWidths", true)),
       IgnorePowersOf2IntegerValues(
           Options.get("IgnorePowersOf2IntegerValues", false)),
       RawIgnoredIntegerValues(
-          Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues)),
-      RawIgnoredFloatingPointValues(Options.get(
+          Options.getList("IgnoredIntegerValues", DefaultIgnoredIntegerValues)),
+      RawIgnoredFloatingPointValues(Options.getList(
           "IgnoredFloatingPointValues", DefaultIgnoredFloatingPointValues)) {
   // Process the set of ignored integer values.
   const std::vector<StringRef> IgnoredIntegerValuesInput =
       utils::options::parseStringList(RawIgnoredIntegerValues);
   IgnoredIntegerValues.resize(IgnoredIntegerValuesInput.size());
   llvm::transform(IgnoredIntegerValuesInput, IgnoredIntegerValues.begin(),
                   [](StringRef Value) {
                     int64_t Res;

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

if (B.isInvalid() || E.isInvalid())
     return llvm::None;
   return SourceRange(B, E);
 }
 
 RedundantStringInitCheck::RedundantStringInitCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringNames(utils::options::parseStringList(
-          Options.get("StringNames", DefaultStringNames))) {}
+          Options.getList("StringNames", DefaultStringNames))) {}
 
 void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringNames", DefaultStringNames);
 }
 
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
   const auto HasStringTypeName = hasAnyName(StringNames);
   const auto HasStringCtorName = hasAnyName(removeNamespaces(StringNames));

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

 namespace tidy {
 namespace readability {
 
 static const char KDefaultTypes[] =
     "::std::basic_string;::std::basic_string_view;::std::vector;::std::array";
 
 SimplifySubscriptExprCheck::SimplifySubscriptExprCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), Types(utils::options::parseStringList(
-                                         Options.get("Types", KDefaultTypes))) {
-}
+    : ClangTidyCheck(Name, Context),
+      Types(utils::options::parseStringList(
+          Options.getList("Types", KDefaultTypes))) {}
 
 void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
   const auto TypesMatcher = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(cxxRecordDecl(hasAnyName(Types)))));
 
   Finder->addMatcher(
       arraySubscriptExpr(hasBase(
           cxxMemberCallExpr(

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

for (std::size_t Idx = 0; Idx < HeuristicCount; ++Idx) {
     if (GetToggleOpt(H))
       AppliedHeuristics.emplace_back(H);
     ConfiguredBounds.emplace_back(
         std::make_pair(GetBoundOpt(H, BoundKind::DissimilarBelow),
                        GetBoundOpt(H, BoundKind::SimilarAbove)));
   }
 
   for (StringRef Abbreviation : optutils::parseStringList(
-           Options.get("Abbreviations", DefaultAbbreviations))) {
+           Options.getList("Abbreviations", DefaultAbbreviations))) {
     auto KeyAndValue = Abbreviation.split("=");
     assert(!KeyAndValue.first.empty() && !KeyAndValue.second.empty());
     AbbreviationDictionary.insert(
         std::make_pair(KeyAndValue.first, KeyAndValue.second.str()));
   }
 }
 
 void SuspiciousCallArgumentCheck::storeOptions(

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

 }
 
 } // namespace
 
 UppercaseLiteralSuffixCheck::UppercaseLiteralSuffixCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       NewSuffixes(
-          utils::options::parseStringList(Options.get("NewSuffixes", ""))),
+          utils::options::parseStringList(Options.getList("NewSuffixes", ""))),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
 void UppercaseLiteralSuffixCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NewSuffixes",
                 utils::options::serializeStringList(NewSuffixes));
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyMain.h"
 #include "../ClangTidy.h"
 #include "../ClangTidyForceLinker.h"
 #include "../GlobList.h"
 #include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Syntax/Nodes.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace clang::tooling;
 using namespace llvm;
 
 static cl::OptionCategory ClangTidyCategory("clang-tidy options");
 
 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 static cl::extrahelp ClangTidyHelp(R"(
)"),
                               cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> VerifyConfig("verify-config", cl::desc(R"(
 Check the config files to ensure each check and
 option is recognized.
 )"),
                                   cl::init(false), cl::cat(ClangTidyCategory));
 
+static cl::opt<bool> ListOptions("list-options", cl::desc(R"(
+Print the available options for the enabled checks.
+)"),
+                                 cl::init(false), cl::cat(ClangTidyCategory));
+
+static cl::opt<bool> ListAllOptions("list-all-options", cl::desc(R"(
+Print the available options for all supported checks.
+)"),
+                                    cl::init(false),
+                                    cl::cat(ClangTidyCategory));
+
 namespace clang {
 namespace tidy {
 
 static void printStats(const ClangTidyStats &Stats) {
   if (Stats.errorsIgnored()) {
     llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
     StringRef Separator = "";
     if (Stats.ErrorsIgnoredNonUserCode) {
getVfsFromFile(const std::string &OverlayFile,
   if (!FS) {
     llvm::errs() << "Error: invalid virtual filesystem overlay file '"
                  << OverlayFile << "'.\n";
     return nullptr;
   }
   return FS;
 }
 
-static StringRef closest(StringRef Value, const StringSet<> &Allowed) {
+template <typename Range>
+static StringRef closest(StringRef Value, Range &&Allowed) {
   unsigned MaxEdit = 5U;
   StringRef Closest;
-  for (auto Item : Allowed.keys()) {
+  for (StringRef Item : Allowed) {
     unsigned Cur = Value.edit_distance_insensitive(Item, true, MaxEdit);
     if (Cur < MaxEdit) {
       Closest = Item;
       MaxEdit = Cur;
     }
   }
   return Closest;
 }
if (Cur.contains('*')) {
             << VerifyConfigWarningEnd;
       }
     } else {
       if (AllChecks.contains(Cur))
         continue;
       AnyInvalid = true;
       llvm::raw_ostream &Output = llvm::WithColor::warning(llvm::errs(), Source)
                                   << "unknown check '" << Cur << '\'';
-      llvm::StringRef Closest = closest(Cur, AllChecks);
+      llvm::StringRef Closest = closest(Cur, AllChecks.keys());
       if (!Closest.empty())
         Output << "; did you mean '" << Closest << '\'';
       Output << VerifyConfigWarningEnd;
     }
   }
   return AnyInvalid;
 }
 
+static bool sortOptCollection(const OptionsCollection::MapEntryTy *L,
+                              const OptionsCollection::MapEntryTy *R) {
+  return L->getKey() < R->getKey();
+}
+
 int clangTidyMain(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
 
   // Enable help for -load option, if plugins are enabled.
   if (cl::Option *LoadOpt = cl::getRegisteredOptions().lookup("load"))
     LoadOpt->addCategory(ClangTidyCategory);
 
   llvm::Expected<CommonOptionsParser> OptionsParser =
if (ListChecks) {
     }
     llvm::outs() << "Enabled checks:";
     for (const auto &CheckName : EnabledChecks)
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
+  if (ListOptions || ListAllOptions) {
+    NamesAndOptions Valid = getAllChecksAndOptions(
+        ListAllOptions
+            ? "*"
+            : OptionsProvider->getOptions(FileName).Checks.value_or(""),
+        AllowEnablingAnalyzerAlphaCheckers);
+    std::vector<OptionsCollection::MapEntryTy *> Items;
+    std::vector<OptionsCollection::MapEntryTy *> GlobalItems;
+    for (auto &Item : Valid.Options) {
+      if (Item.getKey().contains('.'))
+        Items.push_back(&Item);
+      else
+        GlobalItems.push_back(&Item);
+    }
+    if (GlobalItems.empty() && Items.empty()) {
+      llvm::errs() << "No options available.\n";
+      return 1;
+    }
+    llvm::sort(Items, &sortOptCollection);
+    llvm::sort(GlobalItems, &sortOptCollection);
+
+    if (GlobalItems.empty() && Items.empty()) {
+      llvm::errs() << "No options available.\n";
+      return 1;
+    }
+
+    // FIXME: explore creating a json schema output format.
+    auto Output = [](llvm::raw_ostream &O, const OptionType &Type) {
+      switch (Type.getType()) {
+      case OptionType::String:
+        O << "String";
+        break;
+      case OptionType::Boolean:
+        O << "Bool";
+        break;
+      case OptionType::Unsigned:
+        O << "Unsigned integer";
+        break;
+      case OptionType::Signed:
+        O << "Signed integer";
+        break;
+      case OptionType::Custom:
+        O << "Enumeration";
+        if (Type.hasEnum()) {
+          O << '<';
+          auto Values = Type.getEnumValue();
+          if (!Values.empty()) {
+            O << Values.front();
+            for (auto Item : Values.drop_front()) {
+              O << '|' << Item;
+            }
+          }
+          O << '>';
+        }
+        break;
+      case OptionType::List:
+        O << "List";
+        break;
+      }
+    };
+    if (!GlobalItems.empty()) {
+      llvm::outs() << "Global Options:\n";
+      for (const auto *Item : GlobalItems) {
+        llvm::outs() << " - " << Item->getKey() << ": ";
+        Output(llvm::outs(), Item->getValue());
+        llvm::outs() << "\n";
+      }
+    }
+
+    if (!Items.empty()) {
+      llvm::outs() << "Check Options:\n";
+      StringRef Current = "**INVALID_CHECK**";
+      for (const auto *Item : Items) {
+        StringRef Name = Item->getKey();
+        if (!Name.consume_front(Current)) {
+          auto Idx = Name.find('.');
+          assert(Idx != StringRef::npos);
+          Current = Name.take_front(Idx + 1);
+          Name = Name.substr(Idx + 1);
+          llvm::outs() << " - " << Current.drop_back() << ":\n";
+        }
+        llvm::outs() << "   - " << Name << ": ";
+        Output(llvm::outs(), Item->getValue());
+        llvm::outs() << "\n";
+      }
+    }
+    return 0;
+  }
+
   if (DumpConfig) {
     EffectiveOptions.CheckOptions =
         getCheckOptions(EffectiveOptions, AllowEnablingAnalyzerAlphaCheckers);
     llvm::outs() << configurationAsText(ClangTidyOptions::getDefaults().merge(
                         EffectiveOptions, 0))
                  << "\n";
     return 0;
   }
 
   if (VerifyConfig) {
     std::vector<ClangTidyOptionsProvider::OptionsSource> RawOptions =
         OptionsProvider->getRawOptions(FileName);
     NamesAndOptions Valid =
-        getAllChecksAndOptions(AllowEnablingAnalyzerAlphaCheckers);
+        getAllChecksAndOptions("*", AllowEnablingAnalyzerAlphaCheckers);
     bool AnyInvalid = false;
     for (const std::pair<ClangTidyOptions, std::string> &OptionWithSource :
          RawOptions) {
       const ClangTidyOptions &Opts = OptionWithSource.first;
       if (Opts.Checks)
         AnyInvalid |=
             verifyChecks(Valid.Names, *Opts.Checks, OptionWithSource.second);
 
       for (auto Key : Opts.CheckOptions.keys()) {
-        if (Valid.Options.contains(Key))
+        if (Valid.Options.count(Key) != 0)
           continue;
         AnyInvalid = true;
         auto &Output =
             llvm::WithColor::warning(llvm::errs(), OptionWithSource.second)
             << "unknown check option '" << Key << '\'';
-        llvm::StringRef Closest = closest(Key, Valid.Options);
+        llvm::StringRef Closest = closest(Key, Valid.Options.keys());
         if (!Closest.empty())
           Output << "; did you mean '" << Closest << '\'';
         Output << VerifyConfigWarningEnd;
       }
     }
     if (AnyInvalid)
       return 1;
     llvm::outs() << "No config errors detected.\n";

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

 ///     "." prefix). ";h;hh;hpp;hxx" by default.
 ///
 ///     For extension-less header files, using an empty string or leaving an
 ///     empty string between ";" if there are other filename extensions.
 class HeaderGuardCheck : public ClangTidyCheck {
 public:
   HeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+        RawStringHeaderFileExtensions(Options.getLocalOrGlobalList(
             "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
     utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                HeaderFileExtensions,
                                utils::defaultFileExtensionDelimiters());
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;