[clang-tidy] Support IgnoredRegexp configuration to selectively suppress identifier naming checks

[smhc]

Summary

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.

[njames93]

Overall pretty good with this, but i feel the name should be ShortNameThreshold, WDYT?

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

176

Best to use the literal here to make sure we use the unsigned version of Options.get

[smhc]

Thanks for the review! Agreed with suggestions, submitted updated diff.
Please note I do not have commit access to llvm. Regards.

[njames93]

Oh can you also update the release notes, there is already a largish list of changes to this check there.

[njames93]

Oh to run the test locally, run ninja check-clang-extra-clang-tidy think that's right.

[smhc]

I've updated the release notes and corrected the unit tests to be passing. Thanks again.

[njames93]

Should this be a NamingStyle option instead.
{key: readability-identifier-naming.ParameterShortSizeThreshold, value: 2}
WDYT?

[aaron.ballman]

In D90282#2391005, @njames93 wrote:

Should this be a NamingStyle option instead.
{key: readability-identifier-naming.ParameterShortSizeThreshold, value: 2}
WDYT?

I think that makes a lot of sense -- I can imagine wanting to enforce different identifier lengths depending on whether we're spelling a type name vs a local variable name, etc.

[smhc]

In D90282#2391360, @aaron.ballman wrote:

In D90282#2391005, @njames93 wrote:

Should this be a NamingStyle option instead.
{key: readability-identifier-naming.ParameterShortSizeThreshold, value: 2}
WDYT?

I think that makes a lot of sense -- I can imagine wanting to enforce different identifier lengths depending on whether we're spelling a type name vs a local variable name, etc.

I considered this but thought the configuration and documentation would be quite cumbersome. We could provide a global setting (as already done) and allow refining it further by type if needed? For what it's worth I only need it for local variables, I imagine that would be the main use case.

Or should we simply add this threshold to every type of name, similar to how suffix, prefix and case style have been done?

[aaron.ballman]

In D90282#2393019, @smhc wrote:

In D90282#2391360, @aaron.ballman wrote:

In D90282#2391005, @njames93 wrote:

Should this be a NamingStyle option instead.
{key: readability-identifier-naming.ParameterShortSizeThreshold, value: 2}
WDYT?

I think that makes a lot of sense -- I can imagine wanting to enforce different identifier lengths depending on whether we're spelling a type name vs a local variable name, etc.

I considered this but thought the configuration and documentation would be quite cumbersome. We could provide a global setting (as already done) and allow refining it further by type if needed? For what it's worth I only need it for local variables, I imagine that would be the main use case.

Or should we simply add this threshold to every type of name, similar to how suffix, prefix and case style have been done?

I think length of names matters differently in different contexts. I think three-letter identifiers as a class name should probably be a rarity, but may be more reasonable as a local variable. I think one-letter local variables are generally a bad thing, except for loop induction variables. That sort of thing. (And we may someday want to add more specific naming categories like "loop induction variable".) So I think adding the threshold to all the different name kinds is a more flexible approach.

[smhc]

I updated it to use XXShortSizeThreshold.

But I was thinking.. perhaps a more generic approach could be "xxIgnoreRegex", this would allow you to do things such as :

VariableIgnoreRegex: ([a-z]{2}|index)
ClassIgnoreRegex: (Special_CASE|CommonOther.*)
etc.

it would be more generic while also allowing for excluding short names.

[smhc]

Re-based to llvm master and re-diffed.

[aaron.ballman]

In D90282#2395956, @smhc wrote:

I updated it to use XXShortSizeThreshold.

But I was thinking.. perhaps a more generic approach could be "xxIgnoreRegex", this would allow you to do things such as :

VariableIgnoreRegex: ([a-z]{2}|index)
ClassIgnoreRegex: (Special_CASE|CommonOther.*)
etc.

it would be more generic while also allowing for excluding short names.

