Add new IdentifierNaming check

[berenm]

Summary

This check will try to enforce coding guidelines on the identifiers naming.
It supports lower_case, UPPER_CASE, camelBack and CamelCase casing and
tries to convert from one to another if a mismatch is detected.

It also supports a fixed prefix and suffix that will be prepended or appended
to the identifiers, regardless of the casing.

Many configuration options are available, in order to be able to create
different rules for different kind of identifier. In general, the
rules are falling back to a more generic rule if the specific case is not
configured.

[alexfh]

Some initial comments, mostly style-related. It takes some time to get used to the coding style used in LLVM/Clang. One notable thing: though we use auto sometimes, we don't use the almost-always-auto style. Please see the inline comments for specific cases.

clang-tidy/readability/IdentifierNamingCheck.cpp

64

I'd name this StyleKind as most other enums in the LLVM code.

70

The only use of this array seems to be a simplification of a single loop (the other one can iterate over StyleNames as per the comment below). I'd remove it and instead added a "StyleKindCount" element in the enum and use a normal for loop.

88

This could be written nicer using llvm::StringSwitch.

88

Not sure why we would need alternative spellings of these options. That seems to just add complexity with no benefit.

106

Why not iterate over StyleNames here?

152

No need to cast ValueDecl returned by DeclRefExpr::getDecl() to its base class.

174

Please move the detection of the KindName and Style to a separate function. This method is too large.

177

Please resolve the node only once (as it's done on line 168) and then just check it using isa<...>(...).

179

Would it be better to have these in a single array next to StyleNames? Also, this code could return a StyleKind (now StyleConst), and you would need to get the corresponding NamingStyle and KindName once.

This code would suddenly become much leaner.

191

Please remove empty lines before }.

476

Please make this a function. This method is too large to define every utility function inside it.

478

No need to explicitly convert to StringRef here as well.

506

Please make this a function. This method is too large to define every utility function inside it.

506

Please make Name a StringRef.

507

This doesn't look like a valid use case for auto. static llvm::Regex Splitter(...); is shorter and more readable.

Same applies to Words, Substrs and Groups below.

Also, you don't need to explicitly create a StringRef, just leave the string literal.

510

Why not a SmallVector<StringRef,...>?

513

I think, this may be a StringRef.

520

The use of std::move here doesn't make sense to me: Groups[...] is a StringRef, which isn't moved faster than it is copied.

582

We use auto when the type is spelled in the initializer and in a few other cases, e.g. when iterating over a map, and the element type is somewhat tricky to spell correctly. In other cases please use concrete types.

608

clang::DeclarationNameInfo DeclRange(...) is better, IMO.

611

nit: Diagn is not a common abbreviation in clang-tidy code. Diag would be better.

clang-tidy/readability/IdentifierNamingCheck.h

43

I don't see what you gain by using std::move here. How about changing the type of Prefix and Suffix to const std::string & and getting rid of std::move? That's a more common pattern.

test/clang-tidy/readability-identifier-naming.cpp

2

I recently learned that RUN: lines can be split:

// RUN: some-long-command ... \
// RUN:   -command-continues ... \
// RUN:   -command-continues ... \
// RUN:   -command-continues ... \
// RUN:   -command-continues ... \
// RUN:   finally-done

9

No need to repeat the check name in each message ( [readability-identifier-naming]). It's enough to have it in the first CHECK-MESSAGES line. All other CHECK-MESSAGES lines can omit it.

[berenm]

Thanks for the review, I will fix the various style issues and come back with an updated version.

clang-tidy/readability/IdentifierNamingCheck.cpp

88

The idea was to provide a way easier to type than the full names. This may not be very useful, and maybe a single simple name for each case scheme would be enough.

179

The problem is that sometimes, the current code falls back to a more generic naming style, but the "kind name" is still trying to describe the original declaration.

For example, if no style is defined for methods, then it will try to use a more generic "function" style, but the warning will still be "invalid case style for method xxx".

Maybe this is superfluous and I can drop it. It don't see many cases anyway (my original code was covering more cases - too many - and it seemed sensible at that time).

513

I think I had some issues when trying to use StringRef around here, I will investigate a bit more.

[alexfh]

clang-tidy/readability/IdentifierNamingCheck.cpp

88

Clang-tidy options are usually read from a file, so minimizing typing is not really important.

179

The problem is that sometimes, the current code falls back to a more
generic naming style, but the "kind name" is still trying to describe the
original declaration.

I see. It might be possible to split the mapping of types to style kinds and handling missing styles. E.g. a function can return "Method" (which should be SK_Method according to [1], btw) and then a caller would check whether the corresponding NamingStyle is configured, and if needed fall back to a more generic category. WDYT?

[1] http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

[berenm]

clang-tidy/readability/IdentifierNamingCheck.cpp

179

I think it would be difficult to map the declaration types to style kinds without checking the styles that have been provided and falling back to another style at the same time.

For example, a constexpr method is currently selecting the styles in this preferred order :
constexpr method > [public/protected/private] method > method > function.

The order is debatable, but we cannot have the constexpr method to public/protected/private method fallback, if there is no style for constexpr methods, without reading again the method declaration.

It might be OK that the warning message do not use the exact identifier kind name, and one can even think it is better to have a warning message that tells the user which style it used instead of which kind of identifier was checked.

[alexfh]

clang-tidy/readability/IdentifierNamingCheck.cpp

179

we cannot have the constexpr method to public/protected/private method fallback, if there is no style for
constexpr methods, without reading again the method declaration.

So the issue is caused by the fact that the categories are partially overlapping and don't form a hierarchy. Not sure whether this is convenient for the end-user and if it's a good model, but this can fit into the approach: the function can return an ordered list of StyleKinds that could then be looked up in the configured NamingStyles. I don't insist on this specific implementation, but it might end up being more elegant solution.

