[clang-tidy] Support IgnoredRegexp configuration to selectively suppress identifier...
authorsmhc <shanehird@gmail.com>
Wed, 25 Nov 2020 01:18:38 +0000 (01:18 +0000)
committerNathan James <n.james93@hotmail.co.uk>
Wed, 25 Nov 2020 01:18:44 +0000 (01:18 +0000)
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

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
clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp [new file with mode: 0644]

index d7160d5..efc683c 100644 (file)
@@ -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;
 
index 77c03f7..565eb9d 100644 (file)
@@ -52,12 +52,18 @@ public:
     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 {
index c99a589..46bb36c 100644 (file)
@@ -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.
 
index 036103e..b744d21 100644 (file)
@@ -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 (file)
index 0000000..e99edff
--- /dev/null
@@ -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 {{{$}}
+};