I don't have a strong opinion on that approach. It would be a more flexible approach and that's appealing, but it also means writing regular expressions which is a bit unappealing because those aren't obvious to everyone and it's unclear what the performance characteristics would be of running those regexes on every identifier in the program. I'm curious if @alexfh or @njames93 (or others) have opinions on this.

[njames93]

In D90282#2405615, @aaron.ballman wrote:

I don't have a strong opinion on that approach. It would be a more flexible approach and that's appealing, but it also means writing regular expressions which is a bit unappealing because those aren't obvious to everyone and it's unclear what the performance characteristics would be of running those regexes on every identifier in the program. I'm curious if @alexfh or @njames93 (or others) have opinions on this.

For the record, when profiling this (and other RenamerClangTidy based checks) are the slowest(by some margin) checks to run.
This check also uses regex to determine if identifiers are correctly named and to split words in identifiers if they need changing.
Based off that I don't think there is huge performance concerns for using a regex for a couple of styles.

[smhc]

Regexes may be a bit of a slippery slope as any identifier scheme could be represented as a regex (casing, prefix, suffix etc) but it's not practical to provide a fix or suggestion with a regex.
For example with a 'ShortThreshold' a fix could offer to change the casing/xffix or to trim the variable length. With a regex it's less about making a naming rule and more about providing a workaround for problematic edge cases. As such should be used sparingly.

I think the difficulty in writing them is not too much of a deal breaker. Providing an example for the equivalent config options would be just as useful as the config option itself. e.g

"For example, to ignore names with a length less than 3 use: \w{1,3}' "

I assume the ^ and $ would be implied by the matcher. If they want anything more complex they'd be effectively asking for regex support anyway.

[smhc]

Updated diff to use 'IgnoredRegexp'
I see that a regexp has been used elsewhere for some other checks (macro usage, AllowedRegexp).

(as a side note, I see that AllowedRegexp string is getting compiled on every match rather than pre-compiling, the lack of a copy constructor on llvm::Regex makes it trickier to work with)

[smhc]

removed notes on short length threshold

[njames93]

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

141–143

Making this change removes the need to NamingStyle to be copy constructable/assignable.

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

61

Potentially save an allocation.

Also is it wise to warn a user on an invalid regex, unfortunately clang-tidy doesnt support diags with no source location but could still output to llvm::errs.

[smhc]

Updated after review comments.

[njames93]

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

134–137

Elide braces on single statement if.

138–141

IgnoredRegexp will be default constructed anyway, so this doesn't add anything.

[smhc]

Updated after review comments.

[smhc]

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

141–143

Thanks - was looking for a solution to this.

[aaron.ballman]

LGTM, but please wait for @njames93 in case they have additional feedback.

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

64

[njames93]

LGTM, before you push this, can you edit the summary and title as its no longer about just the length of the name. Otherwise the commit message will likely lead to confusion on whats being added.

[smhc]

Fixed uk/us spelling difference as suggested

[smhc]

Thanks for the reviews everyone, I have updated the title and summary.
Unfortunately I don't have push access to llvm - could someone help to push this please?

[njames93]

Just one last small nit.

// You can ignore this, nothing to do with this patch.
All these changes in the documentation tell me we should probably restructure the documentation for this check.
Right now we have NxM lines of documentation for each combination of style kind(N) and style option(M).
This could probably be changed so we could describe each style option at the top of the documentation (<StyleKind>Case, <StyleKind> Prefix, ...)
Then we could describe each StyleKind afterwards.

.. option:: ClassCase, option::ClassPrefix...

Transforms class names
.. code-block:: c++

    class <Ident> {
    };

.. option:: FunctionCase, option::FunctionPrefix...

Transforms class names
.. code-block:: c++

    void <Ident>(int Param0);

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

149

Dont need to use str() here

[smhc]

Removed unnecessary str()

[smhc]

Yes I thought the same wrt the doco. There is also a hungarian notation config option in the works which does the same thing.

