Author: smhc Date: 2020-11-25T01:18:44Z New Revision: 9c4df9eecb6ca6b53d919cec9b460de46dd40302
URL: https://github.com/llvm/llvm-project/commit/9c4df9eecb6ca6b53d919cec9b460de46dd40302 DIFF: https://github.com/llvm/llvm-project/commit/9c4df9eecb6ca6b53d919cec9b460de46dd40302.diff LOG: [clang-tidy] Support IgnoredRegexp configuration to selectively suppress identifier naming checks The idea of suppressing naming checks for variables is to support code bases that allow short variables named e.g 'x' and 'i' without prefix/suffixes or casing styles. This was originally proposed as a 'ShortSizeThreshold' however has been made more generic with a regex to suppress identifier naming checks for those that match. Reviewed By: njames93, aaron.ballman Differential Revision: https://reviews.llvm.org/D90282 Added: clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp Modified: clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h clang-tools-extra/docs/ReleaseNotes.rst clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst Removed: ################################################################################ diff --git a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp index d7160d52750f..efc683c6c05d 100644 --- a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp +++ b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp @@ -122,14 +122,32 @@ static StringRef const StyleNames[] = { #undef NAMING_KEYS // clang-format on +IdentifierNamingCheck::NamingStyle::NamingStyle( + llvm::Optional<IdentifierNamingCheck::CaseType> Case, + const std::string &Prefix, const std::string &Suffix, + const std::string &IgnoredRegexpStr) + : Case(Case), Prefix(Prefix), Suffix(Suffix), + IgnoredRegexpStr(IgnoredRegexpStr) { + if (!IgnoredRegexpStr.empty()) { + IgnoredRegexp = + llvm::Regex(llvm::SmallString<128>({"^", IgnoredRegexpStr, "$"})); + if (!IgnoredRegexp.isValid()) + llvm::errs() << "Invalid IgnoredRegexp regular expression: " + << IgnoredRegexpStr; + } +} + static IdentifierNamingCheck::FileStyle getFileStyleFromOptions(const ClangTidyCheck::OptionsView &Options) { - SmallVector<llvm::Optional<IdentifierNamingCheck::NamingStyle>, 0> Styles( - SK_Count); + SmallVector<llvm::Optional<IdentifierNamingCheck::NamingStyle>, 0> Styles; + Styles.resize(SK_Count); SmallString<64> StyleString; for (unsigned I = 0; I < SK_Count; ++I) { StyleString = StyleNames[I]; size_t StyleSize = StyleString.size(); + StyleString.append("IgnoredRegexp"); + std::string IgnoredRegexpStr = Options.get(StyleString, ""); + StyleString.resize(StyleSize); StyleString.append("Prefix"); std::string Prefix(Options.get(StyleString, "")); // Fast replacement of [Pre]fix -> [Suf]fix. @@ -141,9 +159,10 @@ getFileStyleFromOptions(const ClangTidyCheck::OptionsView &Options) { auto CaseOptional = Options.getOptional<IdentifierNamingCheck::CaseType>(StyleString); - if (CaseOptional || !Prefix.empty() || !Postfix.empty()) + if (CaseOptional || !Prefix.empty() || !Postfix.empty() || + !IgnoredRegexpStr.empty()) Styles[I].emplace(std::move(CaseOptional), std::move(Prefix), - std::move(Postfix)); + std::move(Postfix), std::move(IgnoredRegexpStr)); } bool IgnoreMainLike = Options.get("IgnoreMainLikeFunctions", false); return {std::move(Styles), IgnoreMainLike}; @@ -175,6 +194,9 @@ void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { continue; StyleString = StyleNames[I]; size_t StyleSize = StyleString.size(); + StyleString.append("IgnoredRegexp"); + Options.store(Opts, StyleString, Styles[I]->IgnoredRegexpStr); + StyleString.resize(StyleSize); StyleString.append("Prefix"); Options.store(Opts, StyleString, Styles[I]->Prefix); // Fast replacement of [Pre]fix -> [Suf]fix. @@ -194,7 +216,7 @@ void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { } static bool matchesStyle(StringRef Name, - IdentifierNamingCheck::NamingStyle Style) { + const IdentifierNamingCheck::NamingStyle &Style) { static llvm::Regex Matchers[] = { llvm::Regex("^.*$"), llvm::Regex("^[a-z][a-z0-9_]*$"), @@ -681,6 +703,9 @@ static llvm::Optional<RenamerClangTidyCheck::FailureInfo> getFailureInfo( return None; const IdentifierNamingCheck::NamingStyle &Style = *NamingStyles[SK]; + if (Style.IgnoredRegexp.isValid() && Style.IgnoredRegexp.match(Name)) + return None; + if (matchesStyle(Name, Style)) return None; diff --git a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h index 77c03f77d91d..565eb9d11474 100644 --- a/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h +++ b/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h @@ -52,12 +52,18 @@ class IdentifierNamingCheck final : public RenamerClangTidyCheck { NamingStyle() = default; NamingStyle(llvm::Optional<CaseType> Case, const std::string &Prefix, - const std::string &Suffix) - : Case(Case), Prefix(Prefix), Suffix(Suffix) {} + const std::string &Suffix, const std::string &IgnoredRegexpStr); + NamingStyle(const NamingStyle &O) = delete; + NamingStyle &operator=(NamingStyle &&O) = default; + NamingStyle(NamingStyle &&O) = default; llvm::Optional<CaseType> Case; std::string Prefix; std::string Suffix; + // Store both compiled and non-compiled forms so original value can be + // serialized + llvm::Regex IgnoredRegexp; + std::string IgnoredRegexpStr; }; struct FileStyle { diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst index c99a589b1212..46bb36c271d3 100644 --- a/clang-tools-extra/docs/ReleaseNotes.rst +++ b/clang-tools-extra/docs/ReleaseNotes.rst @@ -149,6 +149,9 @@ Changes in existing checks Added support for specifying the style of scoped ``enum`` constants. If unspecified, will fall back to the style for regular ``enum`` constants. + Added an option `IgnoredRegexp` per identifier type to suppress identifier + naming checks for names matching a regular expression. + - Removed `google-runtime-references` check because the rule it checks does not exist in the Google Style Guide anymore. diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst b/clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst index 036103e7e80e..b744d21b6ff8 100644 --- a/clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst +++ b/clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst @@ -35,60 +35,60 @@ Options The following options are describe below: - - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`, :option:`AbstractClassSuffix` + - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`, :option:`AbstractClassSuffix`, :option:`AbstractClassIgnoredRegexp` - :option:`AggressiveDependentMemberLookup` - - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix` - - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`, :option:`ClassConstantSuffix` - - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`, :option:`ClassMemberSuffix` - - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`, :option:`ClassMethodSuffix` - - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix` - - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`, :option:`ConstantMemberSuffix` - - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`, :option:`ConstantParameterSuffix` - - :option:`ConstantPointerParameterCase`, :option:`ConstantPointerParameterPrefix`, :option:`ConstantPointerParameterSuffix` - - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`, :option:`ConstexprFunctionSuffix` - - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`, :option:`ConstexprMethodSuffix` - - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`, :option:`ConstexprVariableSuffix` - - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix` - - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`, :option:`EnumConstantSuffix` - - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix` + - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix`, :option:`ClassIgnoredRegexp` + - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`, :option:`ClassConstantSuffix`, :option:`ClassConstantIgnoredRegexp` + - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`, :option:`ClassMemberSuffix`, :option:`ClassMemberIgnoredRegexp` + - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`, :option:`ClassMethodSuffix`, :option:`ClassMethodIgnoredRegexp` + - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix`, :option:`ConstantIgnoredRegexp` + - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`, :option:`ConstantMemberSuffix`, :option:`ConstantMemberIgnoredRegexp` + - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`, :option:`ConstantParameterSuffix`, :option:`ConstantParameterIgnoredRegexp` + - :option:`ConstantPointerParameterCase`, :option:`ConstantPointerParameterPrefix`, :option:`ConstantPointerParameterSuffix`, :option:`ConstantPointerParameterIgnoredRegexp` + - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`, :option:`ConstexprFunctionSuffix`, :option:`ConstexprFunctionIgnoredRegexp` + - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`, :option:`ConstexprMethodSuffix`, :option:`ConstexprMethodIgnoredRegexp` + - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`, :option:`ConstexprVariableSuffix`, :option:`ConstexprVariableIgnoredRegexp` + - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix`, :option:`EnumIgnoredRegexp` + - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`, :option:`EnumConstantSuffix`, :option:`EnumConstantIgnoredRegexp` + - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix`, :option:`FunctionIgnoredRegexp` - :option:`GetConfigPerFile` - - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix` - - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix` - - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`, :option:`GlobalFunctionSuffix` - - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix` - - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix` + - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix`, :option:`GlobalConstantIgnoredRegexp` + - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix`, :option:`GlobalConstantPointerIgnoredRegexp` + - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`, :option:`GlobalFunctionSuffix`, :option:`GlobalFunctionIgnoredRegexp` + - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix`, :option:`GlobalPointerIgnoredRegexp` + - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix`, :option:`GlobalVariableIgnoredRegexp` - :option:`IgnoreMainLikeFunctions` - - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`, :option:`InlineNamespaceSuffix` - - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`, :option:`LocalConstantSuffix` - - :option:`LocalConstantPointerCase`, :option:`LocalConstantPointerPrefix`, :option:`LocalConstantPointerSuffix` - - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`, :option:`LocalPointerSuffix` - - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`, :option:`LocalVariableSuffix` - - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`, :option:`MacroDefinitionSuffix` - - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix` - - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix` - - :option:`NamespaceCase`, :option:`NamespacePrefix`, :option:`NamespaceSuffix` - - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix` - - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix` - - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix` - - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix` - - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix` - - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix` - - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix` - - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix` - - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`, :option:`PublicMethodSuffix` - - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`, :option:`ScopedEnumConstantSuffix` - - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix` - - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix` - - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix` - - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`, :option:`TemplateParameterSuffix` - - :option:`TemplateTemplateParameterCase`, :option:`TemplateTemplateParameterPrefix`, :option:`TemplateTemplateParameterSuffix` - - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`, :option:`TypeAliasSuffix` - - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix` - - :option:`TypeTemplateParameterCase`, :option:`TypeTemplateParameterPrefix`, :option:`TypeTemplateParameterSuffix` - - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix` - - :option:`ValueTemplateParameterCase`, :option:`ValueTemplateParameterPrefix`, :option:`ValueTemplateParameterSuffix` - - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix` - - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`, :option:`VirtualMethodSuffix` + - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`, :option:`InlineNamespaceSuffix`, :option:`InlineNamespaceIgnoredRegexp` + - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`, :option:`LocalConstantSuffix`, :option:`LocalConstantIgnoredRegexp` + - :option:`LocalConstantPointerCase`, :option:`LocalConstantPointerPrefix`, :option:`LocalConstantPointerSuffix`, :option:`LocalConstantPointerIgnoredRegexp` + - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`, :option:`LocalPointerSuffix`, :option:`LocalPointerIgnoredRegexp` + - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`, :option:`LocalVariableSuffix`, :option:`LocalVariableIgnoredRegexp` + - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`, :option:`MacroDefinitionSuffix`, :option:`MacroDefinitionIgnoredRegexp` + - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`, :option:`MemberIgnoredRegexp` + - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix`, :option:`MethodIgnoredRegexp` + - :option:`NamespaceCase`, :option:`NamespacePrefix`, :option:`NamespaceSuffix`, :option:`NamespaceIgnoredRegexp` + - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix`, :option:`ParameterIgnoredRegexp` + - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix`, :option:`ParameterPackIgnoredRegexp` + - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix`, :option:`PointerParameterIgnoredRegexp` + - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix`, :option:`PrivateMemberIgnoredRegexp` + - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix`, :option:`PrivateMethodIgnoredRegexp` + - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix`, :option:`ProtectedMemberIgnoredRegexp` + - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix`, :option:`ProtectedMethodIgnoredRegexp` + - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix`, :option:`PublicMemberIgnoredRegexp` + - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`, :option:`PublicMethodSuffix`, :option:`PublicMethodIgnoredRegexp` + - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`, :option:`ScopedEnumConstantSuffix`, :option:`ScopedEnumConstantIgnoredRegexp` + - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix`, :option:`StaticConstantIgnoredRegexp` + - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix`, :option:`StaticVariableIgnoredRegexp` + - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix`, :option:`StructIgnoredRegexp` + - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`, :option:`TemplateParameterSuffix`, :option:`TemplateParameterIgnoredRegexp` + - :option:`TemplateTemplateParameterCase`, :option:`TemplateTemplateParameterPrefix`, :option:`TemplateTemplateParameterSuffix`, :option:`TemplateTemplateParameterIgnoredRegexp` + - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`, :option:`TypeAliasSuffix`, :option:`TypeAliasIgnoredRegexp` + - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix`, :option:`TypedefIgnoredRegexp` + - :option:`TypeTemplateParameterCase`, :option:`TypeTemplateParameterPrefix`, :option:`TypeTemplateParameterSuffix`, :option:`TypeTemplateParameterIgnoredRegexp` + - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix`, :option:`UnionIgnoredRegexp` + - :option:`ValueTemplateParameterCase`, :option:`ValueTemplateParameterPrefix`, :option:`ValueTemplateParameterSuffix`, :option:`ValueTemplateParameterIgnoredRegexp` + - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix`, :option:`VariableIgnoredRegexp` + - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`, :option:`VirtualMethodSuffix`, :option:`VirtualMethodIgnoredRegexp` .. option:: AbstractClassCase @@ -100,6 +100,11 @@ The following options are describe below: When defined, the check will ensure abstract class names will add the prefixed with the given value (regardless of casing). +.. option:: AbstractClassIgnoredRegexp + + Identifier naming checks won't be enforced for abstract class names + matching this regular expression. + .. option:: AbstractClassSuffix When defined, the check will ensure abstract class names will add the @@ -199,6 +204,11 @@ After if AggressiveDependentMemberLookup is ``1``: When defined, the check will ensure class names will add the prefixed with the given value (regardless of casing). +.. option:: ClassIgnoredRegexp + + Identifier naming checks won't be enforced for class names matching + this regular expression. + .. option:: ClassSuffix When defined, the check will ensure class names will add the @@ -242,6 +252,11 @@ After: When defined, the check will ensure class constant names will add the prefixed with the given value (regardless of casing). +.. option:: ClassConstantIgnoredRegexp + + Identifier naming checks won't be enforced for class constant names + matching this regular expression. + .. option:: ClassConstantSuffix When defined, the check will ensure class constant names will add the @@ -283,6 +298,11 @@ After: When defined, the check will ensure class member names will add the prefixed with the given value (regardless of casing). +.. option:: ClassMemberIgnoredRegexp + + Identifier naming checks won't be enforced for class member names + matching this regular expression. + .. option:: ClassMemberSuffix When defined, the check will ensure class member names will add the @@ -324,6 +344,11 @@ After: When defined, the check will ensure class method names will add the prefixed with the given value (regardless of casing). +.. option:: ClassMethodIgnoredRegexp + + Identifier naming checks won't be enforced for class method names + matching this regular expression. + .. option:: ClassMethodSuffix When defined, the check will ensure class method names will add the @@ -365,6 +390,11 @@ After: When defined, the check will ensure constant names will add the prefixed with the given value (regardless of casing). +.. option:: ConstantIgnoredRegexp + + Identifier naming checks won't be enforced for constant names + matching this regular expression. + .. option:: ConstantSuffix When defined, the check will ensure constant names will add the @@ -400,6 +430,11 @@ After: When defined, the check will ensure constant member names will add the prefixed with the given value (regardless of casing). +.. option:: ConstantMemberIgnoredRegexp + + Identifier naming checks won't be enforced for constant member names + matching this regular expression. + .. option:: ConstantMemberSuffix When defined, the check will ensure constant member names will add the @@ -439,6 +474,11 @@ After: When defined, the check will ensure constant parameter names will add the prefixed with the given value (regardless of casing). +.. option:: ConstantParameterIgnoredRegexp + + Identifier naming checks won't be enforced for constant parameter names + matching this regular expression. + .. option:: ConstantParameterSuffix When defined, the check will ensure constant parameter names will add the @@ -474,6 +514,11 @@ After: When defined, the check will ensure constant pointer parameter names will add the prefixed with the given value (regardless of casing). +.. option:: ConstantPointerParameterIgnoredRegexp + + Identifier naming checks won't be enforced for constant pointer parameter + names matching this regular expression. + .. option:: ConstantPointerParameterSuffix When defined, the check will ensure constant pointer parameter names will add the @@ -509,6 +554,11 @@ After: When defined, the check will ensure constexpr function names will add the prefixed with the given value (regardless of casing). +.. option:: ConstexprFunctionIgnoredRegexp + + Identifier naming checks won't be enforced for constexpr function names + matching this regular expression. + .. option:: ConstexprFunctionSuffix When defined, the check will ensure constexpr function names will add the @@ -544,6 +594,11 @@ After: When defined, the check will ensure constexpr method names will add the prefixed with the given value (regardless of casing). +.. option:: ConstexprMethodIgnoredRegexp + + Identifier naming checks won't be enforced for constexpr method names + matching this regular expression. + .. option:: ConstexprMethodSuffix When defined, the check will ensure constexpr method names will add the @@ -585,6 +640,11 @@ After: When defined, the check will ensure constexpr variable names will add the prefixed with the given value (regardless of casing). +.. option:: ConstexprVariableIgnoredRegexp + + Identifier naming checks won't be enforced for constexpr variable names + matching this regular expression. + .. option:: ConstexprVariableSuffix When defined, the check will ensure constexpr variable names will add the @@ -620,6 +680,11 @@ After: When defined, the check will ensure enumeration names will add the prefixed with the given value (regardless of casing). +.. option:: EnumConstantIgnoredRegexp + + Identifier naming checks won't be enforced for enumeration names + matching this regular expression. + .. option:: EnumSuffix When defined, the check will ensure enumeration names will add the @@ -655,6 +720,11 @@ After: When defined, the check will ensure enumeration constant names will add the prefixed with the given value (regardless of casing). +.. option:: EnumConstantIgnoredRegexp + + Identifier naming checks won't be enforced for enumeration constant names + matching this regular expression. + .. option:: EnumConstantSuffix When defined, the check will ensure enumeration constant names will add the @@ -690,6 +760,11 @@ After: When defined, the check will ensure function names will add the prefixed with the given value (regardless of casing). +.. option:: FunctionIgnoredRegexp + + Identifier naming checks won't be enforced for function names + matching this regular expression. + .. option:: FunctionSuffix When defined, the check will ensure function names will add the @@ -732,6 +807,11 @@ After: When defined, the check will ensure global constant names will add the prefixed with the given value (regardless of casing). +.. option:: GlobalConstantIgnoredRegexp + + Identifier naming checks won't be enforced for global constant names + matching this regular expression. + .. option:: GlobalConstantSuffix When defined, the check will ensure global constant names will add the @@ -767,6 +847,11 @@ After: When defined, the check will ensure global constant pointer names will add the prefixed with the given value (regardless of casing). +.. option:: GlobalConstantPointerIgnoredRegexp + + Identifier naming checks won't be enforced for global constant pointer + names matching this regular expression. + .. option:: GlobalConstantPointerSuffix When defined, the check will ensure global constant pointer names will add the @@ -802,6 +887,11 @@ After: When defined, the check will ensure global function names will add the prefixed with the given value (regardless of casing). +.. option:: GlobalFunctionIgnoredRegexp + + Identifier naming checks won't be enforced for global function names + matching this regular expression. + .. option:: GlobalFunctionSuffix When defined, the check will ensure global function names will add the @@ -837,6 +927,11 @@ After: When defined, the check will ensure global pointer names will add the prefixed with the given value (regardless of casing). +.. option:: GlobalPointerIgnoredRegexp + + Identifier naming checks won't be enforced for global pointer names + matching this regular expression. + .. option:: GlobalPointerSuffix When defined, the check will ensure global pointer names will add the @@ -872,6 +967,11 @@ After: When defined, the check will ensure global variable names will add the prefixed with the given value (regardless of casing). +.. option:: GlobalVariableIgnoredRegexp + + Identifier naming checks won't be enforced for global variable names + matching this regular expression. + .. option:: GlobalVariableSuffix When defined, the check will ensure global variable names will add the @@ -913,6 +1013,11 @@ After: When defined, the check will ensure inline namespaces names will add the prefixed with the given value (regardless of casing). +.. option:: InlineNamespaceIgnoredRegexp + + Identifier naming checks won't be enforced for inline namespaces names + matching this regular expression. + .. option:: InlineNamespaceSuffix When defined, the check will ensure inline namespaces names will add the @@ -956,6 +1061,11 @@ After: When defined, the check will ensure local constant names will add the prefixed with the given value (regardless of casing). +.. option:: LocalConstantIgnoredRegexp + + Identifier naming checks won't be enforced for local constant names + matching this regular expression. + .. option:: LocalConstantSuffix When defined, the check will ensure local constant names will add the @@ -991,6 +1101,11 @@ After: When defined, the check will ensure local constant pointer names will add the prefixed with the given value (regardless of casing). +.. option:: LocalConstantPointerIgnoredRegexp + + Identifier naming checks won't be enforced for local constant pointer names + matching this regular expression. + .. option:: LocalConstantPointerSuffix When defined, the check will ensure local constant pointer names will add the @@ -1026,6 +1141,11 @@ After: When defined, the check will ensure local pointer names will add the prefixed with the given value (regardless of casing). +.. option:: LocalPointerIgnoredRegexp + + Identifier naming checks won't be enforced for local pointer names + matching this regular expression. + .. option:: LocalPointerSuffix When defined, the check will ensure local pointer names will add the @@ -1061,6 +1181,19 @@ After: When defined, the check will ensure local variable names will add the prefixed with the given value (regardless of casing). +.. option:: LocalVariableIgnoredRegexp + + Identifier naming checks won't be enforced for local variable names + matching this regular expression. + +For example using values of: + + - LocalVariableCase of ``CamelCase`` + - LocalVariableIgnoredRegexp of ``\w{1,2}`` + +Will exclude variables with a length less than or equal to 2 from the +camel case check applied to other variables. + .. option:: LocalVariableSuffix When defined, the check will ensure local variable names will add the @@ -1096,6 +1229,11 @@ After: When defined, the check will ensure macro definitions will add the prefixed with the given value (regardless of casing). +.. option:: MacroDefinitionIgnoredRegexp + + Identifier naming checks won't be enforced for macro definitions + matching this regular expression. + .. option:: MacroDefinitionSuffix When defined, the check will ensure macro definitions will add the @@ -1134,6 +1272,11 @@ using the ``-D`` flag. When defined, the check will ensure member names will add the prefixed with the given value (regardless of casing). +.. option:: MemberIgnoredRegexp + + Identifier naming checks won't be enforced for member names + matching this regular expression. + .. option:: MemberSuffix When defined, the check will ensure member names will add the @@ -1173,6 +1316,11 @@ After: When defined, the check will ensure method names will add the prefixed with the given value (regardless of casing). +.. option:: MethodIgnoredRegexp + + Identifier naming checks won't be enforced for method names + matching this regular expression. + .. option:: MethodSuffix When defined, the check will ensure method names will add the @@ -1212,6 +1360,11 @@ After: When defined, the check will ensure namespace names will add the prefixed with the given value (regardless of casing). +.. option:: NamespaceIgnoredRegexp + + Identifier naming checks won't be enforced for namespace names + matching this regular expression. + .. option:: NamespaceSuffix When defined, the check will ensure namespace names will add the @@ -1251,6 +1404,11 @@ After: When defined, the check will ensure parameter names will add the prefixed with the given value (regardless of casing). +.. option:: ParameterIgnoredRegexp + + Identifier naming checks won't be enforced for parameter names + matching this regular expression. + .. option:: ParameterSuffix When defined, the check will ensure parameter names will add the @@ -1286,6 +1444,11 @@ After: When defined, the check will ensure parameter pack names will add the prefixed with the given value (regardless of casing). +.. option:: ParameterPackIgnoredRegexp + + Identifier naming checks won't be enforced for parameter pack names + matching this regular expression. + .. option:: ParameterPackSuffix When defined, the check will ensure parameter pack names will add the @@ -1325,6 +1488,11 @@ After: When defined, the check will ensure pointer parameter names will add the prefixed with the given value (regardless of casing). +.. option:: PointerParameterIgnoredRegexp + + Identifier naming checks won't be enforced for pointer parameter names + matching this regular expression. + .. option:: PointerParameterSuffix When defined, the check will ensure pointer parameter names will add the @@ -1360,6 +1528,11 @@ After: When defined, the check will ensure private member names will add the prefixed with the given value (regardless of casing). +.. option:: PrivateMemberIgnoredRegexp + + Identifier naming checks won't be enforced for private member names + matching this regular expression. + .. option:: PrivateMemberSuffix When defined, the check will ensure private member names will add the @@ -1401,6 +1574,11 @@ After: When defined, the check will ensure private method names will add the prefixed with the given value (regardless of casing). +.. option:: PrivateMethodIgnoredRegexp + + Identifier naming checks won't be enforced for private method names + matching this regular expression. + .. option:: PrivateMethodSuffix When defined, the check will ensure private method names will add the @@ -1442,6 +1620,11 @@ After: When defined, the check will ensure protected member names will add the prefixed with the given value (regardless of casing). +.. option:: ProtectedMemberIgnoredRegexp + + Identifier naming checks won't be enforced for protected member names + matching this regular expression. + .. option:: ProtectedMemberSuffix When defined, the check will ensure protected member names will add the @@ -1475,17 +1658,22 @@ After: .. option:: ProtectedMethodCase - When defined, the check will ensure protect method names conform to the + When defined, the check will ensure protected method names conform to the selected casing. .. option:: ProtectedMethodPrefix - When defined, the check will ensure protect method names will add the + When defined, the check will ensure protected method names will add the prefixed with the given value (regardless of casing). +.. option:: ProtectedMethodIgnoredRegexp + + Identifier naming checks won't be enforced for protected method names + matching this regular expression. + .. option:: ProtectedMethodSuffix - When defined, the check will ensure protect method names will add the + When defined, the check will ensure protected method names will add the suffix with the given value (regardless of casing). For example using values of: @@ -1524,6 +1712,11 @@ After: When defined, the check will ensure public member names will add the prefixed with the given value (regardless of casing). +.. option:: PublicMemberIgnoredRegexp + + Identifier naming checks won't be enforced for public member names + matching this regular expression. + .. option:: PublicMemberSuffix When defined, the check will ensure public member names will add the @@ -1565,6 +1758,11 @@ After: When defined, the check will ensure public method names will add the prefixed with the given value (regardless of casing). +.. option:: PublicMethodIgnoredRegexp + + Identifier naming checks won't be enforced for public method names + matching this regular expression. + .. option:: PublicMethodSuffix When defined, the check will ensure public method names will add the @@ -1606,6 +1804,11 @@ After: When defined, the check will ensure scoped enum constant names will add the prefixed with the given value (regardless of casing). +.. option:: ScopedEnumConstantIgnoredRegexp + + Identifier naming checks won't be enforced for scoped enum constant names + matching this regular expression. + .. option:: ScopedEnumConstantSuffix When defined, the check will ensure scoped enum constant names will add the @@ -1641,6 +1844,11 @@ After: When defined, the check will ensure static constant names will add the prefixed with the given value (regardless of casing). +.. option:: StaticConstantIgnoredRegexp + + Identifier naming checks won't be enforced for static constant names + matching this regular expression. + .. option:: StaticConstantSuffix When defined, the check will ensure static constant names will add the @@ -1676,6 +1884,11 @@ After: When defined, the check will ensure static variable names will add the prefixed with the given value (regardless of casing). +.. option:: StaticVariableIgnoredRegexp + + Identifier naming checks won't be enforced for static variable names + matching this regular expression. + .. option:: StaticVariableSuffix When defined, the check will ensure static variable names will add the @@ -1711,6 +1924,11 @@ After: When defined, the check will ensure struct names will add the prefixed with the given value (regardless of casing). +.. option:: StructIgnoredRegexp + + Identifier naming checks won't be enforced for struct names + matching this regular expression. + .. option:: StructSuffix When defined, the check will ensure struct names will add the @@ -1752,6 +1970,11 @@ After: When defined, the check will ensure template parameter names will add the prefixed with the given value (regardless of casing). +.. option:: TemplateParameterIgnoredRegexp + + Identifier naming checks won't be enforced for template parameter names + matching this regular expression. + .. option:: TemplateParameterSuffix When defined, the check will ensure template parameter names will add the @@ -1787,6 +2010,11 @@ After: When defined, the check will ensure template template parameter names will add the prefixed with the given value (regardless of casing). +.. option:: TemplateTemplateParameterIgnoredRegexp + + Identifier naming checks won't be enforced for template template parameter + names matching this regular expression. + .. option:: TemplateTemplateParameterSuffix When defined, the check will ensure template template parameter names will add the @@ -1824,6 +2052,11 @@ After: When defined, the check will ensure type alias names will add the prefixed with the given value (regardless of casing). +.. option:: TypeAliasIgnoredRegexp + + Identifier naming checks won't be enforced for type alias names + matching this regular expression. + .. option:: TypeAliasSuffix When defined, the check will ensure type alias names will add the @@ -1859,6 +2092,11 @@ After: When defined, the check will ensure typedef names will add the prefixed with the given value (regardless of casing). +.. option:: TypedefIgnoredRegexp + + Identifier naming checks won't be enforced for typedef names + matching this regular expression. + .. option:: TypedefSuffix When defined, the check will ensure typedef names will add the @@ -1894,6 +2132,11 @@ After: When defined, the check will ensure type template parameter names will add the prefixed with the given value (regardless of casing). +.. option:: TypeTemplateParameterIgnoredRegexp + + Identifier naming checks won't be enforced for type template names + matching this regular expression. + .. option:: TypeTemplateParameterSuffix When defined, the check will ensure type template parameter names will add the @@ -1931,6 +2174,11 @@ After: When defined, the check will ensure union names will add the prefixed with the given value (regardless of casing). +.. option:: UnionIgnoredRegexp + + Identifier naming checks won't be enforced for union names + matching this regular expression. + .. option:: UnionSuffix When defined, the check will ensure union names will add the @@ -1972,6 +2220,11 @@ After: When defined, the check will ensure value template parameter names will add the prefixed with the given value (regardless of casing). +.. option:: ValueTemplateParameterIgnoredRegexp + + Identifier naming checks won't be enforced for value template parameter + names matching this regular expression. + .. option:: ValueTemplateParameterSuffix When defined, the check will ensure value template parameter names will add the @@ -2009,6 +2262,11 @@ After: When defined, the check will ensure variable names will add the prefixed with the given value (regardless of casing). +.. option:: VariableIgnoredRegexp + + Identifier naming checks won't be enforced for variable names + matching this regular expression. + .. option:: VariableSuffix When defined, the check will ensure variable names will add the @@ -2044,6 +2302,11 @@ After: When defined, the check will ensure virtual method names will add the prefixed with the given value (regardless of casing). +.. option:: VirtualMethodIgnoredRegexp + + Identifier naming checks won't be enforced for virtual method names + matching this regular expression. + .. option:: VirtualMethodSuffix When defined, the check will ensure virtual method names will add the diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp new file mode 100644 index 000000000000..e99edff5cc21 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp @@ -0,0 +1,47 @@ +// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ +// RUN: -config='{CheckOptions: [ \ +// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ +// RUN: {key: readability-identifier-naming.ParameterIgnoredRegexp, value: "^[a-z]{1,2}$"}, \ +// RUN: {key: readability-identifier-naming.ClassCase, value: CamelCase}, \ +// RUN: {key: readability-identifier-naming.ClassIgnoredRegexp, value: "^fo$|^fooo$"}, \ +// RUN: {key: readability-identifier-naming.StructCase, value: CamelCase}, \ +// RUN: {key: readability-identifier-naming.StructIgnoredRegexp, value: "sooo|so|soo|$invalidregex["} \ +// RUN: ]}' + +int testFunc(int a, char **b); +int testFunc(int ab, char **ba); +int testFunc(int abc, char **cba); +// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'abc' +// CHECK-MESSAGES: :[[@LINE-2]]:30: warning: invalid case style for parameter 'cba' +// CHECK-FIXES: {{^}}int testFunc(int Abc, char **Cba);{{$}} +int testFunc(int dE, char **eD); +// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'dE' +// CHECK-MESSAGES: :[[@LINE-2]]:29: warning: invalid case style for parameter 'eD' +// CHECK-FIXES: {{^}}int testFunc(int DE, char **ED);{{$}} +int testFunc(int Abc, char **Cba); + +class fo { +}; + +class fofo { + // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'fofo' + // CHECK-FIXES: {{^}}class Fofo {{{$}} +}; + +class foo { + // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'foo' + // CHECK-FIXES: {{^}}class Foo {{{$}} +}; + +class fooo { +}; + +class afooo { + // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'afooo' + // CHECK-FIXES: {{^}}class Afooo {{{$}} +}; + +struct soo { + // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'soo' + // CHECK-FIXES: {{^}}struct Soo {{{$}} +}; _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