[berenm]

Here is an updated version with some style fixes, and function splits.

The styles are still selected the same way as before (no split between finding the best type style and falling back to available style), but there is only the StyleKind returned and the warning message is deduced from the StyleNames (lower case conversion and underscores replaced with spaces).

I can still implement the mechanism suggested in comment http://reviews.llvm.org/D10933#218645 if you find it is cleaner.

[berenm]

clang-tidy/readability/IdentifierNamingCheck.cpp

514

I replaced with StringRef everywhere it looked sensible and the functions return a std::string, as they are constructing a new string when computing the fixup.

576

DeclRange is actually the SourceRange and not the DeclarationNameInfo

[alexfh]

Sorry for the delay. A few more comments, otherwise looks really nice.

clang-tidy/readability/IdentifierNamingCheck.cpp

167

Why do you need the outermost parentheses?

182

nit: Please remove the empty lines before closing braces.

534

That doesn't seem like a useful warning message. If the tool didn't manage to understand the naming style, it may be interesting to the tool developer, but not to a user. Please make this a DEBUG(llvm::dbgs() << ...).

540

clang:: is superfluous here, the code is already inside the clang namespace.

555

What does P stand for? I'd prefer a more meaningful name for the loop variable.

[berenm]

clang-tidy/readability/IdentifierNamingCheck.cpp

167

For some unknown reason, I always thought parentheses were required around regex alternation... Well, I now know they are not.

[berenm]

Here is an updated version with the latest comments fixed.

[alexfh]

Looks good with a couple of comments. Tell me if you need me to submit the patch for you, once you address the comments.

Thank you for the awesome new check!

clang-tidy/readability/IdentifierNamingCheck.cpp

154

nit: Maybe remove the bool variable and just return false; instead of Matches = false;?

if (Name.startswith(Style.Prefix))
  Name = Name.drop_front(Style.Prefix.size());
else
  return false;

if (Name.endswith(Style.Suffix))
  Name = Name.drop_back(Style.Suffix.size());
else
  return false;

return Matchers[static_cast<size_t>(Style.Case)].match(Name);

test/clang-tidy/readability-identifier-naming.cpp

71

Looking at the tests once again, I find that they should be more strict. E.g. the presence of foo_ns doesn't say anything about whether the replacement was done in the right place (e.g. if the code replaces a wrong token and the result is foo_ns FOO_NS {, the test would pass). Please add more context to the CHECK-FIXES lines, maybe even whole lines including start- and end-of-line anchors ({{^}} and {{$}} respectively).

Thanks!

[berenm]

In D10933#225671, @alexfh wrote:

Looks good with a couple of comments. Tell me if you need me to submit the patch for you, once you address the comments.

If you tell me how I should proceed, I can maybe do it myself (do I just have to send the patch to the cfe-commits list ?).

[alexfh]

In D10933#225678, @berenm wrote:

In D10933#225671, @alexfh wrote:

Looks good with a couple of comments. Tell me if you need me to submit the patch for you, once you address the comments.

If you tell me how I should proceed, I can maybe do it myself (do I just have to send the patch to the cfe-commits list ?).

The question was whether you have commit rights to the LLVM Subversion repository. Apparently, no, so someone needs to commit the patch for you. I'll happily do so once you update it.

[berenm]

Indeed, I probably don't have rights on Clang/LLVM repositories.

I have updated the patch with stricter tests - and found a missing break statement (clang-tidy/readability/IdentifierNamingCheck.cpp:201).

I also realized that the DeclRefExpr matcher used to find references to declared identifiers is only matching references to values and not to classes.

For example, when referencing the class in the out-of-line class static member declaration (test/clang-tidy/readability-identifier-naming.cpp:133 and test/clang-tidy/readability-identifier-naming.cpp:136), or when using a class identifier as the type of a typedef, (test/clang-tidy/readability-identifier-naming.cpp:243). Or even when declaring a variable of a type whose name must be fixed.

Is there any matcher that could be used for finding references to a TypeDecl? Should I go through calls to getDeclContext, getType, or getUnderlyingType depending on the context? Any easier way I don't know about?

[alexfh]

In D10933#225696, @berenm wrote:

Indeed, I probably don't have rights on Clang/LLVM repositories.

I have updated the patch with stricter tests - and found a missing break statement (clang-tidy/readability/IdentifierNamingCheck.cpp:201).

Behold the magic power of testing ;)

I also realized that the DeclRefExpr matcher used to find references to declared identifiers is only matching references to values and not to classes.

For example, when referencing the class in the out-of-line class static member declaration (test/clang-tidy/readability-identifier-naming.cpp:133 and test/clang-tidy/readability-identifier-naming.cpp:136), or when using a class identifier as the type of a typedef, (test/clang-tidy/readability-identifier-naming.cpp:243). Or even when declaring a variable of a type whose name must be fixed.

Is there any matcher that could be used for finding references to a TypeDecl? Should I go through calls to getDeclContext, getType, or getUnderlyingType depending on the context? Any easier way I don't know about?

Yep, renaming classes is not as trivial as it might seem. You'll need to look for TypeLocs (the loc() matcher) of QualTypes and NestedNameSpecifiers referring to the old class name. You'd also need to match constructor declarations and UsingDecls separately.

Here's a rough list of matchers that search for the name of a class:

loc(qualType(hasDeclaration(namedDecl(hasName(old_class)))))
loc(nestedNameSpecifier(specifiesType(
              hasDeclaration(recordDecl(hasName(old_class))))))
usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(hasName(old_class))))
recordDecl(hasName(old_class))
constructorDecl(ofClass(hasName(old_class)))

I suggest that you add a bunch of FIXMEs in the test and we can iterate on the check in follow-up patches. Similar issues apply to namespace and function renaming.