I nearly reworked it but figured it would be best done under a separate patch

It does have the potential to be less searchable through google for specific options. Automatic generation could be used instead if that is a problem.

[smhc]

There's a build failure from this merge, looks like a typo:

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 b744d21b6ff8..68c0abfcbdf6 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
@@ -680,7 +680,7 @@ After:

When defined, the check will ensure enumeration names will add the
prefixed with the given value (regardless of casing).

-.. option:: EnumConstantIgnoredRegexp
+.. option:: EnumIgnoredRegexp

Identifier naming checks won't be enforced for enumeration names
matching this regular expression.

[smhc]

clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst

683

[aaron.ballman]

In D90282#2415189, @smhc wrote:

There's a build failure from this merge, looks like a typo:

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 b744d21b6ff8..68c0abfcbdf6 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
@@ -680,7 +680,7 @@ After:

When defined, the check will ensure enumeration names will add the
prefixed with the given value (regardless of casing).

-.. option:: EnumConstantIgnoredRegexp
+.. option:: EnumIgnoredRegexp

Identifier naming checks won't be enforced for enumeration names
matching this regular expression.

I've corrected this in ed242da0ffa28493d8a5ee6b80ecbe2441ca48a7, thanks!

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

enum CaseType {
     CT_CamelSnakeCase,
     CT_CamelSnakeBack
   };
 
   struct NamingStyle {
     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 {
     FileStyle() : IsActive(false), IgnoreMainLikeFunctions(false) {}
     FileStyle(SmallVectorImpl<Optional<NamingStyle>> &&Styles,
               bool IgnoreMainLike)
         : Styles(std::move(Styles)), IsActive(true),
           IgnoreMainLikeFunctions(IgnoreMainLike) {}

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

 #define STRINGIZE(v) #v,
   NAMING_KEYS(STRINGIZE)
 #undef STRINGIZE
 };
 
 #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.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     std::string Postfix(Options.get(StyleString, ""));
     memcpy(&StyleString[StyleSize], "Case", 4);
     StyleString.pop_back();
     StyleString.pop_back();
     auto CaseOptional =
         Options.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};
 }
 
 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : RenamerClangTidyCheck(Name, Context), Context(Context), CheckName(Name),
       GetConfigPerFile(Options.get("GetConfigPerFile", true)),
       IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)) {
 
   auto IterAndInserted = NamingStylesCache.try_emplace(
       llvm::sys::path::parent_path(Context->getCurrentFile()),
       getFileStyleFromOptions(Options));
   assert(IterAndInserted.second && "Couldn't insert Style");
   // Holding a reference to the data in the vector is safe as it should never
   // move.
   MainFileStyle = &IterAndInserted.first->getValue();
 }
 
 IdentifierNamingCheck::~IdentifierNamingCheck() = default;
 
 void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   RenamerClangTidyCheck::storeOptions(Opts);
   SmallString<64> StyleString;
   ArrayRef<llvm::Optional<NamingStyle>> Styles = MainFileStyle->getStyles();
   for (size_t I = 0; I < SK_Count; ++I) {
     if (!Styles[I])
       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.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     Options.store(Opts, StyleString, Styles[I]->Suffix);
     if (Styles[I]->Case) {
       memcpy(&StyleString[StyleSize], "Case", 4);
       StyleString.pop_back();
       StyleString.pop_back();
       Options.store(Opts, StyleString, *Styles[I]->Case);
     }
   }
   Options.store(Opts, "GetConfigPerFile", GetConfigPerFile);
   Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
   Options.store(Opts, "IgnoreMainLikeFunctions",
                 MainFileStyle->isIgnoringMainLikeFunction());
 }
 
 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_]*$"),
       llvm::Regex("^[a-z][a-zA-Z0-9]*$"),
       llvm::Regex("^[A-Z][A-Z0-9_]*$"),
       llvm::Regex("^[A-Z][a-zA-Z0-9]*$"),
       llvm::Regex("^[A-Z]([a-z0-9]*(_[A-Z])?)*"),
       llvm::Regex("^[a-z]([a-z0-9]*(_[A-Z])?)*"),

 static llvm::Optional<RenamerClangTidyCheck::FailureInfo> getFailureInfo(
     StringRef Name, SourceLocation Location,
     ArrayRef<llvm::Optional<IdentifierNamingCheck::NamingStyle>> NamingStyles,
     StyleKind SK, const SourceManager &SM, bool IgnoreFailedSplit) {
   if (SK == SK_Invalid || !NamingStyles[SK])
     return None;
 
   const IdentifierNamingCheck::NamingStyle &Style = *NamingStyles[SK];
+  if (Style.IgnoredRegexp.isValid() && Style.IgnoredRegexp.match(Name))
+    return None;
+
   if (matchesStyle(Name, Style))
     return None;
 
   std::string KindName =
       fixupWithCase(StyleNames[SK], IdentifierNamingCheck::CT_LowerCase);
   std::replace(KindName.begin(), KindName.end(), '_', ' ');
 
   std::string Fixup = fixupWithStyle(Name, Style);

clang-tools-extra/docs/ReleaseNotes.rst

- Improved :doc:`readability-identifier-naming
   different naming styles.
 
   Now renames overridden virtual methods if the method they override has a
   style violation.
   
   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.
 
 - Improved :doc:`readability-redundant-string-init
   <clang-tidy/checks/readability-redundant-string-init>` check.
 
   Added `std::basic_string_view` to default list of ``string``-like types.
 

clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst

 but not where they are overridden, as it can't be fixed locally there.
 This also applies for pseudo-override patterns like CRTP.
 
 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
 
     When defined, the check will ensure abstract class names conform to the
     selected casing.
 
 .. option:: AbstractClassPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - AbstractClassCase of ``lower_case``
.. option:: ClassCase
     When defined, the check will ensure class names conform to the
     selected casing.
 
 .. option:: ClassPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ClassCase of ``lower_case``
.. option:: ClassConstantCase
     When defined, the check will ensure class constant names conform to the
     selected casing.
 
 .. option:: ClassConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ClassConstantCase of ``lower_case``
.. option:: ClassMemberCase
     When defined, the check will ensure class member names conform to the
     selected casing.
 
 .. option:: ClassMemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ClassMemberCase of ``lower_case``
.. option:: ClassMethodCase
     When defined, the check will ensure class method names conform to the
     selected casing.
 
 .. option:: ClassMethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ClassMethodCase of ``lower_case``
.. option:: ConstantCase
     When defined, the check will ensure constant names conform to the
     selected casing.
 
 .. option:: ConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstantCase of ``lower_case``
.. option:: ConstantMemberCase
     When defined, the check will ensure constant member names conform to the
     selected casing.
 
 .. option:: ConstantMemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstantMemberCase of ``lower_case``
.. option:: ConstantParameterCase
     When defined, the check will ensure constant parameter names conform to the
     selected casing.
 
 .. option:: ConstantParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstantParameterCase of ``lower_case``
.. option:: ConstantPointerParameterCase
     When defined, the check will ensure constant pointer parameter names conform to the
     selected casing.
 
 .. option:: ConstantPointerParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstantPointerParameterCase of ``lower_case``
.. option:: ConstexprFunctionCase
     When defined, the check will ensure constexpr function names conform to the
     selected casing.
 
 .. option:: ConstexprFunctionPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstexprFunctionCase of ``lower_case``
.. option:: ConstexprMethodCase
     When defined, the check will ensure constexpr method names conform to the
     selected casing.
 
 .. option:: ConstexprMethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstexprMethodCase of ``lower_case``
.. option:: ConstexprVariableCase
     When defined, the check will ensure constexpr variable names conform to the
     selected casing.
 
 .. option:: ConstexprVariablePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ConstexprVariableCase of ``lower_case``
.. option:: EnumCase
     When defined, the check will ensure enumeration names conform to the
     selected casing.
 
 .. option:: EnumPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - EnumCase of ``lower_case``
.. option:: EnumConstantCase
     When defined, the check will ensure enumeration constant names conform to the
     selected casing.
 
 .. option:: EnumConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - EnumConstantCase of ``lower_case``
.. option:: FunctionCase
     When defined, the check will ensure function names conform to the
     selected casing.
 
 .. option:: FunctionPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - FunctionCase of ``lower_case``
.. option:: GlobalConstantCase
     When defined, the check will ensure global constant names conform to the
     selected casing.
 
 .. option:: GlobalConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - GlobalConstantCase of ``lower_case``
.. option:: GlobalConstantPointerCase
     When defined, the check will ensure global constant pointer names conform to the
     selected casing.
 
 .. option:: GlobalConstantPointerPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - GlobalConstantPointerCase of ``lower_case``
.. option:: GlobalFunctionCase
     When defined, the check will ensure global function names conform to the
     selected casing.
 
 .. option:: GlobalFunctionPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - GlobalFunctionCase of ``lower_case``
.. option:: GlobalPointerCase
     When defined, the check will ensure global pointer names conform to the
     selected casing.
 
 .. option:: GlobalPointerPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - GlobalPointerCase of ``lower_case``
.. option:: GlobalVariableCase
     When defined, the check will ensure global variable names conform to the
     selected casing.
 
 .. option:: GlobalVariablePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - GlobalVariableCase of ``lower_case``
.. option:: InlineNamespaceCase
     When defined, the check will ensure inline namespaces names conform to the
     selected casing.
 
 .. option:: InlineNamespacePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - InlineNamespaceCase of ``lower_case``
.. option:: LocalConstantCase
     When defined, the check will ensure local constant names conform to the
     selected casing.
 
 .. option:: LocalConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - LocalConstantCase of ``lower_case``
.. option:: LocalConstantPointerCase
     When defined, the check will ensure local constant pointer names conform to the
     selected casing.
 
 .. option:: LocalConstantPointerPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - LocalConstantPointerCase of ``lower_case``
.. option:: LocalPointerCase
     When defined, the check will ensure local pointer names conform to the
     selected casing.
 
 .. option:: LocalPointerPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - LocalPointerCase of ``lower_case``
.. option:: LocalVariableCase
     When defined, the check will ensure local variable names conform to the
     selected casing.
 
 .. option:: LocalVariablePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - LocalVariableCase of ``lower_case``
.. option:: MacroDefinitionCase
     When defined, the check will ensure macro definitions conform to the
     selected casing.
 
 .. option:: MacroDefinitionPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - MacroDefinitionCase of ``lower_case``
.. option:: MemberCase
     When defined, the check will ensure member names conform to the
     selected casing.
 
 .. option:: MemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - MemberCase of ``lower_case``
.. option:: MethodCase
     When defined, the check will ensure method names conform to the
     selected casing.
 
 .. option:: MethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - MethodCase of ``lower_case``
.. option:: NamespaceCase
     When defined, the check will ensure namespace names conform to the
     selected casing.
 
 .. option:: NamespacePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - NamespaceCase of ``lower_case``
.. option:: ParameterCase
     When defined, the check will ensure parameter names conform to the
     selected casing.
 
 .. option:: ParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ParameterCase of ``lower_case``
.. option:: ParameterPackCase
     When defined, the check will ensure parameter pack names conform to the
     selected casing.
 
 .. option:: ParameterPackPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ParameterPackCase of ``lower_case``
.. option:: PointerParameterCase
     When defined, the check will ensure pointer parameter names conform to the
     selected casing.
 
 .. option:: PointerParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - PointerParameterCase of ``lower_case``
.. option:: PrivateMemberCase
     When defined, the check will ensure private member names conform to the
     selected casing.
 
 .. option:: PrivateMemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - PrivateMemberCase of ``lower_case``
.. option:: PrivateMethodCase
     When defined, the check will ensure private method names conform to the
     selected casing.
 
 .. option:: PrivateMethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - PrivateMethodCase of ``lower_case``
.. option:: ProtectedMemberCase
     When defined, the check will ensure protected member names conform to the
     selected casing.
 
 .. option:: ProtectedMemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ProtectedMemberCase of ``lower_case``
.. code-block:: c++
 
     class Foo {
     protected:
       int pre_member_variable_post;
     }
 
 .. 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:
 
    - ProtectedMethodCase of ``lower_case``
    - ProtectedMethodPrefix of ``pre_``
    - ProtectedMethodSuffix of ``_post``
 
.. option:: PublicMemberCase
     When defined, the check will ensure public member names conform to the
     selected casing.
 
 .. option:: PublicMemberPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - PublicMemberCase of ``lower_case``
.. option:: PublicMethodCase
     When defined, the check will ensure public method names conform to the
     selected casing.
 
 .. option:: PublicMethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - PublicMethodCase of ``lower_case``
.. option:: ScopedEnumConstantCase
     When defined, the check will ensure scoped enum constant names conform to 
     the selected casing.
 
 .. option:: ScopedEnumConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ScopedEnumConstantCase of ``lower_case``
.. option:: StaticConstantCase
     When defined, the check will ensure static constant names conform to the
     selected casing.
 
 .. option:: StaticConstantPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - StaticConstantCase of ``lower_case``
.. option:: StaticVariableCase
     When defined, the check will ensure static variable names conform to the
     selected casing.
 
 .. option:: StaticVariablePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - StaticVariableCase of ``lower_case``
.. option:: StructCase
     When defined, the check will ensure struct names conform to the
     selected casing.
 
 .. option:: StructPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - StructCase of ``lower_case``
.. option:: TemplateParameterCase
     When defined, the check will ensure template parameter names conform to the
     selected casing.
 
 .. option:: TemplateParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - TemplateParameterCase of ``lower_case``
.. option:: TemplateTemplateParameterCase
     When defined, the check will ensure template template parameter names conform to the
     selected casing.
 
 .. option:: TemplateTemplateParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - TemplateTemplateParameterCase of ``lower_case``
.. option:: TypeAliasCase
     When defined, the check will ensure type alias names conform to the
     selected casing.
 
 .. option:: TypeAliasPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - TypeAliasCase of ``lower_case``
.. option:: TypedefCase
     When defined, the check will ensure typedef names conform to the
     selected casing.
 
 .. option:: TypedefPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - TypedefCase of ``lower_case``
.. option:: TypeTemplateParameterCase
     When defined, the check will ensure type template parameter names conform to the
     selected casing.
 
 .. option:: TypeTemplateParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - TypeTemplateParameterCase of ``lower_case``
.. option:: UnionCase
     When defined, the check will ensure union names conform to the
     selected casing.
 
 .. option:: UnionPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - UnionCase of ``lower_case``
.. option:: ValueTemplateParameterCase
     When defined, the check will ensure value template parameter names conform to the
     selected casing.
 
 .. option:: ValueTemplateParameterPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - ValueTemplateParameterCase of ``lower_case``
.. option:: VariableCase
     When defined, the check will ensure variable names conform to the
     selected casing.
 
 .. option:: VariablePrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - VariableCase of ``lower_case``
.. option:: VirtualMethodCase
     When defined, the check will ensure virtual method names conform to the
     selected casing.
 
 .. option:: VirtualMethodPrefix
 
     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
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - VirtualMethodCase of ``lower_case``

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-ignored-regexp.cpp

+// 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 {{{$}}
+};