From 8f73c4432b5fa8510c99a5053c07dc70a610e1fb Mon Sep 17 00:00:00 2001 From: Nico Weber Date: Sun, 28 Jun 2020 21:49:07 -0400 Subject: [PATCH] Revert "[clang-tidy] Reworked enum options handling(again)" This reverts commit b9306fd042ce1c11d84f05d2124dfdc65b8331fe and follow-up 42a51587c79a673045aec3586f4070630e5e7af3. It seems to build check-clang-tools on macOS, see comments on https://reviews.llvm.org/D82188 --- clang-tools-extra/clang-tidy/ClangTidyCheck.cpp | 18 ++--- clang-tools-extra/clang-tidy/ClangTidyCheck.h | 80 +++++++++------------- .../abseil/StringFindStartswithCheck.cpp | 4 +- .../cppcoreguidelines/InitVariablesCheck.cpp | 4 +- .../ProBoundsConstantArrayIndexCheck.cpp | 1 + .../clang-tidy/modernize/LoopConvertCheck.cpp | 54 +++++++-------- .../clang-tidy/modernize/MakeSmartPtrCheck.cpp | 4 +- .../clang-tidy/modernize/PassByValueCheck.cpp | 4 +- .../clang-tidy/modernize/ReplaceAutoPtrCheck.cpp | 4 +- .../modernize/ReplaceRandomShuffleCheck.cpp | 4 +- .../performance/MoveConstructorInitCheck.cpp | 4 +- .../performance/TypePromotionInMathFnCheck.cpp | 4 +- .../performance/UnnecessaryValueParamCheck.cpp | 4 +- .../readability/IdentifierNamingCheck.cpp | 34 ++++----- .../clang-tidy/readability/IdentifierNamingCheck.h | 7 -- .../clang-tidy/utils/IncludeSorter.cpp | 13 ++-- clang-tools-extra/clang-tidy/utils/IncludeSorter.h | 7 +- .../clang-tidy/utils/TransformerClangTidyCheck.cpp | 5 +- .../unittests/clang-tidy/ClangTidyOptionsTest.cpp | 48 ++++++------- 19 files changed, 139 insertions(+), 164 deletions(-) diff --git a/clang-tools-extra/clang-tidy/ClangTidyCheck.cpp b/clang-tools-extra/clang-tidy/ClangTidyCheck.cpp index 39c0499..7ddf054 100644 --- a/clang-tools-extra/clang-tidy/ClangTidyCheck.cpp +++ b/clang-tools-extra/clang-tidy/ClangTidyCheck.cpp @@ -158,7 +158,7 @@ void ClangTidyCheck::OptionsView::store(ClangTidyOptions::OptionMap &Options, } llvm::Expected ClangTidyCheck::OptionsView::getEnumInt( - StringRef LocalName, ArrayRef> Mapping, + StringRef LocalName, ArrayRef> Mapping, bool CheckGlobal, bool IgnoreCase) { auto Iter = CheckOptions.find((NamePrefix + LocalName).str()); if (CheckGlobal && Iter == CheckOptions.end()) @@ -171,19 +171,19 @@ llvm::Expected ClangTidyCheck::OptionsView::getEnumInt( unsigned EditDistance = -1; for (const auto &NameAndEnum : Mapping) { if (IgnoreCase) { - if (Value.equals_lower(NameAndEnum.second)) - return NameAndEnum.first; - } else if (Value.equals(NameAndEnum.second)) { - return NameAndEnum.first; - } else if (Value.equals_lower(NameAndEnum.second)) { - Closest = NameAndEnum.second; + if (Value.equals_lower(NameAndEnum.first)) + return NameAndEnum.second; + } else if (Value.equals(NameAndEnum.first)) { + return NameAndEnum.second; + } else if (Value.equals_lower(NameAndEnum.first)) { + Closest = NameAndEnum.first; EditDistance = 0; continue; } - unsigned Distance = Value.edit_distance(NameAndEnum.second); + unsigned Distance = Value.edit_distance(NameAndEnum.first); if (Distance < EditDistance) { EditDistance = Distance; - Closest = NameAndEnum.second; + Closest = NameAndEnum.first; } } if (EditDistance < 3) diff --git a/clang-tools-extra/clang-tidy/ClangTidyCheck.h b/clang-tools-extra/clang-tidy/ClangTidyCheck.h index 84ad16c..84438c2 100644 --- a/clang-tools-extra/clang-tidy/ClangTidyCheck.h +++ b/clang-tools-extra/clang-tidy/ClangTidyCheck.h @@ -27,13 +27,6 @@ class CompilerInstance; namespace tidy { -/// This class should be specialized by any enum type that needs to be converted -/// to and from an \ref llvm::StringRef. -template struct OptionEnumMapping { - // Specializations of this struct must implement this function. - static ArrayRef> getEnumMapping() = delete; -}; - template class OptionError : public llvm::ErrorInfo { std::error_code convertToErrorCode() const override { return llvm::inconvertibleErrorCode(); @@ -320,38 +313,36 @@ public: } /// Read a named option from the ``Context`` and parse it as an - /// enum type ``T``. + /// enum type ``T`` using the \p Mapping provided. If \p IgnoreCase is set, + /// it will search the mapping ignoring the case. /// /// Reads the option with the check-local name \p LocalName from the /// ``CheckOptions``. If the corresponding key is not present, returns a /// ``MissingOptionError``. If the key can't be parsed as a ``T`` returns a /// ``UnparseableEnumOptionError``. - /// - /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to - /// supply the mapping required to convert between ``T`` and a string. template std::enable_if_t::value, llvm::Expected> - get(StringRef LocalName, bool IgnoreCase = false) { - if (llvm::Expected ValueOr = - getEnumInt(LocalName, typeEraseMapping(), false, IgnoreCase)) + get(StringRef LocalName, ArrayRef> Mapping, + bool IgnoreCase = false) { + if (llvm::Expected ValueOr = getEnumInt( + LocalName, typeEraseMapping(Mapping), false, IgnoreCase)) return static_cast(*ValueOr); else return std::move(ValueOr.takeError()); } /// Read a named option from the ``Context`` and parse it as an - /// enum type ``T``. + /// enum type ``T`` using the \p Mapping provided. If \p IgnoreCase is set, + /// it will search the mapping ignoring the case. /// /// Reads the option with the check-local name \p LocalName from the /// ``CheckOptions``. If the corresponding key is not present or it can't be /// parsed as a ``T``, returns \p Default. - /// - /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to - /// supply the mapping required to convert between ``T`` and a string. template std::enable_if_t::value, T> - get(StringRef LocalName, T Default, bool IgnoreCase = false) { - if (auto ValueOr = get(LocalName, IgnoreCase)) + get(StringRef LocalName, ArrayRef> Mapping, + T Default, bool IgnoreCase = false) { + if (auto ValueOr = get(LocalName, Mapping, IgnoreCase)) return *ValueOr; else logErrToStdErr(ValueOr.takeError()); @@ -359,41 +350,40 @@ public: } /// Read a named option from the ``Context`` and parse it as an - /// enum type ``T``. + /// enum type ``T`` using the \p Mapping provided. If \p IgnoreCase is set, + /// it will search the mapping ignoring the case. /// /// 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 a ``MissingOptionError``. If the key can't be /// parsed as a ``T`` returns a ``UnparseableEnumOptionError``. - /// - /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to - /// supply the mapping required to convert between ``T`` and a string. template std::enable_if_t::value, llvm::Expected> getLocalOrGlobal(StringRef LocalName, + ArrayRef> Mapping, bool IgnoreCase = false) { - if (llvm::Expected ValueOr = - getEnumInt(LocalName, typeEraseMapping(), true, IgnoreCase)) + if (llvm::Expected ValueOr = getEnumInt( + LocalName, typeEraseMapping(Mapping), true, IgnoreCase)) return static_cast(*ValueOr); else return std::move(ValueOr.takeError()); } /// Read a named option from the ``Context`` and parse it as an - /// enum type ``T``. + /// enum type ``T`` using the \p Mapping provided. If \p IgnoreCase is set, + /// it will search the mapping ignoring the case. /// /// 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 or it can't be parsed as a ``T``, returns \p Default. - /// - /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to - /// supply the mapping required to convert between ``T`` and a string. template std::enable_if_t::value, T> - getLocalOrGlobal(StringRef LocalName, T Default, bool IgnoreCase = false) { - if (auto ValueOr = getLocalOrGlobal(LocalName, IgnoreCase)) + getLocalOrGlobal(StringRef LocalName, + ArrayRef> Mapping, T Default, + bool IgnoreCase = false) { + if (auto ValueOr = getLocalOrGlobal(LocalName, Mapping, IgnoreCase)) return *ValueOr; else logErrToStdErr(ValueOr.takeError()); @@ -411,25 +401,21 @@ public: int64_t Value) const; /// Stores an option with the check-local name \p LocalName as the string - /// representation of the Enum \p Value to \p Options. - /// - /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to - /// supply the mapping required to convert between ``T`` and a string. + /// representation of the Enum \p Value using the \p Mapping to \p Options. template std::enable_if_t::value> - store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, T Value) { - ArrayRef> Mapping = - OptionEnumMapping::getEnumMapping(); + store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, T Value, + ArrayRef> Mapping) { auto Iter = llvm::find_if( - Mapping, [&](const std::pair &NameAndEnum) { - return NameAndEnum.first == Value; + Mapping, [&](const std::pair &NameAndEnum) { + return NameAndEnum.second == Value; }); assert(Iter != Mapping.end() && "Unknown Case Value"); - store(Options, LocalName, Iter->second); + store(Options, LocalName, Iter->first); } private: - using NameAndValue = std::pair; + using NameAndValue = std::pair; llvm::Expected getEnumInt(StringRef LocalName, ArrayRef Mapping, @@ -437,14 +423,12 @@ public: template std::enable_if_t::value, std::vector> - typeEraseMapping() { - ArrayRef> Mapping = - OptionEnumMapping::getEnumMapping(); + typeEraseMapping(ArrayRef> Mapping) { std::vector Result; Result.reserve(Mapping.size()); for (auto &MappedItem : Mapping) { - Result.emplace_back(static_cast(MappedItem.first), - MappedItem.second); + Result.emplace_back(MappedItem.first, + static_cast(MappedItem.second)); } return Result; } diff --git a/clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp b/clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp index 7a8b71d..9539e28 100644 --- a/clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp +++ b/clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp @@ -27,6 +27,7 @@ StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name, StringLikeClasses(utils::options::parseStringList( Options.get("StringLikeClasses", "::std::basic_string"))), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)), AbseilStringsMatchHeader( Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {} @@ -121,7 +122,8 @@ void StringFindStartswithCheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { Options.store(Opts, "StringLikeClasses", utils::options::serializeStringList(StringLikeClasses)); - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader); } diff --git a/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp b/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp index 0864bb5..608df8a 100644 --- a/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp +++ b/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp @@ -25,11 +25,13 @@ InitVariablesCheck::InitVariablesCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)), MathHeader(Options.get("MathHeader", "math.h")) {} void InitVariablesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); Options.store(Opts, "MathHeader", MathHeader); } diff --git a/clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp b/clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp index dd0bedd..b485112 100644 --- a/clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp +++ b/clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp @@ -22,6 +22,7 @@ ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck( StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)) {} void ProBoundsConstantArrayIndexCheck::storeOptions( diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp index 720d43a2..dd18d86 100644 --- a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp @@ -28,31 +28,6 @@ using namespace llvm; namespace clang { namespace tidy { - -template <> struct OptionEnumMapping { - static llvm::ArrayRef> - getEnumMapping() { - static constexpr std::pair - Mapping[] = {{modernize::Confidence::CL_Reasonable, "reasonable"}, - {modernize::Confidence::CL_Safe, "safe"}, - {modernize::Confidence::CL_Risky, "risky"}}; - return makeArrayRef(Mapping); - } -}; - -template <> struct OptionEnumMapping { - static llvm::ArrayRef< - std::pair> - getEnumMapping() { - static constexpr std::pair - Mapping[] = {{modernize::VariableNamer::NS_CamelCase, "CamelCase"}, - {modernize::VariableNamer::NS_CamelBack, "camelBack"}, - {modernize::VariableNamer::NS_LowerCase, "lower_case"}, - {modernize::VariableNamer::NS_UpperCase, "UPPER_CASE"}}; - return makeArrayRef(Mapping); - } -}; - namespace modernize { static const char LoopNameArray[] = "forLoopArray"; @@ -69,6 +44,25 @@ static const char EndVarName[] = "endVar"; static const char DerefByValueResultName[] = "derefByValueResult"; static const char DerefByRefResultName[] = "derefByRefResult"; +static ArrayRef> +getConfidenceMapping() { + static constexpr std::pair Mapping[] = { + {"reasonable", Confidence::CL_Reasonable}, + {"safe", Confidence::CL_Safe}, + {"risky", Confidence::CL_Risky}}; + return makeArrayRef(Mapping); +} + +static ArrayRef> +getStyleMapping() { + static constexpr std::pair Mapping[] = + {{"CamelCase", VariableNamer::NS_CamelCase}, + {"camelBack", VariableNamer::NS_CamelBack}, + {"lower_case", VariableNamer::NS_LowerCase}, + {"UPPER_CASE", VariableNamer::NS_UpperCase}}; + return makeArrayRef(Mapping); +} + // shared matchers static const TypeMatcher AnyType() { return anything(); } @@ -483,13 +477,15 @@ LoopConvertCheck::RangeDescriptor::RangeDescriptor() LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo), MaxCopySize(Options.get("MaxCopySize", 16ULL)), - MinConfidence(Options.get("MinConfidence", Confidence::CL_Reasonable)), - NamingStyle(Options.get("NamingStyle", VariableNamer::NS_CamelCase)) {} + MinConfidence(Options.get("MinConfidence", getConfidenceMapping(), + Confidence::CL_Reasonable)), + NamingStyle(Options.get("NamingStyle", getStyleMapping(), + VariableNamer::NS_CamelCase)) {} void LoopConvertCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { Options.store(Opts, "MaxCopySize", std::to_string(MaxCopySize)); - Options.store(Opts, "MinConfidence", MinConfidence); - Options.store(Opts, "NamingStyle", NamingStyle); + Options.store(Opts, "MinConfidence", MinConfidence, getConfidenceMapping()); + Options.store(Opts, "NamingStyle", NamingStyle, getStyleMapping()); } void LoopConvertCheck::registerMatchers(MatchFinder *Finder) { diff --git a/clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp b/clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp index c677043..e34fd70 100644 --- a/clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp @@ -45,6 +45,7 @@ MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context, StringRef MakeSmartPtrFunctionName) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)), MakeSmartPtrFunctionHeader( Options.get("MakeSmartPtrFunctionHeader", StdMemoryHeader)), @@ -53,7 +54,8 @@ MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context, IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader); Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName); Options.store(Opts, "IgnoreMacros", IgnoreMacros); diff --git a/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp b/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp index b6dedfb..ed1a1a2 100644 --- a/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp @@ -121,11 +121,13 @@ collectParamDecls(const CXXConstructorDecl *Ctor, PassByValueCheck::PassByValueCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)), ValuesOnly(Options.get("ValuesOnly", false)) {} void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); Options.store(Opts, "ValuesOnly", ValuesOnly); } diff --git a/clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp b/clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp index f98254d..295be20 100644 --- a/clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp @@ -75,10 +75,12 @@ ReplaceAutoPtrCheck::ReplaceAutoPtrCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)) {} void ReplaceAutoPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); } void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) { diff --git a/clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp b/clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp index 66917df..9cfbd87 100644 --- a/clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp @@ -24,6 +24,7 @@ ReplaceRandomShuffleCheck::ReplaceRandomShuffleCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)) {} void ReplaceRandomShuffleCheck::registerMatchers(MatchFinder *Finder) { @@ -51,7 +52,8 @@ void ReplaceRandomShuffleCheck::registerPPCallbacks( void ReplaceRandomShuffleCheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); } void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) { diff --git a/clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp b/clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp index 4cbb014..d09673f 100644 --- a/clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp +++ b/clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp @@ -24,6 +24,7 @@ MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)) {} void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) { @@ -96,7 +97,8 @@ void MoveConstructorInitCheck::registerPPCallbacks( } void MoveConstructorInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); } } // namespace performance diff --git a/clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp b/clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp index 597445d..d08cec1 100644 --- a/clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp +++ b/clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp @@ -32,6 +32,7 @@ TypePromotionInMathFnCheck::TypePromotionInMathFnCheck( StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)) {} void TypePromotionInMathFnCheck::registerPPCallbacks( @@ -43,7 +44,8 @@ void TypePromotionInMathFnCheck::registerPPCallbacks( void TypePromotionInMathFnCheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); } void TypePromotionInMathFnCheck::registerMatchers(MatchFinder *Finder) { diff --git a/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp b/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp index 5de53b1..5b5f2ff 100644 --- a/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp +++ b/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp @@ -69,6 +69,7 @@ UnnecessaryValueParamCheck::UnnecessaryValueParamCheck( StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + utils::IncludeSorter::getMapping(), utils::IncludeSorter::IS_LLVM)), AllowedTypes( utils::options::parseStringList(Options.get("AllowedTypes", ""))) {} @@ -180,7 +181,8 @@ void UnnecessaryValueParamCheck::registerPPCallbacks( void UnnecessaryValueParamCheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + utils::IncludeSorter::getMapping()); Options.store(Opts, "AllowedTypes", utils::options::serializeStringList(AllowedTypes)); } diff --git a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp index c885aac..6e7fcaa 100644 --- a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp +++ b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp @@ -26,26 +26,6 @@ using namespace clang::ast_matchers; namespace clang { namespace tidy { - -llvm::ArrayRef< - std::pair> -OptionEnumMapping< - readability::IdentifierNamingCheck::CaseType>::getEnumMapping() { - static constexpr std::pair - Mapping[] = { - {readability::IdentifierNamingCheck::CT_AnyCase, "aNy_CasE"}, - {readability::IdentifierNamingCheck::CT_LowerCase, "lower_case"}, - {readability::IdentifierNamingCheck::CT_UpperCase, "UPPER_CASE"}, - {readability::IdentifierNamingCheck::CT_CamelBack, "camelBack"}, - {readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"}, - {readability::IdentifierNamingCheck::CT_CamelSnakeCase, - "Camel_Snake_Case"}, - {readability::IdentifierNamingCheck::CT_CamelSnakeBack, - "camel_Snake_Back"}}; - return llvm::makeArrayRef(Mapping); -} - namespace readability { // clang-format off @@ -119,6 +99,16 @@ static StringRef const StyleNames[] = { #undef NAMING_KEYS // clang-format on +static constexpr std::pair + Mapping[] = { + {"aNy_CasE", IdentifierNamingCheck::CT_AnyCase}, + {"lower_case", IdentifierNamingCheck::CT_LowerCase}, + {"UPPER_CASE", IdentifierNamingCheck::CT_UpperCase}, + {"camelBack", IdentifierNamingCheck::CT_CamelBack}, + {"CamelCase", IdentifierNamingCheck::CT_CamelCase}, + {"Camel_Snake_Case", IdentifierNamingCheck::CT_CamelSnakeCase}, + {"camel_Snake_Back", IdentifierNamingCheck::CT_CamelSnakeBack}}; + IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name, ClangTidyContext *Context) : RenamerClangTidyCheck(Name, Context), @@ -127,7 +117,7 @@ IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name, for (auto const &Name : StyleNames) { auto CaseOptional = [&]() -> llvm::Optional { - auto ValueOr = Options.get((Name + "Case").str()); + auto ValueOr = Options.get((Name + "Case").str(), makeArrayRef(Mapping)); if (ValueOr) return *ValueOr; llvm::logAllUnhandledErrors( @@ -158,7 +148,7 @@ void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { if (NamingStyles[i]) { if (NamingStyles[i]->Case) { Options.store(Opts, (StyleNames[i] + "Case").str(), - *NamingStyles[i]->Case); + *NamingStyles[i]->Case, llvm::makeArrayRef(Mapping)); } Options.store(Opts, (StyleNames[i] + "Prefix").str(), NamingStyles[i]->Prefix); diff --git a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h index 369ebe4..04bf53f 100644 --- a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h +++ b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h @@ -75,13 +75,6 @@ private: }; } // namespace readability -template <> -struct OptionEnumMapping< - readability::IdentifierNamingCheck::CaseType> { - static llvm::ArrayRef< - std::pair> - getEnumMapping(); -}; } // namespace tidy } // namespace clang diff --git a/clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp b/clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp index 1ae8c29..6013412 100644 --- a/clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp +++ b/clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp @@ -174,14 +174,13 @@ Optional IncludeSorter::CreateIncludeInsertion(StringRef FileName, IncludeStmt); } -} // namespace utils - -llvm::ArrayRef> -OptionEnumMapping::getEnumMapping() { - static constexpr std::pair - Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"}, - {utils::IncludeSorter::IS_Google, "google"}}; +llvm::ArrayRef> +IncludeSorter::getMapping() { + static constexpr std::pair Mapping[] = + {{"llvm", IS_LLVM}, {"google", IS_Google}}; return makeArrayRef(Mapping); } + +} // namespace utils } // namespace tidy } // namespace clang diff --git a/clang-tools-extra/clang-tidy/utils/IncludeSorter.h b/clang-tools-extra/clang-tidy/utils/IncludeSorter.h index 1abe1b9..7dab2cc 100644 --- a/clang-tools-extra/clang-tidy/utils/IncludeSorter.h +++ b/clang-tools-extra/clang-tidy/utils/IncludeSorter.h @@ -25,6 +25,8 @@ public: /// Supported include styles. enum IncludeStyle { IS_LLVM = 0, IS_Google = 1 }; + static ArrayRef> getMapping(); + /// The classifications of inclusions, in the order they should be sorted. enum IncludeKinds { IK_MainTUInclude = 0, ///< e.g. ``#include "foo.h"`` when editing foo.cc @@ -64,11 +66,6 @@ private: }; } // namespace utils - -template <> struct OptionEnumMapping { - static ArrayRef> - getEnumMapping(); -}; } // namespace tidy } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H diff --git a/clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.cpp b/clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.cpp index 4a7a418..0a57856 100644 --- a/clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.cpp +++ b/clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.cpp @@ -32,6 +32,7 @@ TransformerClangTidyCheck::TransformerClangTidyCheck( StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), Rule(MakeRule(getLangOpts(), Options)), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + IncludeSorter::getMapping(), IncludeSorter::IS_LLVM)) { if (Rule) assert(llvm::all_of(Rule->Cases, hasExplanation) && @@ -44,6 +45,7 @@ TransformerClangTidyCheck::TransformerClangTidyCheck(RewriteRule R, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), Rule(std::move(R)), IncludeStyle(Options.getLocalOrGlobal("IncludeStyle", + IncludeSorter::getMapping(), IncludeSorter::IS_LLVM)) { assert(llvm::all_of(Rule->Cases, hasExplanation) && "clang-tidy checks must have an explanation by default;" @@ -109,7 +111,8 @@ void TransformerClangTidyCheck::check( void TransformerClangTidyCheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "IncludeStyle", IncludeStyle); + Options.store(Opts, "IncludeStyle", IncludeStyle, + IncludeSorter::getMapping()); } } // namespace utils diff --git a/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp b/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp index c4331f4..a089281 100644 --- a/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp +++ b/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp @@ -6,20 +6,6 @@ namespace clang { namespace tidy { - -enum class Colours { Red, Orange, Yellow, Green, Blue, Indigo, Violet }; - -template <> struct OptionEnumMapping { - static llvm::ArrayRef> getEnumMapping() { - static constexpr std::pair Mapping[] = { - {Colours::Red, "Red"}, {Colours::Orange, "Orange"}, - {Colours::Yellow, "Yellow"}, {Colours::Green, "Green"}, - {Colours::Blue, "Blue"}, {Colours::Indigo, "Indigo"}, - {Colours::Violet, "Violet"}}; - return makeArrayRef(Mapping); - } -}; - namespace test { TEST(ParseLineFilter, EmptyFilter) { @@ -223,6 +209,15 @@ TEST(CheckOptionsValidation, ValidIntOptions) { } TEST(ValidConfiguration, ValidEnumOptions) { + + enum class Colours { Red, Orange, Yellow, Green, Blue, Indigo, Violet }; + static constexpr std::pair Mapping[] = { + {"Red", Colours::Red}, {"Orange", Colours::Orange}, + {"Yellow", Colours::Yellow}, {"Green", Colours::Green}, + {"Blue", Colours::Blue}, {"Indigo", Colours::Indigo}, + {"Violet", Colours::Violet}}; + static const auto Map = makeArrayRef(Mapping); + ClangTidyOptions Options; auto &CheckOptions = Options.CheckOptions; @@ -242,30 +237,29 @@ TEST(ValidConfiguration, ValidEnumOptions) { #define CHECK_ERROR_ENUM(Name, Expected) \ CHECK_ERROR(Name, UnparseableEnumOptionError, Expected) - CHECK_VAL(TestCheck.getIntLocal("Valid"), Colours::Red); - CHECK_VAL(TestCheck.getIntGlobal("GlobalValid"), Colours::Violet); + CHECK_VAL(TestCheck.getLocal("Valid", Map), Colours::Red); + CHECK_VAL(TestCheck.getGlobal("GlobalValid", Map), Colours::Violet); + CHECK_VAL(TestCheck.getLocal("ValidWrongCase", Map, /*IgnoreCase*/ true), + Colours::Red); CHECK_VAL( - TestCheck.getIntLocal("ValidWrongCase", /*IgnoreCase*/ true), - Colours::Red); - CHECK_VAL(TestCheck.getIntGlobal("GlobalValidWrongCase", - /*IgnoreCase*/ true), - Colours::Violet); - CHECK_ERROR_ENUM(TestCheck.getIntLocal("Invalid"), + TestCheck.getGlobal("GlobalValidWrongCase", Map, /*IgnoreCase*/ true), + Colours::Violet); + CHECK_ERROR_ENUM(TestCheck.getLocal("Invalid", Map), "invalid configuration value " "'Scarlet' for option 'test.Invalid'"); - CHECK_ERROR_ENUM(TestCheck.getIntLocal("ValidWrongCase"), + CHECK_ERROR_ENUM(TestCheck.getLocal("ValidWrongCase", Map), "invalid configuration value 'rED' for option " "'test.ValidWrongCase'; did you mean 'Red'?"); - CHECK_ERROR_ENUM(TestCheck.getIntLocal("NearMiss"), + CHECK_ERROR_ENUM(TestCheck.getLocal("NearMiss", Map), "invalid configuration value 'Oragne' for option " "'test.NearMiss'; did you mean 'Orange'?"); - CHECK_ERROR_ENUM(TestCheck.getIntGlobal("GlobalInvalid"), + CHECK_ERROR_ENUM(TestCheck.getGlobal("GlobalInvalid", Map), "invalid configuration value " "'Purple' for option 'GlobalInvalid'"); - CHECK_ERROR_ENUM(TestCheck.getIntGlobal("GlobalValidWrongCase"), + CHECK_ERROR_ENUM(TestCheck.getGlobal("GlobalValidWrongCase", Map), "invalid configuration value 'vIOLET' for option " "'GlobalValidWrongCase'; did you mean 'Violet'?"); - CHECK_ERROR_ENUM(TestCheck.getIntGlobal("GlobalNearMiss"), + CHECK_ERROR_ENUM(TestCheck.getGlobal("GlobalNearMiss", Map), "invalid configuration value 'Yelow' for option " "'GlobalNearMiss'; did you mean 'Yellow'?"); -- 2.7.4