What needs to be tested:

• for classes: forward declarations, definitions, constructors, destructors, using declarations, type aliases, use of the class name in new, casting, qualified names (Class::member) (also resulting from injected class name usage - Class::Class::Class), use of the class name in templates and macros (to ensure there are no duplicate or incorrect fixes), and probably something else that I forgot.
• for functions/methods: declarations, calls, using declarations, taking address of, with qualified names and without, probably something else.
• for namespaces: use in qualified names and using declarations and directives.

[berenm]

Alright!

Here is the latest revision then, with FIXMEs comments mentioning this missing feature. I will work on implementing it and come back to you when i've got something working.

Thanks for your time and your advices!

[alexfh]

Another couple of comments (fine for a follow-up).

test/clang-tidy/readability-identifier-naming.cpp

72

Please add a test (with a CHECK-FIXES or a FIXME) for the usages of a namespace in qualified names (e.g. ::foo_ns::inline_namespace::my_enumeration).

209

Add a FIXME or a CHECK-FIXES for the class name in destructor.

[alexfh]

Committed revision 245429.

clang-tidy/readability/CMakeLists.txt

   ContainerSizeEmptyCheck.cpp
   ElseAfterReturnCheck.cpp
   FunctionSizeCheck.cpp
+  IdentifierNamingCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   ReadabilityTidyModule.cpp

clang-tidy/readability/IdentifierNamingCheck.h

+//===--- IdentifierNamingCheck.h - clang-tidy -------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// \brief Checks for identifiers naming style mismatch.
+class IdentifierNamingCheck : public ClangTidyCheck {
+public:
+  IdentifierNamingCheck(StringRef Name, ClangTidyContext *Context);
+
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void onEndOfTranslationUnit() override;
+
+  enum CaseType {
+    CT_AnyCase = 0,
+    CT_LowerCase,
+    CT_CamelBack,
+    CT_UpperCase,
+    CT_CamelCase,
+  };
+
+  struct NamingStyle {
+    NamingStyle() : Case(CT_AnyCase) {}
+
+    NamingStyle(CaseType Case, const std::string &Prefix,
+                const std::string &Suffix)
+        : Case(Case), Prefix(Prefix), Suffix(Suffix) {}
+
+    CaseType Case;
+    std::string Prefix;
+    std::string Suffix;
+
+    bool isSet() const {
+      return !(Case == CT_AnyCase && Prefix.empty() && Suffix.empty());
+    }
+  };
+
+private:
+  std::vector<NamingStyle> NamingStyles;
+  bool IgnoreFailedSplit;
+
+  struct NamingCheckFailure {
+    std::string KindName;
+    std::string Fixup;
+    bool ShouldFix;
+    std::vector<SourceRange> Usages;
+
+    NamingCheckFailure() : ShouldFix(true) {}
+  };
+
+  llvm::DenseMap<const NamedDecl *, NamingCheckFailure> NamingCheckFailures;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H

clang-tidy/readability/IdentifierNamingCheck.cpp

+//===--- IdentifierNamingCheck.cpp - clang-tidy ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "IdentifierNamingCheck.h"
+
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+#define NAMING_KEYS(m) \
+    m(Namespace) \
+    m(InlineNamespace) \
+    m(EnumConstant) \
+    m(ConstexprVariable) \
+    m(ConstantMember) \
+    m(PrivateMember) \
+    m(ProtectedMember) \
+    m(PublicMember) \
+    m(Member) \
+    m(ClassConstant) \
+    m(ClassMember) \
+    m(GlobalConstant) \
+    m(GlobalVariable) \
+    m(LocalConstant) \
+    m(LocalVariable) \
+    m(StaticConstant) \
+    m(StaticVariable) \
+    m(Constant) \
+    m(Variable) \
+    m(ConstantParameter) \
+    m(ParameterPack) \
+    m(Parameter) \
+    m(AbstractClass) \
+    m(Struct) \
+    m(Class) \
+    m(Union) \
+    m(Enum) \
+    m(GlobalFunction) \
+    m(ConstexprFunction) \
+    m(Function) \
+    m(ConstexprMethod) \
+    m(VirtualMethod) \
+    m(ClassMethod) \
+    m(PrivateMethod) \
+    m(ProtectedMethod) \
+    m(PublicMethod) \
+    m(Method) \
+    m(Typedef) \
+    m(TypeTemplateParameter) \
+    m(ValueTemplateParameter) \
+    m(TemplateTemplateParameter) \
+    m(TemplateParameter) \
+
+enum StyleKind {
+#define ENUMERATE(v) SK_ ## v,
+  NAMING_KEYS(ENUMERATE)
+#undef ENUMERATE
+  SK_Count,
+  SK_Invalid
+};
+
+static StringRef const StyleNames[] = {
+#define STRINGIZE(v) #v,
+  NAMING_KEYS(STRINGIZE)
+#undef STRINGIZE
+};
+
+#undef NAMING_KEYS
+
+IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
+                                             ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context) {
+  auto const fromString = [](StringRef Str) {
+    return llvm::StringSwitch<CaseType>(Str)
+        .Case("lower_case", CT_LowerCase)
+        .Case("UPPER_CASE", CT_UpperCase)
+        .Case("camelBack", CT_CamelBack)
+        .Case("CamelCase", CT_CamelCase)
+        .Default(CT_AnyCase);
+  };
+
+  for (auto const &Name : StyleNames) {
+    NamingStyles.push_back(
+        NamingStyle(fromString(Options.get((Name + "Case").str(), "")),
+                    Options.get((Name + "Prefix").str(), ""),
+                    Options.get((Name + "Suffix").str(), "")));
+  }
+
+  IgnoreFailedSplit = Options.get("IgnoreFailedSplit", 0);
+}
+
+void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  auto const toString = [](CaseType Type) {
+    switch (Type) {
+    case CT_AnyCase:
+      return "aNy_CasE";
+    case CT_LowerCase:
+      return "lower_case";
+    case CT_CamelBack:
+      return "camelBack";
+    case CT_UpperCase:
+      return "UPPER_CASE";
+    case CT_CamelCase:
+      return "CamelCase";
+    }
+
+    llvm_unreachable("Unknown Case Type");
+  };
+
+  for (size_t i = 0; i < SK_Count; ++i) {
+    Options.store(Opts, (StyleNames[i] + "Case").str(),
+                  toString(NamingStyles[i].Case));
+    Options.store(Opts, (StyleNames[i] + "Prefix").str(),
+                  NamingStyles[i].Prefix);
+    Options.store(Opts, (StyleNames[i] + "Suffix").str(),
+                  NamingStyles[i].Suffix);
+  }
+
+  Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
+}
+
+void IdentifierNamingCheck::registerMatchers(MatchFinder *Finder) {
+// FIXME: For now, only Decl and DeclRefExpr nodes are visited for checking and
+// replacement. There is a lot of missing cases, such as references to a class
+// name (as in 'const int CMyClass::kClassConstant = 4;'), to an enclosing
+// context (namespace, class, etc).
+
+  Finder->addMatcher(namedDecl().bind("decl"), this);
+  Finder->addMatcher(declRefExpr().bind("declref"), this);
+}
+
+static bool matchesStyle(StringRef Name,
+                         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]*$"),
+  };
+
+  bool Matches = true;
+  if (Name.startswith(Style.Prefix))
+    Name = Name.drop_front(Style.Prefix.size());
+  else
+    Matches = false;
+
+  if (Name.endswith(Style.Suffix))
+    Name = Name.drop_back(Style.Suffix.size());
+  else
+    Matches = false;
+
+  if (!Matchers[static_cast<size_t>(Style.Case)].match(Name))
+    Matches = false;
+
+  return Matches;
+}
+
+static std::string fixupWithCase(StringRef Name,
+                                 IdentifierNamingCheck::CaseType Case) {
+  static llvm::Regex Splitter(
+      "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
+
+  SmallVector<StringRef, 8> Substrs;
+  Name.split(Substrs, "_", -1, false);
+
+  SmallVector<StringRef, 8> Words;
+  for (auto Substr : Substrs) {
+    while (!Substr.empty()) {
+      SmallVector<StringRef, 8> Groups;
+      if (!Splitter.match(Substr, &Groups))
+        break;
+
+      if (Groups[2].size() > 0) {
+        Words.push_back(Groups[1]);
+        Substr = Substr.substr(Groups[0].size());
+      } else if (Groups[3].size() > 0) {
+        Words.push_back(Groups[3]);
+        Substr = Substr.substr(Groups[0].size() - Groups[4].size());
+      } else if (Groups[5].size() > 0) {
+        Words.push_back(Groups[5]);
+        Substr = Substr.substr(Groups[0].size() - Groups[6].size());
+      }
+    }
+  }
+
+  if (Words.empty())
+    return Name;
+
+  std::string Fixup;
+  switch (Case) {
+  case IdentifierNamingCheck::CT_AnyCase:
+    Fixup += Name;
+    break;
+
+  case IdentifierNamingCheck::CT_LowerCase:
+    for (auto const &Word : Words) {
+      if (&Word != &Words.front())
+        Fixup += "_";
+      Fixup += Word.lower();
+    }
+    break;
+
+  case IdentifierNamingCheck::CT_UpperCase:
+    for (auto const &Word : Words) {
+      if (&Word != &Words.front())
+        Fixup += "_";
+      Fixup += Word.upper();
+    }
+    break;
+
+  case IdentifierNamingCheck::CT_CamelCase:
+    for (auto const &Word : Words) {
+      Fixup += Word.substr(0, 1).upper();
+      Fixup += Word.substr(1).lower();
+    }
+    break;
+
+  case IdentifierNamingCheck::CT_CamelBack:
+    for (auto const &Word : Words) {
+      if (&Word == &Words.front()) {
+        Fixup += Word.lower();
+      } else {
+        Fixup += Word.substr(0, 1).upper();
+        Fixup += Word.substr(1).lower();
+      }
+    }
+    break;
+  }
+
+  return Fixup;
+}
+
+static std::string fixupWithStyle(StringRef Name,
+                                  IdentifierNamingCheck::NamingStyle Style) {
+  return Style.Prefix + fixupWithCase(Name, Style.Case) + Style.Suffix;
+}
+
+static StyleKind findStyleKind(
+    const NamedDecl *D,
+    const std::vector<IdentifierNamingCheck::NamingStyle> &NamingStyles) {
+  if (isa<TypedefDecl>(D) && NamingStyles[SK_Typedef].isSet())
+    return SK_Typedef;
+
+  if (const auto *Decl = dyn_cast<NamespaceDecl>(D)) {
+    if (Decl->isAnonymousNamespace())
+      return SK_Invalid;
+
+    if (Decl->isInline() && NamingStyles[SK_InlineNamespace].isSet())
+      return SK_InlineNamespace;
+
+    if (NamingStyles[SK_Namespace].isSet())
+      return SK_Namespace;
+  }
+
+  if (isa<EnumDecl>(D) && NamingStyles[SK_Enum].isSet())
+    return SK_Enum;
+
+  if (isa<EnumConstantDecl>(D)) {
+    if (NamingStyles[SK_EnumConstant].isSet())
+      return SK_EnumConstant;
+
+    if (NamingStyles[SK_Constant].isSet())
+      return SK_Constant;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<CXXRecordDecl>(D)) {
+    if (Decl->isAnonymousStructOrUnion())
+      return SK_Invalid;
+
+    if (Decl->hasDefinition() && Decl->isAbstract() &&
+        NamingStyles[SK_AbstractClass].isSet())
+      return SK_AbstractClass;
+
+    if (Decl->isStruct() && NamingStyles[SK_Struct].isSet())
+      return SK_Struct;
+
+    if (Decl->isStruct() && NamingStyles[SK_Class].isSet())
+      return SK_Class;
+
+    if (Decl->isClass() && NamingStyles[SK_Class].isSet())
+      return SK_Class;
+
+    if (Decl->isClass() && NamingStyles[SK_Struct].isSet())
+      return SK_Struct;
+
+    if (Decl->isUnion() && NamingStyles[SK_Union].isSet())
+      return SK_Union;
+
+    if (Decl->isEnum() && NamingStyles[SK_Enum].isSet())
+      return SK_Enum;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<FieldDecl>(D)) {
+    QualType Type = Decl->getType();
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        NamingStyles[SK_ConstantMember].isSet())
+      return SK_ConstantMember;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        NamingStyles[SK_Constant].isSet())
+      return SK_Constant;
+
+    if (Decl->getAccess() == AS_private &&
+        NamingStyles[SK_PrivateMember].isSet())
+      return SK_PrivateMember;
+
+    if (Decl->getAccess() == AS_protected &&
+        NamingStyles[SK_ProtectedMember].isSet())
+      return SK_ProtectedMember;
+
+    if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMember].isSet())
+      return SK_PublicMember;
+
+    if (NamingStyles[SK_Member].isSet())
+      return SK_Member;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<ParmVarDecl>(D)) {
+    QualType Type = Decl->getType();
+
+    if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
+      return SK_ConstexprVariable;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        NamingStyles[SK_ConstantParameter].isSet())
+      return SK_ConstantParameter;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        NamingStyles[SK_Constant].isSet())
+      return SK_Constant;
+
+    if (Decl->isParameterPack() && NamingStyles[SK_ParameterPack].isSet())
+      return SK_ParameterPack;
+
+    if (NamingStyles[SK_Parameter].isSet())
+      return SK_Parameter;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<VarDecl>(D)) {
+    QualType Type = Decl->getType();
+
+    if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
+      return SK_ConstexprVariable;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        Decl->isStaticDataMember() && NamingStyles[SK_ClassConstant].isSet())
+      return SK_ClassConstant;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        Decl->isFileVarDecl() && NamingStyles[SK_GlobalConstant].isSet())
+      return SK_GlobalConstant;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        Decl->isStaticLocal() && NamingStyles[SK_StaticConstant].isSet())
+      return SK_StaticConstant;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        Decl->isLocalVarDecl() && NamingStyles[SK_LocalConstant].isSet())
+      return SK_LocalConstant;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        Decl->isFunctionOrMethodVarDecl() &&
+        NamingStyles[SK_LocalConstant].isSet())
+      return SK_LocalConstant;
+
+    if (!Type.isNull() && Type.isLocalConstQualified() &&
+        NamingStyles[SK_Constant].isSet())
+      return SK_Constant;
+
+    if (Decl->isStaticDataMember() && NamingStyles[SK_ClassMember].isSet())
+      return SK_ClassMember;
+
+    if (Decl->isFileVarDecl() && NamingStyles[SK_GlobalVariable].isSet())
+      return SK_GlobalVariable;
+
+    if (Decl->isStaticLocal() && NamingStyles[SK_StaticVariable].isSet())
+      return SK_StaticVariable;
+
+    if (Decl->isLocalVarDecl() && NamingStyles[SK_LocalVariable].isSet())
+      return SK_LocalVariable;
+
+    if (Decl->isFunctionOrMethodVarDecl() &&
+        NamingStyles[SK_LocalVariable].isSet())
+      return SK_LocalVariable;
+
+    if (NamingStyles[SK_Variable].isSet())
+      return SK_Variable;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<CXXMethodDecl>(D)) {
+    if (Decl->isMain() || !Decl->isUserProvided() ||
+        Decl->isUsualDeallocationFunction() ||
+        Decl->isCopyAssignmentOperator() || Decl->isMoveAssignmentOperator() ||
+        Decl->size_overridden_methods() > 0)
+      return SK_Invalid;
+
+    if (Decl->isConstexpr() && NamingStyles[SK_ConstexprMethod].isSet())
+      return SK_ConstexprMethod;
+
+    if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
+      return SK_ConstexprFunction;
+
+    if (Decl->isStatic() && NamingStyles[SK_ClassMethod].isSet())
+      return SK_ClassMethod;
+
+    if (Decl->isVirtual() && NamingStyles[SK_VirtualMethod].isSet())
+      return SK_VirtualMethod;
+
+    if (Decl->getAccess() == AS_private &&
+        NamingStyles[SK_PrivateMethod].isSet())
+      return SK_PrivateMethod;
+
+    if (Decl->getAccess() == AS_protected &&
+        NamingStyles[SK_ProtectedMethod].isSet())
+      return SK_ProtectedMethod;
+
+    if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMethod].isSet())
+      return SK_PublicMethod;
+
+    if (NamingStyles[SK_Method].isSet())
+      return SK_Method;
+
+    if (NamingStyles[SK_Function].isSet())
+      return SK_Function;
+
+    return SK_Invalid;
+  }
+
+  if (const auto *Decl = dyn_cast<FunctionDecl>(D)) {
+    if (Decl->isMain())
+      return SK_Invalid;
+
+    if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
+      return SK_ConstexprFunction;
+
+    if (Decl->isGlobal() && NamingStyles[SK_GlobalFunction].isSet())
+      return SK_GlobalFunction;
+
+    if (NamingStyles[SK_Function].isSet())
+      return SK_Function;
+  }
+
+  if (isa<TemplateTypeParmDecl>(D)) {
+    if (NamingStyles[SK_TypeTemplateParameter].isSet())
+      return SK_TypeTemplateParameter;
+
+    if (NamingStyles[SK_TemplateParameter].isSet())
+      return SK_TemplateParameter;
+
+    return SK_Invalid;
+  }
+
+  if (isa<NonTypeTemplateParmDecl>(D)) {
+    if (NamingStyles[SK_ValueTemplateParameter].isSet())
+      return SK_ValueTemplateParameter;
+
+    if (NamingStyles[SK_TemplateParameter].isSet())
+      return SK_TemplateParameter;
+
+    return SK_Invalid;
+  }
+
+  if (isa<TemplateTemplateParmDecl>(D)) {
+    if (NamingStyles[SK_TemplateTemplateParameter].isSet())
+      return SK_TemplateTemplateParameter;
+
+    if (NamingStyles[SK_TemplateParameter].isSet())
+      return SK_TemplateParameter;
+
+    return SK_Invalid;
+  }
+
+  return SK_Invalid;
+}
+
+void IdentifierNamingCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declref")) {
+    auto It = NamingCheckFailures.find(DeclRef->getDecl());
+    if (It == NamingCheckFailures.end())
+      return;
+
+    NamingCheckFailure &Failure = It->second;
+    SourceRange Range = DeclRef->getNameInfo().getSourceRange();
+
+    Failure.Usages.push_back(Range);
+    Failure.ShouldFix = Failure.ShouldFix &&
+                        Result.SourceManager->isInMainFile(Range.getBegin()) &&
+                        Result.SourceManager->isInMainFile(Range.getEnd()) &&
+                        !Range.getBegin().isMacroID() &&
+                        !Range.getEnd().isMacroID();
+
+    return;
+  }
+
+  if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
+    if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
+      return;
+
+    StyleKind SK = findStyleKind(Decl, NamingStyles);
+    if (SK == SK_Invalid)
+      return;
+
+    NamingStyle Style = NamingStyles[SK];
+    StringRef Name = Decl->getName();
+    if (matchesStyle(Name, Style))
+      return;
+
+    std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
+    std::replace(KindName.begin(), KindName.end(), '_', ' ');
+
+    std::string Fixup = fixupWithStyle(Name, Style);
+    if (StringRef(Fixup).equals(Name)) {
+      if (!IgnoreFailedSplit) {
+        DEBUG(llvm::dbgs() << Decl->getLocStart().printToString(
+                                  *Result.SourceManager)
+                           << format(": unable to split words for %s '%s'\n",
+                                     KindName.c_str(), Name));
+      }
+    } else {
+      NamingCheckFailure &Failure = NamingCheckFailures[Decl];
+      SourceRange Range =
+          DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
+              .getSourceRange();
+
+      Failure.Fixup = std::move(Fixup);
+      Failure.KindName = std::move(KindName);
+      Failure.ShouldFix =
+          Failure.ShouldFix &&
+          Result.SourceManager->isInMainFile(Range.getBegin()) &&
+          Result.SourceManager->isInMainFile(Range.getEnd()) &&
+          !Range.getBegin().isMacroID() && !Range.getEnd().isMacroID();
+    }
+  }
+}
+
+void IdentifierNamingCheck::onEndOfTranslationUnit() {
+  for (const auto &Pair : NamingCheckFailures) {
+    const NamedDecl &Decl = *Pair.first;
+    const NamingCheckFailure &Failure = Pair.second;
+
+    SourceRange DeclRange =
+        DeclarationNameInfo(Decl.getDeclName(), Decl.getLocation())
+            .getSourceRange();
+    auto Diag = diag(Decl.getLocStart(), "invalid case style for %0 '%1'")
+                << Failure.KindName << Decl.getName();
+
+    if (Failure.ShouldFix) {
+      Diag << FixItHint::CreateReplacement(
+          CharSourceRange::getTokenRange(DeclRange), Failure.Fixup);
+
+      for (const auto &Range : Failure.Usages) {
+        Diag << FixItHint::CreateReplacement(
+            CharSourceRange::getTokenRange(Range), Failure.Fixup);
+      }
+    }
+  }
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "ContainerSizeEmptyCheck.h"
 #include "ElseAfterReturnCheck.h"
 #include "FunctionSizeCheck.h"
+#include "IdentifierNamingCheck.h"
 #include "NamedParameterCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"

         "readability-else-after-return");
     CheckFactories.registerCheck<FunctionSizeCheck>(
         "readability-function-size");
+    CheckFactories.registerCheck<IdentifierNamingCheck>(
+        "readability-identifier-naming");
     CheckFactories.registerCheck<readability::NamedParameterCheck>(
         "readability-named-parameter");
     CheckFactories.registerCheck<RedundantSmartptrGetCheck>(

test/clang-tidy/readability-identifier-naming.cpp

+// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-identifier-naming %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: readability-identifier-naming.AbstractClassCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.AbstractClassPrefix, value: 'A'}, \
+// RUN:     {key: readability-identifier-naming.ClassCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.ClassPrefix, value: 'C'}, \
+// RUN:     {key: readability-identifier-naming.ClassConstantCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.ClassConstantPrefix, value: 'k'}, \
+// RUN:     {key: readability-identifier-naming.ClassMemberCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.ClassMethodCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.ConstantCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.ConstantSuffix, value: '_CST'}, \
+// RUN:     {key: readability-identifier-naming.ConstexprFunctionCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.ConstexprMethodCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.ConstexprVariableCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.EnumCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.EnumPrefix, value: 'E'}, \
+// RUN:     {key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.FunctionCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.GlobalFunctionCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.GlobalVariableCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.GlobalVariablePrefix, value: 'g_'}, \
+// RUN:     {key: readability-identifier-naming.InlineNamespaceCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.LocalConstantCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.LocalConstantPrefix, value: 'k'}, \
+// RUN:     {key: readability-identifier-naming.LocalVariableCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.MemberCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.MemberPrefix, value: 'm_'}, \
+// RUN:     {key: readability-identifier-naming.ConstantMemberCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.PrivateMemberPrefix, value: '__'}, \
+// RUN:     {key: readability-identifier-naming.ProtectedMemberPrefix, value: '_'}, \
+// RUN:     {key: readability-identifier-naming.PublicMemberCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.MethodCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.PrivateMethodPrefix, value: '__'}, \
+// RUN:     {key: readability-identifier-naming.ProtectedMethodPrefix, value: '_'}, \
+// RUN:     {key: readability-identifier-naming.NamespaceCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.ParameterCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.ParameterPrefix, value: 'a_'}, \
+// RUN:     {key: readability-identifier-naming.ConstantParameterCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.ConstantParameterPrefix, value: 'i_'}, \
+// RUN:     {key: readability-identifier-naming.ParameterPackCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.PureFunctionCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.PureMethodCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.StaticConstantCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.StaticVariableCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.StaticVariablePrefix, value: 's_'}, \
+// RUN:     {key: readability-identifier-naming.StructCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.TemplateParameterCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.TemplateTemplateParameterCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.TemplateUsingCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.TemplateUsingPrefix, value: 'u_'}, \
+// RUN:     {key: readability-identifier-naming.TypeTemplateParameterCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.TypeTemplateParameterSuffix, value: '_t'}, \
+// RUN:     {key: readability-identifier-naming.TypedefCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.TypedefSuffix, value: '_t'}, \
+// RUN:     {key: readability-identifier-naming.UnionCase, value: CamelCase}, \
+// RUN:     {key: readability-identifier-naming.UnionPrefix, value: 'U'}, \
+// RUN:     {key: readability-identifier-naming.UsingCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \
+// RUN:     {key: readability-identifier-naming.VariableCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.VirtualMethodCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \
+// RUN:     {key: readability-identifier-naming.IgnoreFailedSplit, value: 0} \
+// RUN:   ]}' -- -std=c++11
+// REQUIRES: shell
+
+// FIXME: There should be more test cases for checking that references to class
+// FIXME: name, declaration contexts, forward declarations, etc, are correctly
+// FIXME: checked and renamed
+
+namespace FOO_NS {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for namespace 'FOO_NS' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}namespace foo_ns {{{$}}
+inline namespace InlineNamespace {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for inline namespace 'InlineNamespace'
+// CHECK-FIXES: {{^}}inline namespace inline_namespace {{{$}}
+
+#define BLA int FOO_bar
+BLA;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for global variable 'FOO_bar'
+// NO fix expected as FOO_bar is from macro expansion
+
+enum my_enumeration {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for enum 'my_enumeration'
+// CHECK-FIXES: {{^}}enum EMyEnumeration {{{$}}
+    MyConstant = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'MyConstant'
+// CHECK-FIXES: {{^}}    MY_CONSTANT = 1,{{$}}
+    your_CONST = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'your_CONST'
+// CHECK-FIXES: {{^}}    YOUR_CONST = 1,{{$}}
+    THIS_ConstValue = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'THIS_ConstValue'
+// CHECK-FIXES: {{^}}    THIS_CONST_VALUE = 1,{{$}}
+};
+
+constexpr int ConstExpr_variable = MyConstant;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for constexpr variable 'ConstExpr_variable'
+// CHECK-FIXES: {{^}}constexpr int const_expr_variable = MY_CONSTANT;{{$}}
+
+class my_class {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for class 'my_class'
+// CHECK-FIXES: {{^}}class CMyClass {{{$}}
+    my_class();
+
+  const int MEMBER_one_1 = ConstExpr_variable;
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for constant member 'MEMBER_one_1'
+// CHECK-FIXES: {{^}}  const int member_one_1 = const_expr_variable;{{$}}
+  int member2 = 2;
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for private member 'member2'
+// CHECK-FIXES: {{^}}  int __member2 = 2;{{$}}
+
+private:
+    int private_member = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for private member 'private_member'
+// CHECK-FIXES: {{^}}    int __private_member = 3;{{$}}
+
+protected:
+    int ProtMember;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for protected member 'ProtMember'
+// CHECK-FIXES: {{^}}    int _ProtMember;{{$}}
+
+public:
+    int PubMem;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for public member 'PubMem'
+// CHECK-FIXES: {{^}}    int pub_mem;{{$}}
+
+    static const int classConstant;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for class constant 'classConstant'
+// CHECK-FIXES: {{^}}    static const int kClassConstant;{{$}}
+    static int ClassMember_2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for class member 'ClassMember_2'
+// CHECK-FIXES: {{^}}    static int ClassMember2;{{$}}
+};
+
+const int my_class::classConstant = 4;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for class constant 'classConstant'
+// CHECK-FIXES: {{^}}const int my_class::kClassConstant = 4;{{$}}
+// FIXME: The fixup should reflect class name fixups as well:
+// FIXME: {{^}}const int CMyClass::kClassConstant = 4;{{$}}
+
+int my_class::ClassMember_2 = 5;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for class member 'ClassMember_2'
+// CHECK-FIXES: {{^}}int my_class::ClassMember2 = 5;{{$}}
+// FIXME: The fixup should reflect class name fixups as well:
+// FIXME: {{^}}int CMyClass::ClassMember2 = 5;{{$}}
+
+const int global_Constant = 6;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for global constant 'global_Constant'
+// CHECK-FIXES: {{^}}const int GLOBAL_CONSTANT = 6;{{$}}
+int Global_variable = 7;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for global variable 'Global_variable'
+// CHECK-FIXES: {{^}}int g_global_variable = 7;{{$}}
+
+void global_function(int PARAMETER_1, int const CONST_parameter) {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for global function 'global_function'
+// CHECK-MESSAGES: :[[@LINE-2]]:22: warning: invalid case style for parameter 'PARAMETER_1'
+// CHECK-MESSAGES: :[[@LINE-3]]:39: warning: invalid case style for constant parameter 'CONST_parameter'
+// CHECK-FIXES: {{^}}void GlobalFunction(int a_parameter1, int const i_constParameter) {{{$}}
+    static const int THIS_static_ConsTant = 4;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for static constant 'THIS_static_ConsTant'
+// CHECK-FIXES: {{^}}    static const int THIS_STATIC_CONS_TANT = 4;{{$}}
+    static int THIS_static_variable;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for static variable 'THIS_static_variable'
+// CHECK-FIXES: {{^}}    static int s_thisStaticVariable;{{$}}
+    int const local_Constant = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for local constant 'local_Constant'
+// CHECK-FIXES: {{^}}    int const kLocalConstant = 3;{{$}}
+    int LOCAL_VARIABLE;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for local variable 'LOCAL_VARIABLE'
+// CHECK-FIXES: {{^}}    int local_variable;{{$}}
+
+    int LOCAL_Array__[] = {0, 1, 2};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for local variable 'LOCAL_Array__'
+// CHECK-FIXES: {{^}}    int local_array[] = {0, 1, 2};{{$}}
+
+    for (auto _ : LOCAL_Array__) {
+    }
+}
+
+template<typename ... TYPE_parameters>
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for type template parameter 'TYPE_parameters'
+// CHECK-FIXES: {{^}}template<typename ... typeParameters_t>{{$}}
+void Global_Fun(TYPE_parameters... PARAMETER_PACK) {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for global function 'Global_Fun'
+// CHECK-MESSAGES: :[[@LINE-2]]:17: warning: invalid case style for parameter pack 'PARAMETER_PACK'
+// CHECK-FIXES: {{^}}void GlobalFun(TYPE_parameters... parameterPack) {{{$}}
+    global_function(1, 2);
+// CHECK-FIXES: {{^}}    GlobalFunction(1, 2);{{$}}
+    FOO_bar = Global_variable;
+// CHECK-FIXES: {{^}}    FOO_bar = g_global_variable;{{$}}
+// NO fix expected for FOO_bar declared in macro expansion
+}
+
+template<template<typename> class TPL_parameter, int COUNT_params, typename ... TYPE_parameters>
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for template template parameter 'TPL_parameter'
+// CHECK-MESSAGES: :[[@LINE-2]]:50: warning: invalid case style for value template parameter 'COUNT_params'
+// CHECK-MESSAGES: :[[@LINE-3]]:68: warning: invalid case style for type template parameter 'TYPE_parameters'
+// CHECK-FIXES: {{^}}template<template<typename> class TplParameter, int countParams, typename ... typeParameters_t>{{$}}
+class test_CLASS {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for class 'test_CLASS'
+// CHECK-FIXES: {{^}}class CTestClass {{{$}}
+};
+
+class abstract_class {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for abstract class 'abstract_class'
+// CHECK-FIXES: {{^}}class AAbstractClass {{{$}}
+    virtual ~abstract_class() = 0;
+    virtual void VIRTUAL_METHOD();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for virtual method 'VIRTUAL_METHOD'
+// CHECK-FIXES: {{^}}    virtual void v_VIRTUAL_METHOD();{{$}}
+    void non_Virtual_METHOD() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for private method 'non_Virtual_METHOD'
+// CHECK-FIXES: {{^}}    void __non_Virtual_METHOD() {}{{$}}
+    static void CLASS_METHOD() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for class method 'CLASS_METHOD'
+// CHECK-FIXES: {{^}}    static void classMethod() {}{{$}}
+
+    constexpr int CST_expr_Method() { return 2; }
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for constexpr method 'CST_expr_Method'
+// CHECK-FIXES: {{^}}    constexpr int cst_expr_method() { return 2; }{{$}}
+
+private:
+    void PRIVate_Method();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for private method 'PRIVate_Method'
+// CHECK-FIXES: {{^}}    void __PRIVate_Method();{{$}}
+protected:
+    void protected_Method();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for protected method 'protected_Method'
+// CHECK-FIXES: {{^}}    void _protected_Method();{{$}}
+public:
+    void public_Method();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for method 'public_Method'
+// CHECK-FIXES: {{^}}    void publicMethod();{{$}}
+};
+
+constexpr int CE_function() { return 3; }
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for constexpr function 'CE_function'
+// CHECK-FIXES: {{^}}constexpr int ce_function() { return 3; }{{$}}
+
+struct THIS___Structure {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for struct 'THIS___Structure'
+// CHECK-FIXES: {{^}}struct this_structure {{{$}}
+    THIS___Structure();
+// FIXME: There should be a fixup for the constructor as well
+// FIXME: {{^}}    this_structure();{{$}}
+
+  union __MyUnion_is_wonderful__ {};
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for union '__MyUnion_is_wonderful__'
+// CHECK-FIXES: {{^}}  union UMyUnionIsWonderful {};{{$}}
+};
+
+typedef THIS___Structure struct_type;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for typedef 'struct_type'
+// CHECK-FIXES: {{^}}typedef THIS___Structure struct_type_t;{{$}}
+// FIXME: The fixup should reflect structure name fixups as well:
+// FIXME: {{^}}typedef this_structure struct_type_t;{{$}}
+
+static void static_Function() {
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for function 'static_Function'
+// CHECK-FIXES: {{^}}static void staticFunction() {{{$}}
+}
+
+}
+}