[clang-tidy] Add new case type to check variables with Hungarian notation

[dougpuob]

Summary

Add IdentifierNamingCheck::CaseType, CT_HungarianNotation, supporting naming check with Hungarian notation.

[dougpuob]

Reply code review suggestions. I will upload my change later.

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

478

OK~ I moved the HNOption to IdentifierNamingCheck class as its private data member. Then give value by constructor initializer list (instead of clearAll()).

532–533

OK.

533

OK~ Thank you. I will check them.

534

OK.

536

OK.

536–537

Sure! it's what should I do, you have helped me a lots.

541

Nice, thank you.

548–555

OK.

559–563

YES. I get the its QualType from EnumConstantDecl::getType(). Then get EnumDecl name via QualType::getAsString() (if enum tag name is "DataType", the string I get is "enum DataType").

static std::string getHungarianNotationEnumPrefix(const EnumConstantDecl *ECD) {
  std::string Name = ECD->getType().getAsString();
  // ...
}

600

OK.

601

OK, thank you.

[njames93]

Can you rebase this against trunk please, having trouble testing it out locally.

[njames93]

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

441

This function can be called multiple times per translation unit when looking through header files if GetConfigPerFile is enabled. Making this static will mean that each file thats read could potentially alter other files style configuration.
Maybe a smarter way about this is rather than this function returning a vector of naming styles, it returns a struct which contains the Hungarian options and a vector of the styles. Doing this would probably also mean you don't need to store a reference to this in the NamingStyle.

441–456

This isn't really needed if you have the mapping defined, Options.get works with enums, just look at how CaseType is parsed and stored. If you want to map multiple strings to a single enum constant that can also work by putting both strings in the mapping.
This method also validates inputs and will print out an error if a user supplies a value that can't be converted.

[dougpuob]

• Removed clearAll() function and made the HPOption variable passing by value(origin is std::move()).
• Moved static HNOption variable from static getNamingStyles() function to IdentifierNamingCheck class a private data member.
• Replaced auto keyword with explicit std::string.
• Elided braces around single-line.
• Used CXXRecordDecl::isAbstract() directly.
• changed const auto to const auto * for pointer objects.
• Enhanced test case for enum with two EnumConstant decls.
• Removed unnecessary clang:: namespace for variables.
• Executed arc lint
• Final changes.
• Executed arc lint

[dougpuob]

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

441

I removed the static variable from the function and a reference in NamingStyle.

441–456

Good idea. Thank you.

[dougpuob]

1. Applied all patches with the trunk(1800b44651c19b11e7680f908344d5751e8d2246).
2. Moved HNOption pointer out of NamingStyle data structure.
3. Removed parseHungarianPrefix() function, use Options.get() instead.

[njames93]

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

130

Is this line needed?

240

As you never use map like access for this, shouldn't it be an array.
The same goes for all the other StringMaps in this function

365

367

However for this I can see that its mapping the same options as Options in getHungarianNotationDefaultConfig().
Maybe HNOpts should be removed from here, Option from getHungarianNotationDefaultConfig() taken out of function scope and iterate over that array below.

A similar approach could be made with HNDerviedTypes

368–369

Building these temporary strings is expensive. Better off having a SmallString contsructed outside the loop and fill the string for each iteration, saved on allocations.
The same buffer can be reused below for the other loops

423

722

[dougpuob]

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

130

I will remove it. Thank you.

240

Thank you. I will change it.

367

I will move HNOpts and HNDerviedTypes outward to the top of the getHungarianNotationDefaultConfig() function. If the arrays are defined as static, is there any difference btw inside or outside of function, or did I misunderstand your meaning?

368–369

Good idea, thank you.

[dougpuob]

1. Fixed build failure on BuildBot. (Touch empty data from Options.get())
2. Changed llvm::StringMap with std::pair in getHungarianNotationDefaultConfig().
3. Moved HNOpts and HNDerviedTypes declarations out of getHungarianNotationDefaultConfig().
4. Reused SmallString<128> for string concatenation.
5. Removed redundant m(HungarianNotation) in #define NAMING_KEYS(m).

[dougpuob]

• Fixed warnings of Clang-Tidy.

[dougpuob]

• Shortened namespace with type alias.
• Removed namespace for StringRef.

[dougpuob]

ping?

[dougpuob]

Against git master.

[aaron.ballman]

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

235–439

Formatting

244

Usual style is to elide braces for single-line if statements (applies elsewhere in the patch as well).

261

One thing that confused me was the plain char and wchar_t entries -- those are for arrays of char and wchar_t, aren't they? Can we use char[] to make that more clear? If not, can you add a comment to clarify?

383–387

Similar question here as above, but less pressing because we at least have the word "array" nearby.

428–429

601–602

612–613

677

688–690

No need to check for CXXMethodDecl because those inherit from FunctionDecl anyway.

704

I think EOL should probably be const char * and can remove remove all these const_cast<>?

791

I think this switch should be replaced with:

if (const auto *ECD = dyn_cast<EnumConstantDecl>(ND)) {
  ...
} else if (const auto *CRD = dyn_cast<CXXRecordDecl>(ND)) {
  ...
} else if (isa<VarDecl, FieldDecl, RecordDecl>(ND)) {
  ...
}

796

Can remove all of the if (ND) in this method -- we already early return if ND == nullptr.

836–837

883

1047–1067

1359–1360

There's no need to pass a StringRef by const reference -- they pass like a pointer type already.

1396

And can remove the declaration of TypeName above.

Also, can you correct the formatting issues, elsewhere as well.

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

107

Might as well clear up this lint warning.

clang-tools-extra/clangd/refactor/tweaks/AddUsing.cpp

55 ↗

(On Diff #306411)

This change looks unrelated to the patch?

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

363 ↗

(On Diff #306411)

Same here?

clang-tools-extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp

41 ↗

(On Diff #306411)

And these changes as well?

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

110

For all of these, I'd recommend a slight wording tweak to:

When enabled, the check ensures that the declared identifier will have a Hungarian notation prefix based on the declared type.

2264–2265

I would remove this paragraph as it doesn't really add much value (it effectively says that the option works well with other options, but that's already expected).

2312

2315

2318

2321–2322

lldb/include/lldb/Target/Process.h

565 ↗

(On Diff #306411)

All the changes in this file are unrelated.

lldb/source/Target/Process.cpp

532 ↗

(On Diff #306411)

Unrelated changes.

llvm/lib/Target/SystemZ/SystemZISelLowering.cpp

167 ↗

(On Diff #306411)

All the changes in this file are unrelated.

llvm/lib/Target/SystemZ/SystemZISelLowering.h

54 ↗

(On Diff #306411)

Unrelated changes.

llvm/lib/Target/SystemZ/SystemZInstrInfo.td

835 ↗

(On Diff #306411)

All the changes in this file are unrelated.

llvm/lib/Target/SystemZ/SystemZInstrVector.td

574 ↗

(On Diff #306411)

Unrelated changes.

llvm/lib/Target/SystemZ/SystemZOperators.td

669 ↗

(On Diff #306411)

All the changes in this file are unrelated.

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

15 ↗

(On Diff #306411)

All the changes in this file are unrelated.

[dougpuob]

Against git master.

[dougpuob]

Hi @aaron.ballman, thank you for your feedback. I will update my change later. Unrelated change were mixed with other commits when I against git master. I did it again then the problem was gone. I found the command, arc diff master --preview, knowing exactly changes before uploading diff by arc.

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

235–439

OK. I checked all the range including single-line if statements, and passing StringRef directly(not its reference).

261

I improved it. It will look like the following:

static constexpr std::pair<StringRef, StringRef> CStrings[] = {
      {"char*", "sz"}, {"char[]", "sz"}, {"wchar_t*", "wsz"}, {"wchar_t[]", "wsz"}};

383–387

Improved here too. It will change to:

static constexpr std::pair<StringRef, StringRef> HNCStrings[] = {
    {"CharPrinter", "char*"},
    {"CharArray", "char[]"},
    {"WideCharPrinter", "wchar_t*"},
    {"WideCharArray", "wchar_t[]"}};

[dougpuob]

• Improved code review suggestions from Aaron Ballman(aaron.ballman). Including document, single-line if statements, no reference with StringRef, "char"-->"char[]" for HNOption.CString, use llvm::transform insteads of for-loop to uppercase string, don't check CXXMethod in getDeclTypeName(), remove const_cast<char *> in getDeclTypeName(), use if-else insteads of switch-case(simplify src).

[aaron.ballman]

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

629–632

684–685

722

This comment doesn't appear to have been handled.

753

Similar to what was suggested above.

[Eugene.Zelenko]

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

627

Returning {} as default initializer will be better. Same in other places.

[dougpuob]

Hi @aaron.ballman and @Eugene.Zelenko, thank you for your suggestions. I will improve them and upload my diff later.

[dougpuob]

• Improved code review suggestions from Aaron.Ballman and Eugene.Zelenko. Including return default initializer instead of empty string, use isa<>() instead of if statement with multiple conditions, use StringRef array instead of list<std::string>.

[aaron.ballman]

LGTM! Thank you for the new functionality! You may want to wait a bit before landing to see if @njames93 has any remaining comments.

[njames93]

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

241–245

250–254

262–266

314–318

353–354

372

379

392

398–407

413–415

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

106–107

This should be part of the FileStyle struct.

[dougpuob]

• Improved code review suggestions from @njames93. Including move the IdentifierNamingCheck::HNOption variable to IdentifierNamingCheck::FileStyle::HNOption, use try_emplace() instead of insert() and lookup().

[dougpuob]

arc diff with the correct base.

[njames93]

This needs rebasing against main. Can't be applied cleanly in its current state.

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

405–411

There's no need to build a string and transform it here.

[dougpuob]

• Against git master.
• Refined isHungarianNotationOptionEnabled() function.
• Classify document and test cases.

[dougpuob]

• Fixed assertions by clang-format.

[dougpuob]

Hi @njames93, thank you for your review suggestions, I have improved them and against my change to the main branch.

I encounter a problem on the Buildbot for Windows only. Several people encounter also to the same problem that their build failed at an unrelated regression test (llvm\test\CodeGen\XCore\threads.ll).

[njames93]

One last point, is there a way to validate that these options are only set where it makes sense. If someone tries to use say MacroDefinitionHungarianPrefix That could be warning worthy?

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

405–411

Scratch this, in D92756 support was added for all boolean options in clang-tidy to use the full YAML boolean spec, I'd advise calling the same function here to keep everything consistent.

453–480

[dougpuob]

In D86671#2456161, @njames93 wrote:

One last point, is there a way to validate that these options are only set where it makes sense. If someone tries to use say MacroDefinitionHungarianPrefix That could be warning worthy?

Hi @njames93, it's a good idea. I am trying to do it, thank you.

[dougpuob]

• Against git master.
• Refined isHungarianNotationOptionEnabled() function.
• Classify document and test cases.
• Fixed assertions by clang-format.
• Instead check On/Off string with llvm::yaml::parseBool() function for consistent.
• Improved code.
• Add new check for unsupported option.

[dougpuob]

• Removed unrelated comments.

[dougpuob]

Addressed comments by @njames93. Including adding warning message for unsupported options in config file, refining code in getFileStyleFromOptions(), and for consistent reason to use llvm::yaml::parseBool() function instead of checking On/Off string.

[dougpuob]

Ping @njames93

[dougpuob]

• Against trunk.
• Refined isHungarianNotationOptionEnabled() function.
• Changed old way that showing invalid config option in .clang-tidy config file. Now added a new function ClangTidyCheck::OptionsView::diagnoseInvalidConfigOption() instead.
• Recovered that document content missing in .rst.

[njames93]

Sorry, I thought this landed months ago. I'll take a proper look again next week.

clang-tools-extra/clang-tidy/ClangTidyCheck.h

158 ↗

(On Diff #342126)

This isn't really needed, you can just call configurationDiag directly.

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

457

[dougpuob]

Hi @njames93,

That's ok. You have helped me a lots. Thank you.

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

457

To use configurationDiag() function in getFileStyleFromOptions(), seems it needs to pass a ClangTidyContext object to getFileStyleFromOptions(). How about changing like the following?

getFileStyleFromOptions(const ClangTidyCheck::OptionsView &Options,
                        ClangTidyContext &Context) {
    ...

    if (!isHungarianNotationSupportedStyle(I) && HPTOpt.hasValue())
      Context.configurationDiag("invalid identifier naming option '%0'")
          << StyleString;

    ...
}

[njames93]

clang-tools-extra/clang-tidy/ClangTidyCheck.h

124–126 ↗

(On Diff #342126)

You don't need a ClangTidyContext, this function is all that's needed.

[dougpuob]

clang-tools-extra/clang-tidy/ClangTidyCheck.h

124–126 ↗

(On Diff #342126)

But the getFileStyleFromOptions() is a static function in IdentifierNamingCheck.cpp file. It can't access configurationDiag() directly.

[dougpuob]

Hi @njames93

I tried to create a class, HungarianNotation, and put all related functions into the class. Then I can call configurationDiag() in HungarianNotation::checkOptionValid() function.
How about this way?

The new class.

struct HungarianNotation {
public:
  HungarianNotation(ClangTidyContext *Context = nullptr);

  bool checkOptionValid(int StyleKindIndex, StringRef StyleString,
                        bool HasValue);
  ...

Use the configurationDiag() in checkOptionValid() function

bool HungarianNotation::checkOptionValid(int StyleKindIndex,
                                         StringRef StyleString, bool HasValue) {
  ..
  if (HasValue)
    Context->configurationDiag("invalid identifier naming option '%0'")
        << StyleString;

  return false;
}

Call the checkOptionValid() here in getFileStyleFromOptions().

static IdentifierNamingCheck::FileStyle
getFileStyleFromOptions(const ClangTidyCheck::OptionsView &Options,
                        ClangTidyContext &Context) {
    ...
    StyleString.append("HungarianPrefix");
    auto HPTOpt =
        Options.get<IdentifierNamingCheck::HungarianPrefixType>(StyleString);
    HN.checkOptionValid(I, StyleString, HPTOpt.hasValue());
    ...

[dougpuob]

• Removed diagnoseInvalidConfigOption() function.
• Created a HungarianNotation class and moved related functions into there.

[dougpuob]

Hi @njames93:
Could you do me a favor? Because it is my first patch, something I'm not sure. I'm confused about can I land this patch now? I read the "LLVM Code-Review Policy and Practices" document, it said patches can be landed if received a LGTM, but seems you are still reviewing.

[njames93]

In D86671#2750957, @dougpuob wrote:

Hi @njames93:
Could you do me a favor? Because it is my first patch, something I'm not sure. I'm confused about can I land this patch now? I read the "LLVM Code-Review Policy and Practices" document, it said patches can be landed if received a LGTM, but seems you are still reviewing.

If you have made significant changes (excluding what a reviewer asks when giving an LGTM) Its best to get those further changes also reviewed.

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

236

Rather than passing the ClangTidyContext, Make this function a method of IdentifierNamingCheck. Then you call create the Diag without worrying about the Context.

[dougpuob]

In D86671#2754542, @njames93 wrote:

In D86671#2750957, @dougpuob wrote:

Hi @njames93:
Could you do me a favor? Because it is my first patch, something I'm not sure. I'm confused about can I land this patch now? I read the "LLVM Code-Review Policy and Practices" document, it said patches can be landed if received a LGTM, but seems you are still reviewing.

If you have made significant changes (excluding what a reviewer asks when giving an LGTM) Its best to get those further changes also reviewed.

Thank you for your reply and suggestion in code, I will try it.

[dougpuob]

• Moved all static functions into IdentifierNamingCheck class, and called the configurationDiag() directly in IdentifierNamingCheck::getFileStyleFromOptions() method.

[dougpuob]

@njames93, Ping

[• gnossier]

Is this ready to merge soon?

[dougpuob]

In D86671#2837818, @gnossier wrote:

Is this ready to merge soon?

Hi @gnossier:
I'm waiting for feedbacks from reviewer.

Hi @aaron.ballman:
Nathan is helping me to review this patch, but seems he is not here recently. Do you have any suggestion about how to keep the ball rolling in this situation? If it was done, can I apply the right to land it by self?

[thakis]

This breaks tests on windows: http://45.33.8.238/win/43180/step_8.txt

"The command line is too long" Maybe some arts could be passed via a response file instead?

[dougpuob]

In D86671#2919077, @thakis wrote:

This breaks tests on windows: http://45.33.8.238/win/43180/step_8.txt

"The command line is too long" Maybe some arts could be passed via a response file instead?

Hi @thakis :
Thank you.

I'm a newbie. I tried to arc diff but arc shows ERR_CLOSED: This revision has already been closed.. Should I create a new differential diff for it?

[thakis]

In D86671#2920294, @dougpuob wrote:

In D86671#2919077, @thakis wrote:

This breaks tests on windows: http://45.33.8.238/win/43180/step_8.txt

"The command line is too long" Maybe some arts could be passed via a response file instead?

Hi @thakis :
Thank you.

I'm a newbie. I tried to arc diff but arc shows ERR_CLOSED: This revision has already been closed.. Should I create a new differential diff for it?

Yes :)

[aeubanks]

you can reopen the revision via "Add Action..."

[thakis]

Any news here? This has been broken for over a day now.

[dougpuob]

In D86671#2920570, @aeubanks wrote:

you can reopen the revision via "Add Action..."

Hi @aeubanks , thank you for the suggestion.

[dougpuob]

In D86671#2921424, @thakis wrote:

Any news here? This has been broken for over a day now.

Hi @thakis,
YES. I just create a new differential diff for it, https://reviews.llvm.org/D107325, could you help me to review it?

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

 /// 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.
 class IdentifierNamingCheck final : public RenamerClangTidyCheck {
 public:
   IdentifierNamingCheck(StringRef Name, ClangTidyContext *Context);
   ~IdentifierNamingCheck();
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
   enum CaseType {
     CT_AnyCase = 0,
     CT_LowerCase,
     CT_CamelBack,
     CT_UpperCase,
     CT_CamelCase,
     CT_CamelSnakeCase,
     CT_CamelSnakeBack
   };
 
+  enum HungarianPrefixType {
+    HPT_Off = 0,
+    HPT_On,
+    HPT_LowerCase,
+    HPT_CamelCase,
+  };
+
+  struct HungarianNotationOption {
+    HungarianNotationOption() : HPType(HungarianPrefixType::HPT_Off) {}
+
+    llvm::Optional<CaseType> Case;
+    HungarianPrefixType HPType;
+    llvm::StringMap<std::string> General;
+    llvm::StringMap<std::string> CString;
+    llvm::StringMap<std::string> PrimitiveType;
+    llvm::StringMap<std::string> UserDefinedType;
+    llvm::StringMap<std::string> DerivedType;
+  };
+
   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, HungarianPrefixType HPType)
+        : Case(Case), Prefix(Prefix), Suffix(Suffix), HPType(HPType) {}
 
     llvm::Optional<CaseType> Case;
     std::string Prefix;
     std::string Suffix;
+
+    HungarianPrefixType HPType;
   };
 
 private:
   llvm::Optional<FailureInfo>
   GetDeclFailureInfo(const NamedDecl *Decl,
                      const SourceManager &SM) const override;
   llvm::Optional<FailureInfo>
   GetMacroFailureInfo(const Token &MacroNameTok,
                       const SourceManager &SM) const override;
   DiagInfo GetDiagInfo(const NamingCheckId &ID,
                        const NamingCheckFailure &Failure) const override;
 
   ArrayRef<llvm::Optional<NamingStyle>>
   getStyleForFile(StringRef FileName) const;
 
   /// Stores the style options as a vector, indexed by the specified \ref
   /// StyleKind, for a given directory.
   mutable llvm::StringMap<std::vector<llvm::Optional<NamingStyle>>>
       NamingStylesCache;
   ArrayRef<llvm::Optional<NamingStyle>> MainFileStyle;
   ClangTidyContext *const Context;
   const std::string CheckName;
   const bool GetConfigPerFile;
   const bool IgnoreFailedSplit;
   const bool IgnoreMainLikeFunctions;
+
+  IdentifierNamingCheck::HungarianNotationOption HNOption;
 };
 
 } // namespace readability
 template <>
 struct OptionEnumMapping<readability::IdentifierNamingCheck::CaseType> {
   static llvm::ArrayRef<
       std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>>
   getEnumMapping();
 };
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H

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

static constexpr std::pair<readability::IdentifierNamingCheck::CaseType,
           {readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"},
           {readability::IdentifierNamingCheck::CT_CamelSnakeCase,
            "Camel_Snake_Case"},
           {readability::IdentifierNamingCheck::CT_CamelSnakeBack,
            "camel_Snake_Back"}};
   return llvm::makeArrayRef(Mapping);
 }
 
+template <>
+struct OptionEnumMapping<
+    readability::IdentifierNamingCheck::HungarianPrefixType> {
+  static llvm::ArrayRef<std::pair<
+      readability::IdentifierNamingCheck::HungarianPrefixType, StringRef>>
+  getEnumMapping() {
+    static constexpr std::pair<
+        readability::IdentifierNamingCheck::HungarianPrefixType, StringRef>
+        Mapping[] = {
+            {readability::IdentifierNamingCheck::HungarianPrefixType::HPT_Off,
+             "Off"},
+            {readability::IdentifierNamingCheck::HungarianPrefixType::HPT_On,
+             "On"},
+            {readability::IdentifierNamingCheck::HungarianPrefixType::
+                 HPT_LowerCase,
+             "sz_LowerCase"},
+            {readability::IdentifierNamingCheck::HungarianPrefixType::
+                 HPT_CamelCase,
+             "szCamelCase"}};
+    return llvm::makeArrayRef(Mapping);
+  }
+};
+
 namespace readability {
 
 // clang-format off
 #define NAMING_KEYS(m) \
     m(Namespace) \
     m(InlineNamespace) \
     m(EnumConstant) \
     m(ScopedEnumConstant) \
#define NAMING_KEYS(m) \
     m(Method) \
     m(Typedef) \
     m(TypeTemplateParameter) \
     m(ValueTemplateParameter) \
     m(TemplateTemplateParameter) \
     m(TemplateParameter) \
     m(TypeAlias) \
     m(MacroDefinition) \
-    m(ObjcIvar) \
+    m(ObjcIvar)
 
 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
 };
 
+#define HUNGARIAN_NOTATION_PRIMITIVE_TYPES(m) \
+     m(int8_t) \
+     m(int16_t) \
+     m(int32_t) \
+     m(int64_t) \
+     m(uint8_t) \
+     m(uint16_t) \
+     m(uint32_t) \
+     m(uint64_t) \
+     m(char8_t) \
+     m(char16_t) \
+     m(char32_t) \
+     m(float) \
+     m(double) \
+     m(char) \
+     m(bool) \
+     m(_Bool) \
+     m(int) \
+     m(size_t) \
+     m(wchar_t) \
+     m(short-int) \
+     m(short) \
+     m(signed-int) \
+     m(signed-short) \
+     m(signed-short-int) \
+     m(signed-long-long-int) \
+     m(signed-long-long) \
+     m(signed-long-int) \
+     m(signed-long) \
+     m(signed) \
+     m(unsigned-long-long-int) \
+     m(unsigned-long-long) \
+     m(unsigned-long-int) \
+     m(unsigned-long) \
+     m(unsigned-short-int) \
+     m(unsigned-short) \
+     m(unsigned-int) \
+     m(unsigned) \
+     m(long-long-int) \
+     m(long-double) \
+     m(long-long) \
+     m(long-int) \
+     m(long) \
+     m(ptrdiff_t) \
+
+static StringRef const HungarainNotationPrimitiveTypes[] = {
+#define STRINGIZE(v) #v,
+  HUNGARIAN_NOTATION_PRIMITIVE_TYPES(STRINGIZE)
+#undef STRINGIZE
+};
+
+#define HUNGARIAN_NOTATION_USER_DEFINED_TYPES(m) \
+     m(BOOL) \
+     m(BOOLEAN) \
+     m(BYTE) \
+     m(CHAR) \
+     m(UCHAR) \
+     m(SHORT) \
+     m(USHORT) \
+     m(WORD) \
+     m(DWORD) \
+     m(DWORD32) \
+     m(DWORD64) \
+     m(LONG) \
+     m(ULONG) \
+     m(ULONG32) \
+     m(ULONG64) \
+     m(ULONGLONG) \
+     m(HANDLE) \
+     m(INT) \
+     m(INT8) \
+     m(INT16) \
+     m(INT32) \
+     m(INT64) \
+     m(UINT) \
+     m(UINT8) \
+     m(UINT16) \
+     m(UINT32) \
+     m(UINT64) \
+     m(PVOID) \
+
+static StringRef const HungarainNotationUserDefinedTypes[] = {
+#define STRINGIZE(v) #v,
+  HUNGARIAN_NOTATION_USER_DEFINED_TYPES(STRINGIZE)
+#undef STRINGIZE
+};
+
+
 #undef NAMING_KEYS
 // clang-format on
 
+static void getHungarianNotationDefaultConfig(
+    IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+
+  // Options
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> Options[] = {
+      {"TreatStructAsClass", "false"}};
+  for (const auto &Opt : Options) {
+    std::string Val = HNOption.General.lookup(Opt.first);
+    if (Val.empty()) {
+      HNOption.General.insert({Opt.first, Opt.second.str()});
+    }
+  }
+
+  // Derived types
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> DerivedTypes[] =
+      {{"Array", "a"}, {"Pointer", "p"}, {"FunctionPointer", "fn"}};
+  for (const auto &Other : DerivedTypes) {
+    std::string Val = HNOption.DerivedType.lookup(Other.first);
+    if (Val.empty()) {
+      HNOption.DerivedType.insert({Other.first, Other.second.str()});
+    }
+  }
+
+  // C strings
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> CStrings[] = {
+      {"char*", "sz"}, {"char", "sz"}, {"wchar_t*", "wsz"}, {"wchar_t", "wsz"}};
+  for (const auto &CStr : CStrings) {
+    std::string Val = HNOption.CString.lookup(CStr.first);
+    if (Val.empty()) {
+      HNOption.CString.insert({CStr.first, CStr.second.str()});
+    }
+  }
+
+  // clang-format off
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> PrimitiveTypes[] = {
+        {"int8_t",                  "i8"  },
+        {"int16_t",                 "i16" },
+        {"int32_t",                 "i32" },
+        {"int64_t",                 "i64" },
+        {"uint8_t",                 "u8"  },
+        {"uint16_t",                "u16" },
+        {"uint32_t",                "u32" },
+        {"uint64_t",                "u64" },
+        {"char8_t",                 "c8"  },
+        {"char16_t",                "c16" },
+        {"char32_t",                "c32" },
+        {"float",                   "f"   },
+        {"double",                  "d"   },
+        {"char",                    "c"   },
+        {"bool",                    "b"   },
+        {"_Bool",                   "b"   },
+        {"int",                     "i"   },
+        {"size_t",                  "n"   },
+        {"wchar_t",                 "wc"  },
+        {"short int",               "si"  },
+        {"short",                   "s"   },
+        {"signed int",              "si"  },
+        {"signed short",            "ss"  },
+        {"signed short int",        "ssi" },
+        {"signed long long int",    "slli"},
+        {"signed long long",        "sll" },
+        {"signed long int",         "sli" },
+        {"signed long",             "sl"  },
+        {"signed",                  "s"   },
+        {"unsigned long long int",  "ulli"},
+        {"unsigned long long",      "ull" },
+        {"unsigned long int",       "uli" },
+        {"unsigned long",           "ul"  },
+        {"unsigned short int",      "usi" },
+        {"unsigned short",          "us"  },
+        {"unsigned int",            "ui"  },
+        {"unsigned",                "u"   },
+        {"long long int",           "lli" },
+        {"long double",             "ld"  },
+        {"long long",               "ll"  },
+        {"long int",                "li"  },
+        {"long",                    "l"   },
+        {"ptrdiff_t",               "p"   }};
+  // clang-format on
+  for (const auto &Type : PrimitiveTypes) {
+    std::string Val = HNOption.PrimitiveType.lookup(Type.first);
+    if (Val.empty()) {
+      HNOption.PrimitiveType.insert({Type.first, Type.second.str()});
+    }
+  }
+
+  // clang-format off
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> UserDefinedTypes[] = {
+      // Windows data types
+      {"BOOL",                    "b"   },
+      {"BOOLEAN",                 "b"   },
+      {"BYTE",                    "by"  },
+      {"CHAR",                    "c"   },
+      {"UCHAR",                   "uc"  },
+      {"SHORT",                   "s"   },
+      {"USHORT",                  "us"  },
+      {"WORD",                    "w"   },
+      {"DWORD",                   "dw"  },
+      {"DWORD32",                 "dw32"},
+      {"DWORD64",                 "dw64"},
+      {"LONG",                    "l"   },
+      {"ULONG",                   "ul"  },
+      {"ULONG32",                 "ul32"},
+      {"ULONG64",                 "ul64"},
+      {"ULONGLONG",               "ull" },
+      {"HANDLE",                  "h"   },
+      {"INT",                     "i"   },
+      {"INT8",                    "i8"  },
+      {"INT16",                   "i16" },
+      {"INT32",                   "i32" },
+      {"INT64",                   "i64" },
+      {"UINT",                    "ui"  },
+      {"UINT8",                   "u8"  },
+      {"UINT16",                  "u16" },
+      {"UINT32",                  "u32" },
+      {"UINT64",                  "u64" },
+      {"PVOID",                   "p"   } };
+  // clang-format on
+  for (const auto &Type : UserDefinedTypes) {
+    std::string Val = HNOption.UserDefinedType.lookup(Type.first);
+    if (Val.empty()) {
+      HNOption.UserDefinedType.insert({Type.first, Type.second.str()});
+    }
+  }
+}
+
+static constexpr StringRef HNOpts[] = {"TreatStructAsClass"};
+static constexpr StringRef HNDerivedTypes[] = {"Array", "Pointer",
+                                               "FunctionPointer"};
+static void getHungarianNotationFileConfig(
+    const ClangTidyCheck::OptionsView &Options,
+    IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+  llvm::StringRef Section = "HungarianNotation.";
+
+  SmallString<128> Buffer;
+  for (const auto &Opt : HNOpts) {
+    Buffer.assign({Section, "General.", Opt});
+    std::string Val = Options.get(Buffer, "");
+    if (!Val.empty())
+      HNOption.General[Opt] = Val;
+  }
+
+  for (const auto &Type : HNDerivedTypes) {
+    Buffer.assign({Section, "DerivedType.", Type});
+    std::string Val = Options.get(Buffer, "");
+    if (!Val.empty())
+      HNOption.DerivedType[Type] = Val;
+  }
+
+  static constexpr std::pair<llvm::StringRef, llvm::StringRef> HNCStrings[] = {
+      {"CharPrinter", "char*"},
+      {"CharArray", "char"},
+      {"WideCharPrinter", "wchar_t*"},
+      {"WideCharArray", "wchar_t"}};
+
+  for (const auto &CStr : HNCStrings) {
+    Buffer.assign({Section, "CString.", CStr.first});
+    std::string Val = Options.get(Buffer, "");
+    if (!Val.empty())
+      HNOption.CString[CStr.first] = Val;
+  }
+
+  for (const auto &PrimType : HungarainNotationPrimitiveTypes) {
+    Buffer.assign({Section, "PrimitiveType.", PrimType});
+    std::string Val = Options.get(Buffer, "");
+    std::string Type = PrimType.str();
+    if (!Val.empty()) {
+      if (Type.find('-') != std::string::npos) {
+        for (size_t I = 0; I < Type.length(); ++I) {
+          if (Type[I] == '-') {
+            Type.replace(I, 1, " ");
+          }
+        }
+      }
+      HNOption.PrimitiveType[Type] = Val;
+    }
+  }
+
+  for (const auto &WDType : HungarainNotationUserDefinedTypes) {
+    Buffer.assign({Section, "UserDefinedType.", WDType});
+    std::string Val = Options.get(Buffer, "");
+    std::string Type = WDType.str();
+    if (!Val.empty())
+      HNOption.UserDefinedType[Type] = Val;
+  }
+}
+
+static bool
+isHungarianNotationOptionEnabled(const std::string OptionKey,
+                                 const llvm::StringMap<std::string> &StrMap) {
+  if (OptionKey.empty())
+    return false;
+
+  std::string OptionVal = StrMap.lookup(OptionKey);
+  for (auto &C : OptionVal)
+    C = toupper(C);
+
+  if (OptionVal == "1" || OptionVal == "TRUE" || OptionVal == "ON")
+    return true;
+
+  return false;
+}
+
 static std::vector<llvm::Optional<IdentifierNamingCheck::NamingStyle>>
-getNamingStyles(const ClangTidyCheck::OptionsView &Options) {
+getNamingStyles(const ClangTidyCheck::OptionsView &Options,
+                IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+  getHungarianNotationDefaultConfig(HNOption);
+  getHungarianNotationFileConfig(Options, HNOption);
+
   std::vector<llvm::Optional<IdentifierNamingCheck::NamingStyle>> Styles(
       SK_Count);
+
   SmallString<64> StyleString;
   for (unsigned I = 0; I < SK_Count; ++I) {
     StyleString = StyleNames[I];
     size_t StyleSize = StyleString.size();
+
+    std::string HPrefixKey = (StyleString + "HungarianPrefix").str();
+    auto HPTVal = IdentifierNamingCheck::HungarianPrefixType::HPT_Off;
+    std::string HPrefixVal = Options.get(HPrefixKey, "");
+    if (!HPrefixVal.empty()) {
+      if (auto HPTypeVal =
+              Options.get<IdentifierNamingCheck::HungarianPrefixType>(
+                  HPrefixKey)) {
+        HPTVal = HPTypeVal.get();
+      }
+    }
+
     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);
+    HNOption.Case = CaseOptional;
 
-    if (CaseOptional || !Prefix.empty() || !Postfix.empty())
+    if (CaseOptional || !Prefix.empty() || !Postfix.empty() ||
+        !HPrefixVal.empty()) {
       Styles[I].emplace(std::move(CaseOptional), std::move(Prefix),
-                        std::move(Postfix));
+                        std::move(Postfix), HPTVal);
+    }
   }
   return Styles;
 }
 
 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : RenamerClangTidyCheck(Name, Context), Context(Context), CheckName(Name),
       GetConfigPerFile(Options.get("GetConfigPerFile", true)),
       IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)),
       IgnoreMainLikeFunctions(Options.get("IgnoreMainLikeFunctions", false)) {
 
   auto IterAndInserted = NamingStylesCache.try_emplace(
       llvm::sys::path::parent_path(Context->getCurrentFile()),
-      getNamingStyles(Options));
+      getNamingStyles(Options, HNOption));
   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;
   for (size_t I = 0; I < SK_Count; ++I) {
     if (!MainFileStyle[I])
       continue;
     StyleString = StyleNames[I];
     size_t StyleSize = StyleString.size();
+
+    Options.store(Opts, (StyleString + "HungarianPrefix").str(),
+                  MainFileStyle[I]->HPType);
+
     StyleString.append("Prefix");
     Options.store(Opts, StyleString, MainFileStyle[I]->Prefix);
     // Fast replacement of [Pre]fix -> [Suf]fix.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     Options.store(Opts, StyleString, MainFileStyle[I]->Suffix);
     if (MainFileStyle[I]->Case) {
       memcpy(&StyleString[StyleSize], "Case", 4);
       StyleString.pop_back();
       StyleString.pop_back();
       Options.store(Opts, StyleString, *MainFileStyle[I]->Case);
     }
   }
   Options.store(Opts, "GetConfigPerFile", GetConfigPerFile);
   Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
   Options.store(Opts, "IgnoreMainLikeFunctions", IgnoreMainLikeFunctions);
 }
 
-static bool matchesStyle(StringRef Name,
-                         IdentifierNamingCheck::NamingStyle Style) {
+static const std::string getHungarianNotationDataTypePrefix(
+    const std::string &TypeName, const NamedDecl *ND,
+    const IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+  if (!ND || TypeName.empty())
+    return TypeName;
+
+  std::string ModifiedTypeName = TypeName;
+
+  // Derived types
+  std::string PrefixStr;
+  if (const auto *TD = dyn_cast<ValueDecl>(ND)) {
+    QualType QT = TD->getType();
+    if (QT->isFunctionPointerType()) {
+      PrefixStr = HNOption.DerivedType.lookup("FunctionPointer");
+    } else if (QT->isPointerType()) {
+      for (const auto &CStr : HNOption.CString) {
+        std::string Key = CStr.getKey().str();
+        if (ModifiedTypeName.find(Key) == 0) {
+          PrefixStr = CStr.getValue();
+          ModifiedTypeName = ModifiedTypeName.substr(
+              Key.size(), ModifiedTypeName.size() - Key.size());
+          break;
+        }
+      }
+    } else if (QT->isArrayType()) {
+      for (const auto &CStr : HNOption.CString) {
+        std::string Key = CStr.getKey().str();
+        if (ModifiedTypeName.find(Key) == 0) {
+          PrefixStr = CStr.getValue();
+          break;
+        }
+      }
+      if (PrefixStr.empty()) {
+        PrefixStr = HNOption.DerivedType.lookup("Array");
+      }
+    } else if (QT->isReferenceType()) {
+      size_t Pos = ModifiedTypeName.find_last_of("&");
+      if (Pos != std::string::npos) {
+        ModifiedTypeName = ModifiedTypeName.substr(0, Pos);
+      }
+    }
+  }
+
+  // Pointers
+  size_t PtrCount = [&](std::string TypeName) -> size_t {
+    size_t Pos = TypeName.find('*');
+    size_t Count = 0;
+    for (; Pos < TypeName.length(); Pos++, Count++) {
+      if ('*' != TypeName[Pos])
+        break;
+    }
+    return Count;
+  }(ModifiedTypeName);
+  if (PtrCount > 0) {
+    ModifiedTypeName = [&](std::string Str, const std::string &From,
+                           const std::string &To) {
+      size_t StartPos = 0;
+      while ((StartPos = Str.find(From, StartPos)) != std::string::npos) {
+        Str.replace(StartPos, From.length(), To);
+        StartPos += To.length();
+      }
+      return Str;
+    }(ModifiedTypeName, "*", "");
+  }
+
+  // Primitive types
+  if (PrefixStr.empty()) {
+    for (const auto &Type : HNOption.PrimitiveType) {
+      std::string Key = Type.getKey().str();
+      if (ModifiedTypeName == Key) {
+        PrefixStr = Type.getValue();
+        break;
+      }
+    }
+  }
+
+  // User-Defined types
+  if (PrefixStr.empty()) {
+    for (const auto &Type : HNOption.UserDefinedType) {
+      std::string Key = Type.getKey().str();
+      if (ModifiedTypeName == Key) {
+        PrefixStr = Type.getValue();
+        break;
+      }
+    }
+  }
+
+  for (size_t Idx = 0; Idx < PtrCount; Idx++)
+    PrefixStr.insert(0, HNOption.DerivedType.lookup("Pointer"));
+
+  return PrefixStr;
+}
+
+static std::string getHungarianNotationClassPrefix(
+    const CXXRecordDecl *CRD,
+    const IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+
+  if (CRD->isUnion())
+    return "";
+
+  if (CRD->isStruct() && !isHungarianNotationOptionEnabled("TreatStructAsClass",
+                                                           HNOption.General)) {
+    return "";
+  }
+
+  return CRD->isAbstract() ? "I" : "C";
+}
+
+static std::string getHungarianNotationEnumPrefix(const EnumConstantDecl *ECD) {
+  std::string Name = ECD->getType().getAsString();
+  if (std::string::npos != Name.find("enum")) {
+    Name = Name.substr(strlen("enum"), Name.length() - strlen("enum"));
+    Name = Name.erase(0, Name.find_first_not_of(" "));
+  }
+
+  static llvm::Regex Splitter(
+      "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
+
+  llvm::StringRef EnumName(Name);
+  SmallVector<StringRef, 8> Substrs;
+  EnumName.split(Substrs, "_", -1, false);
+
+  SmallVector<StringRef, 8> Words;
+  SmallVector<StringRef, 8> Groups;
+  for (auto Substr : Substrs) {
+    while (!Substr.empty()) {
+      Groups.clear();
+      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());
+      }
+    }
+  }
+
+  std::string Initial;
+  for (auto const &Word : Words) {
+    Initial += tolower(Word[0]);
+  }
+  return Initial;
+}
+
+static std::string getDeclTypeName(const NamedDecl *ND) {
+  const auto *VD = dyn_cast<ValueDecl>(ND);
+  if (!VD)
+    return "";
+
+  if (clang::Decl::Kind::EnumConstant == ND->getKind() ||
+      clang::Decl::Kind::CXXMethod == ND->getKind() ||
+      clang::Decl::Kind::Function == ND->getKind()) {
+    return "";
+  }
+
+  // Get type text of variable declarations.
+  auto &SM = VD->getASTContext().getSourceManager();
+  const char *Begin = SM.getCharacterData(VD->getBeginLoc());
+  const char *End = SM.getCharacterData(VD->getEndLoc());
+  intptr_t StrLen = End - Begin;
+
+  // FIXME: Sometimes the value that returns from ValDecl->getEndLoc()
+  // is wrong(out of location of Decl). This causes `StrLen` will be assigned
+  // an unexpected large value. Current workaround to find the terminated
+  // character instead of the `getEndLoc()` function.
+  char *EOL = const_cast<char *>(strchr(Begin, '\n'));
+  if (!EOL) {
+    EOL = const_cast<char *>(Begin) + strlen(Begin);
+  }
+  const std::vector<const char *> PosList = {
+      strchr(Begin, '='), strchr(Begin, ';'), strchr(Begin, ','),
+      strchr(Begin, ')'), EOL};
+  for (const auto &Pos : PosList) {
+    if (Pos > Begin) {
+      EOL = std::min(EOL, const_cast<char *>(Pos));
+    }
+  }
+
+  StrLen = EOL - Begin;
+  std::string TypeName;
+  if (StrLen > 0) {
+    std::string Type(Begin, StrLen);
+
+    const static std::list<std::string> Keywords = {
+        // Constexpr specifiers
+        "constexpr", "constinit", "consteval",
+        // Qualifier
+        "const", "volatile", "restrict", "mutable",
+        // Storage class specifiers
+        "register", "static", "extern", "thread_local",
+        // Other keywords
+        "virtual"};
+
+    // Remove keywords
+    for (const std::string &Kw : Keywords) {
+      for (size_t Pos = 0; (Pos = Type.find(Kw, Pos)) != std::string::npos;) {
+        Type.replace(Pos, Kw.length(), "");
+      }
+    }
+    TypeName = Type.erase(0, Type.find_first_not_of(" "));
+
+    // Replace spaces with single space.
+    for (size_t Pos = 0; (Pos = Type.find("  ", Pos)) != std::string::npos;
+         Pos += strlen(" ")) {
+      Type.replace(Pos, strlen("  "), " ");
+    }
+
+    // Replace " &" with "&".
+    for (size_t Pos = 0; (Pos = Type.find(" &", Pos)) != std::string::npos;
+         Pos += strlen("&")) {
+      Type.replace(Pos, strlen(" &"), "&");
+    }
+
+    // Replace " *" with "* ".
+    for (size_t Pos = 0; (Pos = Type.find(" *", Pos)) != std::string::npos;
+         Pos += strlen("*")) {
+      Type.replace(Pos, strlen(" *"), "* ");
+    }
+
+    // Remove redundant tailing.
+    const static std::list<std::string> TailsOfMultiWordType = {
+        " int", " char", " double", " long", " short"};
+    bool RedundantRemoved = false;
+    for (const auto &Kw : TailsOfMultiWordType) {
+      size_t Pos = Type.rfind(Kw);
+      if (Pos != std::string::npos) {
+        Type = Type.substr(0, Pos + Kw.length());
+        RedundantRemoved = true;
+        break;
+      }
+    }
+    TypeName = Type.erase(0, Type.find_first_not_of(" "));
+    if (!RedundantRemoved) {
+      std::size_t FoundSpace = Type.find(" ");
+      if (FoundSpace != std::string::npos)
+        Type = Type.substr(0, FoundSpace);
+    }
+
+    TypeName = Type.erase(0, Type.find_first_not_of(" "));
+  }
+
+  return TypeName;
+}
+
+static std::string getHungarianNotationPrefix(
+    const Decl *D,
+    const IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+  const auto *ND = dyn_cast<NamedDecl>(D);
+  if (!ND)
+    return "";
+
+  std::string Prefix;
+  switch (ND->getKind()) {
+  case clang::Decl::Kind::Var:
+  case clang::Decl::Kind::Field:
+  case clang::Decl::Kind::ParmVar:
+  case clang::Decl::Kind::Record:
+    if (ND) {
+      std::string TypeName = getDeclTypeName(ND);
+      if (!TypeName.empty())
+        Prefix = getHungarianNotationDataTypePrefix(TypeName, ND, HNOption);
+    }
+    break;
+
+  case clang::Decl::Kind::EnumConstant:
+    if (ND) {
+      const auto *ECD = dyn_cast<EnumConstantDecl>(ND);
+      Prefix = getHungarianNotationEnumPrefix(ECD);
+    }
+    break;
+
+  case clang::Decl::Kind::CXXRecord:
+    if (ND) {
+      const auto *CRD = dyn_cast<CXXRecordDecl>(ND);
+      Prefix = getHungarianNotationClassPrefix(CRD, HNOption);
+    }
+    break;
+
+  default:
+    break;
+  }
+  return Prefix;
+}
+
+static bool removeDuplicatedHungarianNotationPrefix(
+    SmallVector<StringRef, 8> &Words,
+    const IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+  if (Words.size() <= 1)
+    return true;
+
+  std::string CorrectName = Words[0].str();
+  std::vector<llvm::StringMap<std::string>> MapList = {
+      HNOption.CString, HNOption.DerivedType, HNOption.PrimitiveType,
+      HNOption.UserDefinedType};
+
+  for (auto &Map : MapList) {
+    for (auto &Str : Map) {
+      bool Found = (Str.getValue() == CorrectName);
+      if (Found) {
+        Words.assign(Words.begin() + 1, Words.end());
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+static bool
+matchesStyle(StringRef Type, StringRef Name,
+             IdentifierNamingCheck::NamingStyle Style,
+             const IdentifierNamingCheck::HungarianNotationOption &HNOption,
+             const NamedDecl *Decl) {
   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])?)*"),
   };
 
   if (!Name.consume_front(Style.Prefix))
     return false;
   if (!Name.consume_back(Style.Suffix))
     return false;
+  if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType) {
+    std::string HNPrefix = getHungarianNotationPrefix(Decl, HNOption);
+    if (!Name.consume_front(HNPrefix))
+      return false;
+  }
 
   // Ensure the name doesn't have any extra underscores beyond those specified
   // in the prefix and suffix.
   if (Name.startswith("_") || Name.endswith("_"))
     return false;
 
   if (Style.Case && !Matchers[static_cast<size_t>(*Style.Case)].match(Name))
     return false;
 
   return true;
 }
 
-static std::string fixupWithCase(StringRef Name,
-                                 IdentifierNamingCheck::CaseType Case) {
+static std::string
+fixupWithCase(const StringRef &Type, const StringRef &Name, const Decl *D,
+              const IdentifierNamingCheck::NamingStyle &Style,
+              const IdentifierNamingCheck::HungarianNotationOption &HNOption,
   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;
   SmallVector<StringRef, 8> Groups;
while (!Substr.empty()) {
         Substr = Substr.substr(Groups[0].size() - Groups[6].size());
       }
     }
   }
 
   if (Words.empty())
     return Name.str();
 
+  if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType)
+    removeDuplicatedHungarianNotationPrefix(Words, HNOption);
+
   SmallString<128> Fixup;
   switch (Case) {
   case IdentifierNamingCheck::CT_AnyCase:
     return Name.str();
     break;
 
   case IdentifierNamingCheck::CT_LowerCase:
     for (auto const &Word : Words) {
for (auto const &Word : Words) {
         Fixup += tolower(Word.front());
       }
       Fixup += Word.substr(1).lower();
     }
     break;
   }
 
   return Fixup.str().str();
 }
 
 static bool isParamInMainLikeFunction(const ParmVarDecl &ParmDecl,
                                       bool IncludeMainLike) {
   const auto *FDecl =
       dyn_cast_or_null<FunctionDecl>(ParmDecl.getParentFunctionOrMethod());
   if (!FDecl)
     return false;
   if (FDecl->isMain())
     return true;
if (Type == Main) {
     static llvm::Regex Matcher("(^((W[Mm])|(wm))ain([_A-Z]|$))|([a-z0-9_]W[Mm]"
                                "ain([_A-Z]|$))|(_wmain(_|$))");
     assert(Matcher.isValid() && "Invalid Matcher for wmain like functions.");
     return Matcher.match(FDecl->getName());
   }
 }
 
 static std::string
-fixupWithStyle(StringRef Name,
-               const IdentifierNamingCheck::NamingStyle &Style) {
-  const std::string Fixed = fixupWithCase(
-      Name, Style.Case.getValueOr(IdentifierNamingCheck::CaseType::CT_AnyCase));
+fixupWithStyle(const StringRef &Type, const StringRef &Name,
+               const IdentifierNamingCheck::NamingStyle &Style,
+               const IdentifierNamingCheck::HungarianNotationOption &HNOption,
+               const Decl *D) {
+  std::string Fixed = fixupWithCase(
+      Type, Name, D, Style, HNOption,
+      Style.Case.getValueOr(IdentifierNamingCheck::CaseType::CT_AnyCase));
+  std::string HungarianPrefix;
+  if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType) {
+    HungarianPrefix = getHungarianNotationPrefix(D, HNOption);
+    if (!HungarianPrefix.empty()) {
+      if (Style.HPType ==
+          IdentifierNamingCheck::HungarianPrefixType::HPT_LowerCase) {
+        HungarianPrefix += "_";
+      }
+      if (Style.HPType ==
+          IdentifierNamingCheck::HungarianPrefixType::HPT_CamelCase) {
+        Fixed[0] = toupper(Fixed[0]);
+      }
+    }
+  }
   StringRef Mid = StringRef(Fixed).trim("_");
   if (Mid.empty())
     Mid = "_";
-  return (Style.Prefix + Mid + Style.Suffix).str();
+
+  return (Style.Prefix + HungarianPrefix + Mid + Style.Suffix).str();
 }
 
 static StyleKind findStyleKind(
     const NamedDecl *D,
     ArrayRef<llvm::Optional<IdentifierNamingCheck::NamingStyle>> NamingStyles,
     bool IgnoreMainLikeFunctions) {
   assert(D && D->getIdentifier() && !D->getName().empty() && !D->isImplicit() &&
          "Decl must be an explicit identifier with a name.");
static StyleKind findStyleKind(
 
   if (const auto *EnumConst = dyn_cast<EnumConstantDecl>(D)) {
     if (cast<EnumDecl>(EnumConst->getDeclContext())->isScoped() &&
         NamingStyles[SK_ScopedEnumConstant])
       return SK_ScopedEnumConstant;
 
     if (NamingStyles[SK_EnumConstant])
       return SK_EnumConstant;
 
     if (NamingStyles[SK_Constant])
       return SK_Constant;
 
     return SK_Invalid;
   }
 
   if (const auto *Decl = dyn_cast<CXXRecordDecl>(D)) {
     if (Decl->isAnonymousStructOrUnion())
if (const auto *Decl = dyn_cast<VarDecl>(D)) {
     if (Decl->isFileVarDecl() && Type.getTypePtr()->isAnyPointerType() && NamingStyles[SK_GlobalPointer])
       return SK_GlobalPointer;
 
     if (Decl->isFileVarDecl() && NamingStyles[SK_GlobalVariable])
       return SK_GlobalVariable;
 
     if (Decl->isStaticLocal() && NamingStyles[SK_StaticVariable])
       return SK_StaticVariable;
- 
     if (Decl->isLocalVarDecl() && Type.getTypePtr()->isAnyPointerType() && NamingStyles[SK_LocalPointer])
       return SK_LocalPointer;
 
     if (Decl->isLocalVarDecl() && NamingStyles[SK_LocalVariable])
       return SK_LocalVariable;
 
     if (Decl->isFunctionOrMethodVarDecl() && NamingStyles[SK_LocalVariable])
       return SK_LocalVariable;
if (isa<TemplateTemplateParmDecl>(D)) {
 
     return SK_Invalid;
   }
 
   return SK_Invalid;
 }
 
 static llvm::Optional<RenamerClangTidyCheck::FailureInfo> getFailureInfo(
-    StringRef Name, SourceLocation Location,
+    const StringRef &Type, const StringRef &Name, const NamedDecl *ND,
+    SourceLocation Location,
     ArrayRef<llvm::Optional<IdentifierNamingCheck::NamingStyle>> NamingStyles,
+    const IdentifierNamingCheck::HungarianNotationOption &HNOption,
     StyleKind SK, const SourceManager &SM, bool IgnoreFailedSplit) {
   if (SK == SK_Invalid || !NamingStyles[SK])
     return None;
 
   const IdentifierNamingCheck::NamingStyle &Style = *NamingStyles[SK];
-  if (matchesStyle(Name, Style))
+  if (matchesStyle(Type, Name, Style, HNOption, ND))
     return None;
 
   std::string KindName =
-      fixupWithCase(StyleNames[SK], IdentifierNamingCheck::CT_LowerCase);
+      fixupWithCase(Type, StyleNames[SK], ND, Style, HNOption,
+                    IdentifierNamingCheck::CT_LowerCase);
   std::replace(KindName.begin(), KindName.end(), '_', ' ');
 
-  std::string Fixup = fixupWithStyle(Name, Style);
+  std::string Fixup = fixupWithStyle(Type, Name, Style, HNOption, ND);
   if (StringRef(Fixup).equals(Name)) {
     if (!IgnoreFailedSplit) {
       LLVM_DEBUG(Location.print(llvm::dbgs(), SM);
                  llvm::dbgs()
                  << llvm::formatv(": unable to split words for {0} '{1}'\n",
                                   KindName, Name));
     }
     return None;
   }
   return RenamerClangTidyCheck::FailureInfo{std::move(KindName),
                                             std::move(Fixup)};
 }
 
 llvm::Optional<RenamerClangTidyCheck::FailureInfo>
 IdentifierNamingCheck::GetDeclFailureInfo(const NamedDecl *Decl,
                                           const SourceManager &SM) const {
   SourceLocation Loc = Decl->getLocation();
   ArrayRef<llvm::Optional<NamingStyle>> NamingStyles =
       getStyleForFile(SM.getFilename(Loc));
 
+  std::string TypeName = getDeclTypeName(Decl);
   return getFailureInfo(
-      Decl->getName(), Loc, NamingStyles,
+      TypeName, Decl->getName(), Decl, Loc, NamingStyles, HNOption,
       findStyleKind(Decl, NamingStyles, IgnoreMainLikeFunctions), SM,
       IgnoreFailedSplit);
 }
 
 llvm::Optional<RenamerClangTidyCheck::FailureInfo>
 IdentifierNamingCheck::GetMacroFailureInfo(const Token &MacroNameTok,
                                            const SourceManager &SM) const {
   SourceLocation Loc = MacroNameTok.getLocation();
 
-  return getFailureInfo(MacroNameTok.getIdentifierInfo()->getName(), Loc,
-                        getStyleForFile(SM.getFilename(Loc)),
+  return getFailureInfo("", MacroNameTok.getIdentifierInfo()->getName(), NULL,
+                        Loc, getStyleForFile(SM.getFilename(Loc)), HNOption,
                         SK_MacroDefinition, SM, IgnoreFailedSplit);
 }
 
 RenamerClangTidyCheck::DiagInfo
 IdentifierNamingCheck::GetDiagInfo(const NamingCheckId &ID,
                                    const NamingCheckFailure &Failure) const {
   return DiagInfo{"invalid case style for %0 '%1'",
                   [&](DiagnosticBuilder &Diag) {
                     Diag << Failure.Info.KindName << ID.second;
                   }};
 }
 
 ArrayRef<llvm::Optional<IdentifierNamingCheck::NamingStyle>>
 IdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
   if (!GetConfigPerFile)
     return MainFileStyle;
   auto &Styles = NamingStylesCache[llvm::sys::path::parent_path(FileName)];
   if (Styles.empty()) {
+    HungarianNotationOption HNOption;
     ClangTidyOptions Options = Context->getOptionsForFile(FileName);
     if (Options.Checks && GlobList(*Options.Checks).contains(CheckName))
-      Styles = getNamingStyles({CheckName, Options.CheckOptions});
+      Styles = getNamingStyles({CheckName, Options.CheckOptions}, HNOption);
     else
       Styles.resize(SK_Count, None);
   }
   return Styles;
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
 - Checks that allow configuring names of headers to include now support wrapping
   the include in angle brackets to create a system include. For example,
   :doc:`cppcoreguidelines-init-variables
   <clang-tidy/checks/cppcoreguidelines-init-variables>` and
   :doc:`modernize-make-unique <clang-tidy/checks/modernize-make-unique>`.
 
 New modules
 ^^^^^^^^^^^
 
 - New ``altera`` module.
 
   Includes checks related to OpenCL for FPGA coding guidelines, based on the
   `Altera SDK for OpenCL: Best Practices Guide
   <https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
 

 - New :doc:`readability-function-cognitive-complexity
   <clang-tidy/checks/readability-function-cognitive-complexity>` check.
 
   Flags functions with Cognitive Complexity metric exceeding the configured limit.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`modernize-loop-convert
   <clang-tidy/checks/modernize-loop-convert>` check.
 
   Now able to transform iterator loops using ``rbegin`` and ``rend`` methods.
 
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability-identifier-naming>` check.
 
   Added an option `GetConfigPerFile` to support including files which use
   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.
 
+- Improved :doc:`readability-identifier-naming
+  <clang-tidy/checks/readability-identifier-naming>` check.  
+
+  Added new options HungarianPrefix for variable decls to check variable with 
+  Hungarian Notation which the prefix encodes the actual data type of the variable.
+  
 - Removed `google-runtime-references` check because the rule it checks does
   not exist in the Google Style Guide anymore.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 

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

 
  - ``lower_case``,
  - ``UPPER_CASE``,
  - ``camelBack``,
  - ``CamelCase``,
  - ``camel_Snake_Back``,
  - ``Camel_Snake_Case``,
  - ``aNy_CasE``.
 
 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 kinds of identifiers. In general, the rules are
 falling back to a more generic rule if the specific case is not configured.
 
 The naming of virtual methods is reported where they occur in the base class,

  - :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:`EnumConstantCase`, :option:`EnumConstantPrefix`, :option:`EnumConstantSuffix`, :option:`EnumConstantHungarianPrefix`
  - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix`
  - :option:`GetConfigPerFile`
- - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix`
- - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix`
+ - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix`, :option:`GlobalConstantHungarianPrefix`
+ - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix`, :option:`GlobalConstantPointerHungarianPrefix`
  - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`, :option:`GlobalFunctionSuffix`
- - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix`
- - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix`
+ - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix`, :option:`GlobalPointerHungarianPrefix`
+ - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix`, :option:`GlobalVariableHungarianPrefix`
  - :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:`LocalConstantCase`, :option:`LocalConstantPrefix`, :option:`LocalConstantSuffix`, :option:`LocalConstantHungarianPrefix`
+ - :option:`LocalConstantPointerCase`, :option:`LocalConstantPointerPrefix`, :option:`LocalConstantPointerSuffix`, :option:`LocalConstantPointerHungarianPrefix`
+ - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`, :option:`LocalPointerSuffix`, :option:`LocalPointerHungarianPrefix`
+ - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`, :option:`LocalVariableSuffix`, :option:`LocalVariableHungarianPrefix`
  - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`, :option:`MacroDefinitionSuffix`
- - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`
+ - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`, :option:`MemberHungarianPrefix`
  - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix`
  - :option:`NamespaceCase`, :option:`NamespacePrefix`, :option:`NamespaceSuffix`
- - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix`
+ - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix`, :option:`ParameterHungarianPrefix`
  - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix`
- - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix`
- - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix`
+ - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix`, :option:`PointerParameterHungarianPrefix`
+ - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix`, :option:`PrivateMemberHungarianPrefix`
  - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix`
- - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix`
+ - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix`, :option:`ProtectedMemberHungarianPrefix`
  - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix`
- - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix`
+ - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix`, :option:`PublicMemberHungarianPrefix`
  - :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:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix`, :option:`StaticConstantHungarianPrefix`
+ - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix`, :option:`StaticVariableHungarianPrefix`
  - :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:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix`, :option:`VariableHungarianPrefix`
  - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`, :option:`VirtualMethodSuffix`
 
 .. 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:: AbstractClassSuffix
 
     When defined, the check will ensure abstract class names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: AbstractClassHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - AbstractClassCase of ``lower_case``
    - AbstractClassPrefix of ``pre_``
    - AbstractClassSuffix of ``_post``
+   - AbstractClassHungarianPrefix of ``On``
+
 
 Identifies and/or transforms abstract class names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class ABSTRACT_CLASS {
.. option:: ClassPrefix
     When defined, the check will ensure class names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ClassSuffix
 
     When defined, the check will ensure class names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ClassHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ClassCase of ``lower_case``
    - ClassPrefix of ``pre_``
    - ClassSuffix of ``_post``
+   - ClassHungarianPrefix of ``On``
 
 Identifies and/or transforms class names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class FOO {
.. option:: ClassConstantPrefix
     When defined, the check will ensure class constant names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ClassConstantSuffix
 
     When defined, the check will ensure class constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ClassConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ClassConstantCase of ``lower_case``
    - ClassConstantPrefix of ``pre_``
    - ClassConstantSuffix of ``_post``
+   - ClassConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms class constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class FOO {
.. option:: ClassMemberPrefix
     When defined, the check will ensure class member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ClassMemberSuffix
 
     When defined, the check will ensure class member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ClassMemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ClassMemberCase of ``lower_case``
    - ClassMemberPrefix of ``pre_``
    - ClassMemberSuffix of ``_post``
+   - ClassMemberHungarianPrefix of ``On``
 
 Identifies and/or transforms class member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class FOO {
.. option:: ClassMethodPrefix
     When defined, the check will ensure class method names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ClassMethodSuffix
 
     When defined, the check will ensure class method names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ClassMethodHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ClassMethodCase of ``lower_case``
    - ClassMethodPrefix of ``pre_``
    - ClassMethodSuffix of ``_post``
+   - ClassMethodHungarianPrefix of ``On``
 
 Identifies and/or transforms class method names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class FOO {
.. option:: ConstantPrefix
     When defined, the check will ensure constant names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ConstantSuffix
 
     When defined, the check will ensure constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ConstantCase of ``lower_case``
    - ConstantPrefix of ``pre_``
    - ConstantSuffix of ``_post``
+   - ConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void function() { unsigned const MyConst_array[] = {1, 2, 3}; }
.. option:: ConstantMemberPrefix
     When defined, the check will ensure constant member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ConstantMemberSuffix
 
     When defined, the check will ensure constant member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ConstantMemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ConstantMemberCase of ``lower_case``
    - ConstantMemberPrefix of ``pre_``
    - ConstantMemberSuffix of ``_post``
+   - ConstantMemberHungarianPrefix of ``On``
 
 Identifies and/or transforms constant member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: ConstantParameterPrefix
     When defined, the check will ensure constant parameter names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ConstantParameterSuffix
 
     When defined, the check will ensure constant parameter names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ConstantParameterHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ConstantParameterCase of ``lower_case``
    - ConstantParameterPrefix of ``pre_``
    - ConstantParameterSuffix of ``_post``
+   - ConstantParameterHungarianPrefix of ``On``
 
 Identifies and/or transforms constant parameter names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
.. option:: ConstantPointerParameterPrefix
     When defined, the check will ensure constant pointer parameter names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ConstantPointerParameterSuffix
 
     When defined, the check will ensure constant pointer parameter names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ConstantPointerParameterHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ConstantPointerParameterCase of ``lower_case``
    - ConstantPointerParameterPrefix of ``pre_``
    - ConstantPointerParameterSuffix of ``_post``
+   - ConstantPointerParameterHungarianPrefix of ``On``
 
 Identifies and/or transforms constant pointer parameter names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void GLOBAL_FUNCTION(int const *CONST_parameter);
.. option:: ConstexprVariablePrefix
     When defined, the check will ensure constexpr variable names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ConstexprVariableSuffix
 
     When defined, the check will ensure constexpr variable names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ConstexprVariableHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ConstexprVariableCase of ``lower_case``
    - ConstexprVariablePrefix of ``pre_``
    - ConstexprVariableSuffix of ``_post``
+   - ConstexprVariableHungarianPrefix of ``On``
 
 Identifies and/or transforms constexpr variable names as follows:
 
 Before:
 
 .. code-block:: c++
 
     constexpr int ConstExpr_variable = MyConstant;
.. option:: EnumConstantPrefix
     When defined, the check will ensure enumeration constant names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: EnumConstantSuffix
 
     When defined, the check will ensure enumeration constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: EnumConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - EnumConstantCase of ``lower_case``
    - EnumConstantPrefix of ``pre_``
    - EnumConstantSuffix of ``_post``
+   - EnumConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms enumeration constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     enum FOO { One, Two, Three };

 
 .. code-block:: c++
 
     char pre_my_function_string_post();
 
 .. option:: GetConfigPerFile
 
     When `true` the check will look for the configuration for where an
-    identifier is declared. Useful for when included header files use a 
-    different style. 
+    identifier is declared. Useful for when included header files use a
+    different style.
     Default value is `true`.
 
 .. 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:: GlobalConstantSuffix
 
     When defined, the check will ensure global constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: GlobalConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - GlobalConstantCase of ``lower_case``
    - GlobalConstantPrefix of ``pre_``
    - GlobalConstantSuffix of ``_post``
+   - GlobalConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms global constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     unsigned const MyConstGlobal_array[] = {1, 2, 3};
.. option:: GlobalConstantPointerPrefix
     When defined, the check will ensure global constant pointer names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: GlobalConstantPointerSuffix
 
     When defined, the check will ensure global constant pointer names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: GlobalConstantPointerHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - GlobalConstantPointerCase of ``lower_case``
    - GlobalConstantPointerPrefix of ``pre_``
    - GlobalConstantPointerSuffix of ``_post``
+   - GlobalConstantPointerHungarianPrefix of ``On``
 
 Identifies and/or transforms global constant pointer names as follows:
 
 Before:
 
 .. code-block:: c++
 
     int *const MyConstantGlobalPointer = nullptr;
.. option:: GlobalPointerPrefix
     When defined, the check will ensure global pointer names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: GlobalPointerSuffix
 
     When defined, the check will ensure global pointer names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: GlobalPointerHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - GlobalPointerCase of ``lower_case``
    - GlobalPointerPrefix of ``pre_``
    - GlobalPointerSuffix of ``_post``
+   - GlobalPointerHungarianPrefix of ``On``
 
 Identifies and/or transforms global pointer names as follows:
 
 Before:
 
 .. code-block:: c++
 
     int *GLOBAL3;
.. option:: GlobalVariablePrefix
     When defined, the check will ensure global variable names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: GlobalVariableSuffix
 
     When defined, the check will ensure global variable names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: GlobalVariableHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - GlobalVariableCase of ``lower_case``
    - GlobalVariablePrefix of ``pre_``
    - GlobalVariableSuffix of ``_post``
+   - GlobalVariableHungarianPrefix of ``On``
 
 Identifies and/or transforms global variable names as follows:
 
 Before:
 
 .. code-block:: c++
 
     int GLOBAL3;
 
 After:
 
 .. code-block:: c++
 
     int pre_global3_post;
 
 .. option:: IgnoreMainLikeFunctions
 
-    When set to `1` functions that have a similar signature to ``main`` or 
+    When set to `1` functions that have a similar signature to ``main`` or
     ``wmain`` won't enforce checks on the names of their parameters.
     Default value is `0`.
 
 .. option:: InlineNamespaceCase
 
     When defined, the check will ensure inline namespaces 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:: LocalConstantSuffix
 
     When defined, the check will ensure local constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: LocalConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - LocalConstantCase of ``lower_case``
    - LocalConstantPrefix of ``pre_``
    - LocalConstantSuffix of ``_post``
+   - LocalConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms local constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void foo() { int const local_Constant = 3; }
.. option:: LocalConstantPointerPrefix
     When defined, the check will ensure local constant pointer names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: LocalConstantPointerSuffix
 
     When defined, the check will ensure local constant pointer names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: LocalConstantPointerHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - LocalConstantPointerCase of ``lower_case``
    - LocalConstantPointerPrefix of ``pre_``
    - LocalConstantPointerSuffix of ``_post``
+   - LocalConstantPointerHungarianPrefix of ``On``
 
 Identifies and/or transforms local constant pointer names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void foo() { int const *local_Constant = 3; }
.. option:: LocalPointerPrefix
     When defined, the check will ensure local pointer names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: LocalPointerSuffix
 
     When defined, the check will ensure local pointer names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: LocalPointerHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - LocalPointerCase of ``lower_case``
    - LocalPointerPrefix of ``pre_``
    - LocalPointerSuffix of ``_post``
+   - LocalPointerHungarianPrefix of ``On``
 
 Identifies and/or transforms local pointer names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void foo() { int *local_Constant; }
.. option:: LocalVariablePrefix
     When defined, the check will ensure local variable names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: LocalVariableSuffix
 
     When defined, the check will ensure local variable names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: LocalVariableHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - LocalVariableCase of ``lower_case``
    - LocalVariablePrefix of ``pre_``
    - LocalVariableSuffix of ``_post``
+   - LocalVariableHungarianPrefix of ``On``
 
 Identifies and/or transforms local variable names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void foo() { int local_Constant; }
.. option:: MemberPrefix
     When defined, the check will ensure member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: MemberSuffix
 
     When defined, the check will ensure member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: MemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - MemberCase of ``lower_case``
    - MemberPrefix of ``pre_``
    - MemberSuffix of ``_post``
+   - MemberHungarianPrefix of ``On``
 
 Identifies and/or transforms member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: ParameterPrefix
     When defined, the check will ensure parameter names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ParameterSuffix
 
     When defined, the check will ensure parameter names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ParameterHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ParameterCase of ``lower_case``
    - ParameterPrefix of ``pre_``
    - ParameterSuffix of ``_post``
+   - ParameterHungarianPrefix of ``On``
 
 Identifies and/or transforms parameter names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
.. option:: PointerParameterPrefix
     When defined, the check will ensure pointer parameter names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: PointerParameterSuffix
 
     When defined, the check will ensure pointer parameter names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: PointerParameterHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - PointerParameterCase of ``lower_case``
    - PointerParameterPrefix of ``pre_``
    - PointerParameterSuffix of ``_post``
+   - PointerParameterHungarianPrefix of ``On``
 
 Identifies and/or transforms pointer parameter names as follows:
 
 Before:
 
 .. code-block:: c++
 
     void FUNCTION(int *PARAMETER);
.. option:: PrivateMemberPrefix
     When defined, the check will ensure private member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: PrivateMemberSuffix
 
     When defined, the check will ensure private member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: PrivateMemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - PrivateMemberCase of ``lower_case``
    - PrivateMemberPrefix of ``pre_``
    - PrivateMemberSuffix of ``_post``
+   - PrivateMemberHungarianPrefix of ``On``
 
 Identifies and/or transforms private member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: PrivateMethodPrefix
     When defined, the check will ensure private method names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: PrivateMethodSuffix
 
     When defined, the check will ensure private method names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: PrivateMethodHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - PrivateMethodCase of ``lower_case``
    - PrivateMethodPrefix of ``pre_``
    - PrivateMethodSuffix of ``_post``
+   - PrivateMethodHungarianPrefix of ``On``
 
 Identifies and/or transforms private method names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: ProtectedMemberPrefix
     When defined, the check will ensure protected member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: ProtectedMemberSuffix
 
     When defined, the check will ensure protected member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: ProtectedMemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - ProtectedMemberCase of ``lower_case``
    - ProtectedMemberPrefix of ``pre_``
    - ProtectedMemberSuffix of ``_post``
+   - ProtectedMemberHungarianPrefix of ``On``
 
 Identifies and/or transforms protected member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: PublicMemberPrefix
     When defined, the check will ensure public member names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: PublicMemberSuffix
 
     When defined, the check will ensure public member names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: PublicMemberHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - PublicMemberCase of ``lower_case``
    - PublicMemberPrefix of ``pre_``
    - PublicMemberSuffix of ``_post``
+   - PublicMemberHungarianPrefix of ``On``
 
 Identifies and/or transforms public member names as follows:
 
 Before:
 
 .. code-block:: c++
 
     class Foo {
.. option:: StaticConstantPrefix
     When defined, the check will ensure static constant names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: StaticConstantSuffix
 
     When defined, the check will ensure static constant names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: StaticConstantHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - StaticConstantCase of ``lower_case``
    - StaticConstantPrefix of ``pre_``
    - StaticConstantSuffix of ``_post``
+   - StaticConstantHungarianPrefix of ``On``
 
 Identifies and/or transforms static constant names as follows:
 
 Before:
 
 .. code-block:: c++
 
     static unsigned const MyConstStatic_array[] = {1, 2, 3};
.. option:: StaticVariablePrefix
     When defined, the check will ensure static variable names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: StaticVariableSuffix
 
     When defined, the check will ensure static variable names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: StaticVariableHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - StaticVariableCase of ``lower_case``
    - StaticVariablePrefix of ``pre_``
    - StaticVariableSuffix of ``_post``
+   - StaticVariableHungarianPrefix of ``On``
 
 Identifies and/or transforms static variable names as follows:
 
 Before:
 
 .. code-block:: c++
 
     static unsigned MyStatic_array[] = {1, 2, 3};
.. option:: VariablePrefix
     When defined, the check will ensure variable names will add the
     prefixed with the given value (regardless of casing).
 
 .. option:: VariableSuffix
 
     When defined, the check will ensure variable names will add the
     suffix with the given value (regardless of casing).
 
+.. option:: VariableHungarianPrefix
+
+    When set to `true` the check will ensure the name will add Hungarian Notation
+    prefix for the given data type. The default value is `Off`.
+
 For example using values of:
 
    - VariableCase of ``lower_case``
    - VariablePrefix of ``pre_``
    - VariableSuffix of ``_post``
+   - VariableHungarianPrefix of ``On``
 
 Identifies and/or transforms variable names as follows:
 
 Before:
 
 .. code-block:: c++
 
     unsigned MyVariable;

 After:
 
 .. code-block:: c++
 
     class Foo {
     public:
       virtual int pre_member_function_post();
     }
+
+
+The default mapping table of Hungarian Notation
+-----------------------------------------------
+
+In Hungarian notation, a variable name starts with a group of lower-case
+letters which are mnemonics for the type or purpose of that variable, followed
+by whatever name the programmer has chosen; this last part is sometimes
+distinguished as the given name. The first character of the given name can be
+capitalized to separate it from the type indicators (see also CamelCase).
+Otherwise the case of this character denotes scope.
+
+This tool supports all casing types that means not only CamelCase starts with
+Hungarian Notation, others either.
+
+The following table is the default mapping table of Hungarian Notation which
+maps Decl to its prefix string. You can also have your own style in config file.
+
+================= ============== ====================== ============== =========== ==============
+Primitive Types                                                        Microsoft data types
+---------------------------------------------------------------------- --------------------------
+    Type          Prefix         Type                   Prefix         Type        Prefix
+================= ============== ====================== ============== =========== ==============
+int8_t            i8             signed int             si             BOOL        b
+int16_t           i16            signed short           ss             BOOLEAN     b
+int32_t           i32            signed short int       ssi            BYTE        by
+int64_t           i64            signed long long int   slli           CHAR        c
+uint8_t           u8             signed long long       sll            UCHAR       uc
+uint16_t          u16            signed long int        sli            SHORT       s
+uint32_t          u32            signed long            sl             USHORT      us
+uint64_t          u64            signed                 s              WORD        w
+char8_t           c8             unsigned long long int ulli           DWORD       dw
+char16_t          c16            unsigned long long     ull            DWORD32     dw32
+char32_t          c32            unsigned long int      uli            DWORD64     dw64
+float             f              unsigned long          ul             LONG        l
+double            d              unsigned short int     usi            ULONG       ul
+char              c              unsigned short         us             ULONG32     ul32
+bool              b              unsigned int           ui             ULONG64     ul64
+_Bool             b              unsigned               u              ULONGLONG   ull
+int               i              long long int          lli            HANDLE      h
+size_t            n              long double            ld             INT         i
+short             s              long long              ll             INT8        i8
+signed            i              long int               li             INT16       i16
+unsigned          u              long                   l              INT32       i32
+long              l              ptrdiff_t              p              INT64       i64
+long long         ll                                                   UINT        ui
+unsigned long     ul                                                   UINT8       u8
+long double       ld                                                   UINT16      u16
+ptrdiff_t         p                                                    UINT32      u32
+wchar_t           wc                                                   UINT64      u64
+short int         si                                                   PVOID       p
+short             s
+================= ============== ====================== ============== =========== ==============
+
+**There are more trivial options for Hungarian Notation:**
+
+**HungarianNotation.General.***
+  Options are not belonging to any specific Decl.
+
+**HungarianNotation.CString.***
+  Options for NULL terminated string, you can customized your prefix here.
+
+**HungarianNotation.DerivedType.***
+ Options for derived types, you can customized your prefix here.
+
+**HungarianNotation.PrimitiveType.***
+  Options for primitive types, you can customized your prefix here.
+
+**HungarianNotation.UserDefinedType.***
+  Options for redefined types(Microsoft data types), you can customized your
+  prefix here.
+
+
+Options for Hungarian Notation
+------------------------------
+
+- :option:`HungarianNotation.General.TreatStructAsClass`
+
+- :option:`HungarianNotation.DerivedType.Array`
+- :option:`HungarianNotation.DerivedType.Pointer`
+- :option:`HungarianNotation.DerivedType.FunctionPointer`
+
+- :option:`HungarianNotation.CString.CharPrinter`
+- :option:`HungarianNotation.CString.CharArray`
+- :option:`HungarianNotation.CString.WideCharPrinter`
+- :option:`HungarianNotation.CString.WideCharArray`
+
+- :option:`HungarianNotation.PrimitiveType.*`
+- :option:`HungarianNotation.UserDefinedType.*`
+
+.. option:: HungarianNotation.General.TreatStructAsClass
+
+    When defined, the check will treat naming of struct as a class.
+    The default value is `false`.
+
+.. option:: HungarianNotation.DerivedType.Array
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `a`.
+
+.. option:: HungarianNotation.DerivedType.Pointer
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `p`.
+
+.. option:: HungarianNotation.DerivedType.FunctionPointer
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `fn`.
+
+
+Before:
+
+.. code-block:: c++
+
+    // Array
+    int DataArray[2] = {0};
+
+    // Pointer
+    void *DataBuffer = NULL;
+
+    // FunctionPointer
+    typedef void (*FUNC_PTR)();
+    FUNC_PTR FuncPtr = NULL;
+
+After:
+
+.. code-block:: c++
+
+    // Array
+    int aDataArray[2] = {0};
+
+    // Pointer
+    void *pDataBuffer = NULL;
+
+    // FunctionPointer
+    typedef void (*FUNC_PTR)();
+    FUNC_PTR fnFuncPtr = NULL;
+
+
+.. option:: HungarianNotation.CString.CharPrinter
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `sz`.
+
+.. option:: HungarianNotation.CString.CharArray
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `sz`.
+
+.. option:: HungarianNotation.CString.WideCharPrinter
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `wsz`.
+
+.. option:: HungarianNotation.CString.WideCharArray
+
+    When defined, the check will ensure variable name will add the prefix with
+    the given string. The default prefix is `wsz`.
+
+
+Before:
+
+.. code-block:: c++
+
+    // CharPrinter
+    const char *NamePtr = "Name";
+
+    // CharArray
+    const char NameArray[] = "Name";
+
+    // WideCharPrinter
+    const wchar_t *WideNamePtr = L"Name";
+
+    // WideCharArray
+    const wchar_t WideNameArray[] = L"Name";
+
+After:
+
+.. code-block:: c++
+
+    // CharPrinter
+    const char *szNamePtr = "Name";
+
+    // CharArray
+    const char szNameArray[] = "Name";
+
+    // WideCharPrinter
+    const wchar_t *wszWideNamePtr = L"Name";
+
+    // WideCharArray
+    const wchar_t wszWideNameArray[] = L"Name";
+
+
+.. option:: HungarianNotation.PrimitiveType.*
+
+    When defined, the check will ensure variable name of involved primitive
+    types will add the prefix with the given string. The default prefixes are
+    defined in the default mapping table.
+
+.. option:: HungarianNotation.UserDefinedType.*
+
+    When defined, the check will ensure variable name of involved primitive
+    types will add the prefix with the given string. The default prefixes are
+    defined in the default mapping table.
+
+
+Before:
+
+.. code-block:: c++
+
+    int8_t   ValueI8      = 0;
+    int16_t  ValueI16     = 0;
+    int32_t  ValueI32     = 0;
+    int64_t  ValueI64     = 0;
+    uint8_t  ValueU8      = 0;
+    uint16_t ValueU16     = 0;
+    uint32_t ValueU32     = 0;
+    uint64_t ValueU64     = 0;
+    float    ValueFloat   = 0.0;
+    double   ValueDouble  = 0.0;
+    ULONG    ValueUlong   = 0;
+    DWORD    ValueDword   = 0;
+
+After:
+
+.. code-block:: c++
+
+    int8_t   i8ValueI8    = 0;
+    int16_t  i16ValueI16  = 0;
+    int32_t  i32ValueI32  = 0;
+    int64_t  i64ValueI64  = 0;
+    uint8_t  u8ValueU8    = 0;
+    uint16_t u16ValueU16  = 0;
+    uint32_t u32ValueU32  = 0;
+    uint64_t u64ValueU64  = 0;
+    float    fValueFloat  = 0.0;
+    double   dValueDouble = 0.0;
+    ULONG    ulValueUlong = 0;
+    DWORD    dwValueDword = 0;

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-hungarian-notation-cfgfile.cpp

+// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
+// RUN:   -config='{ CheckOptions: [ \
+// RUN:     { key: readability-identifier-naming.ClassCase                                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.AbstractClassCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ClassMemberCase                                         , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantCase                                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantMemberCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantParameterCase                                   , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantPointerParameterCase                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstexprVariableCase                                   , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantPointerCase                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalVariableCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantPointerCase                                , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalPointerCase                                        , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalVariableCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.MemberCase                                              , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ParameterCase                                           , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.PointerParameterCase                                    , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.PrivateMemberCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StaticConstantCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StaticVariableCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StructCase                                              , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.UnionCase                                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.VariableCase                                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ClassHungarianPrefix                                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.AbstractClassHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ClassMemberHungarianPrefix                              , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantHungarianPrefix                                 , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantMemberHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantParameterHungarianPrefix                        , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantPointerParameterHungarianPrefix                 , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstexprVariableHungarianPrefix                        , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantPointerHungarianPrefix                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalVariableHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantPointerHungarianPrefix                     , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalPointerHungarianPrefix                             , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalVariableHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.MemberHungarianPrefix                                   , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ParameterHungarianPrefix                                , value: On        }, \
+// RUN:     { key: readability-identifier-naming.PointerParameterHungarianPrefix                         , value: On        }, \
+// RUN:     { key: readability-identifier-naming.PrivateMemberHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StaticConstantHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StaticVariableHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StructHungarianPrefix                                   , value: On        }, \
+// RUN:     { key: readability-identifier-naming.UnionHungarianPrefix                                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.VariableHungarianPrefix                                 , value: On        }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.Options.TreatStructAsClass            , value: false     }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.DerivedType.Array                     , value: a    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.DerivedType.Pointer                   , value: p    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.DerivedType.FunctionPointer           , value: fn   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.CString.CharPrinter                   , value: sz   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.CString.CharArray                     , value: sz   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.CString.WideCharPrinter               , value: wsz  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.CString.WideCharArray                 , value: wsz  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.int8_t                  , value: i8   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.int16_t                 , value: i16  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.int32_t                 , value: i32  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.int64_t                 , value: i64  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint8_t                 , value: u8   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint16_t                , value: u16  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint32_t                , value: u32  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint64_t                , value: u64  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.char8_t                 , value: c8   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.char16_t                , value: c16  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.char32_t                , value: c32  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.float                   , value: f    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.double                  , value: d    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.char                    , value: c    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.bool                    , value: b    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType._Bool                   , value: b    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.int                     , value: i    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.size_t                  , value: n    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.wchar_t                 , value: wc   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.short-int               , value: si   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.short                   , value: s    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-int              , value: si   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short            , value: ss   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short-int        , value: ssi  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long-int    , value: slli }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long        , value: sll  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-int         , value: sli  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long             , value: sl   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed                  , value: s    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long-int  , value: ulli }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long      , value: ull  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-int       , value: uli  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long           , value: ul   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short-int      , value: usi  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short          , value: us   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-int            , value: ui   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned                , value: u    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long-int           , value: lli  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-double             , value: ld   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long               , value: ll   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-int                , value: li   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.long                    , value: l    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.PrimitiveType.ptrdiff_t               , value: p    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOL                  , value: b    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOLEAN               , value: b    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.BYTE                  , value: by   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.CHAR                  , value: c    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UCHAR                 , value: uc   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.SHORT                 , value: s    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.USHORT                , value: us   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.WORD                  , value: w    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD                 , value: dw   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD32               , value: dw32 }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD64               , value: dw64 }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.LONG                  , value: l    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG                 , value: ul   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG32               , value: ul32 }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG64               , value: ul64 }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONGLONG             , value: ull  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.HANDLE                , value: h    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT                   , value: i    }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT8                  , value: i8   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT16                 , value: i16  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT32                 , value: i32  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT64                 , value: i64  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT                  , value: ui   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT8                 , value: u8   }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT16                , value: u16  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT32                , value: u32  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT64                , value: u64  }, \
+// RUN:     { key: readability-identifier-naming.HungarianNotation.UserDefinedType.PVOID                 , value: p    }, \
+// RUN:   ]}'
+
+// clang-format off
+typedef signed char         int8_t;     // NOLINT
+typedef short               int16_t;    // NOLINT
+typedef long                int32_t;    // NOLINT
+typedef long long           int64_t;    // NOLINT
+typedef unsigned char       uint8_t;    // NOLINT
+typedef unsigned short      uint16_t;   // NOLINT
+typedef unsigned long       uint32_t;   // NOLINT
+typedef unsigned long long  uint64_t;   // NOLINT
+#ifndef _WIN32
+typedef unsigned long long  size_t;     // NOLINT
+#endif
+typedef long                intptr_t;   // NOLINT
+typedef unsigned long       uintptr_t;  // NOLINT
+typedef long int            ptrdiff_t;  // NOLINT
+typedef unsigned char       BYTE;       // NOLINT
+typedef unsigned short      WORD;       // NOLINT
+typedef unsigned long       DWORD;      // NOLINT
+typedef int                 BOOL;       // NOLINT
+typedef int                 BOOLEAN;    // NOLINT
+typedef float               FLOAT;      // NOLINT
+typedef int                 INT;        // NOLINT
+typedef unsigned int        UINT;       // NOLINT
+typedef unsigned long       ULONG;      // NOLINT
+typedef short               SHORT;      // NOLINT
+typedef unsigned short      USHORT;     // NOLINT
+typedef char                CHAR;       // NOLINT
+typedef unsigned char       UCHAR;      // NOLINT
+typedef signed char         INT8;       // NOLINT
+typedef signed short        INT16;      // NOLINT
+typedef signed int          INT32;      // NOLINT
+typedef signed long long    INT64;      // NOLINT
+typedef unsigned char       UINT8;      // NOLINT
+typedef unsigned short      UINT16;     // NOLINT
+typedef unsigned int        UINT32;     // NOLINT
+typedef unsigned long long  UINT64;     // NOLINT
+typedef long                LONG;       // NOLINT
+typedef signed int          LONG32;     // NOLINT
+typedef unsigned int        ULONG32;    // NOLINT
+typedef uint64_t            ULONG64;    // NOLINT
+typedef unsigned int        DWORD32;    // NOLINT
+typedef uint64_t            DWORD64;    // NOLINT
+typedef uint64_t            ULONGLONG;  // NOLINT
+typedef void*               PVOID;      // NOLINT
+typedef void*               HANDLE;     // NOLINT
+typedef void*               FILE;       // NOLINT
+#define NULL                (0)         // NOLINT
+// clang-format on
+
+// clang-format off
+//===----------------------------------------------------------------------===//
+// Cases to CheckOptions
+//===----------------------------------------------------------------------===//
+class CMyClass1 {
+public:
+  static int ClassMemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  static int iClassMemberCase;
+
+  char const ConstantMemberCase = 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char const cConstantMemberCase = 0;
+
+  void MyFunc1(const int ConstantParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for constant parameter 'ConstantParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void MyFunc1(const int iConstantParameterCase);
+
+  void MyFunc2(const int* ConstantPointerParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: invalid case style for pointer parameter 'ConstantPointerParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void MyFunc2(const int* piConstantPointerParameterCase);
+
+  static constexpr int ConstexprVariableCase = 123;
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constexpr variable 'ConstexprVariableCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  static constexpr int iConstexprVariableCase = 123;
+};
+
+const int GlobalConstantCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int iGlobalConstantCase = 0;
+
+const int* GlobalConstantPointerCase = nullptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'GlobalConstantPointerCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int* piGlobalConstantPointerCase = nullptr;
+
+int GlobalVariableCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iGlobalVariableCase = 0;
+
+void Func1(){
+  int const LocalConstantCase = 3;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int const iLocalConstantCase = 3;
+
+  int* const LocalConstantPointerCase = nullptr;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int* const piLocalConstantPointerCase = nullptr;
+
+  int *LocalPointerCase = nullptr;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int *piLocalPointerCase = nullptr;
+
+  int LocalVariableCase = 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int iLocalVariableCase = 0;
+}
+
+class CMyClass2 {
+  char MemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char cMemberCase;
+
+  void Func1(int ParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func1(int iParameterCase);
+
+  void Func2(const int ParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constant parameter 'ParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func2(const int iParameterCase);
+
+  void Func3(const int *PointerParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for pointer parameter 'PointerParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func3(const int *piPointerParameterCase);
+};
+
+class CMyClass3 {
+private:
+  char PrivateMemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char cPrivateMemberCase;
+};
+
+static const int StaticConstantCase = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static const int iStaticConstantCase = 3;
+
+static int StaticVariableCase = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static int iStaticVariableCase = 3;
+
+struct MyStruct { int StructCase; };
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for member 'StructCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}struct MyStruct { int iStructCase; };
+
+union MyUnion { int UnionCase1; long lUnionCase2; };
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for member 'UnionCase1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}union MyUnion { int iUnionCase1; long lUnionCase2; };
+
+//===----------------------------------------------------------------------===//
+// C string
+//===----------------------------------------------------------------------===//
+const char *NamePtr = "Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char *szNamePtr = "Name";
+
+const char NameArray[] = "Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char szNameArray[] = "Name";
+
+const char *NamePtrArray[] = {"AA", "BB"};
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char *pszNamePtrArray[] = {"AA", "BB"};
+
+const wchar_t *WideNamePtr = L"Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t *wszWideNamePtr = L"Name";
+
+const wchar_t WideNameArray[] = L"Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t wszWideNameArray[] = L"Name";
+
+const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"};
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"};
+
+class CMyClass4 {
+private:
+  char *Name = "Text";
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'Name' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char *szName = "Text";
+
+  const char *ConstName = "Text";
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for private member 'ConstName' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  const char *szConstName = "Text";
+
+public:
+  const char* DuplicateString(const char* Input, size_t nRequiredSize);
+  // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  const char* DuplicateString(const char* szInput, size_t nRequiredSize);
+
+  size_t UpdateText(const char* Buffer, size_t nBufferSize);
+  // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  size_t UpdateText(const char* szBuffer, size_t nBufferSize);
+};
+
+
+//===----------------------------------------------------------------------===//
+// Microsoft Windows data types
+//===----------------------------------------------------------------------===//
+DWORD MsDword = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD dwMsDword = 0;
+
+BYTE MsByte = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BYTE byMsByte = 0;
+
+WORD MsWord = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}WORD wMsWord = 0;
+
+BOOL MsBool = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BOOL bMsBool = 0;
+
+BOOLEAN MsBoolean = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BOOLEAN bMsBoolean = 0;
+
+CHAR MsValueChar = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}CHAR cMsValueChar = 0;
+
+UCHAR MsValueUchar = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UCHAR ucMsValueUchar = 0;
+
+SHORT MsValueShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}SHORT sMsValueShort = 0;
+
+USHORT MsValueUshort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}USHORT usMsValueUshort = 0;
+
+WORD MsValueWord = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}WORD wMsValueWord = 0;
+
+DWORD MsValueDword = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD dwMsValueDword = 0;
+
+DWORD32 MsValueDword32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD32 dw32MsValueDword32 = 0;
+
+DWORD64 MsValueDword64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD64 dw64MsValueDword64 = 0;
+
+LONG MsValueLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}LONG lMsValueLong = 0;
+
+ULONG MsValueUlong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG ulMsValueUlong = 0;
+
+ULONG32 MsValueUlong32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG32 ul32MsValueUlong32 = 0;
+
+ULONG64 MsValueUlong64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG64 ul64MsValueUlong64 = 0;
+
+ULONGLONG MsValueUlongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONGLONG ullMsValueUlongLong = 0;
+
+HANDLE MsValueHandle = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueHandle' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}HANDLE hMsValueHandle = 0;
+
+INT MsValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT iMsValueInt = 0;
+
+INT8 MsValueInt8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT8 i8MsValueInt8 = 0;
+
+INT16 MsValueInt16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT16 i16MsValueInt16 = 0;
+
+INT32 MsValueInt32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT32 i32MsValueInt32 = 0;
+
+INT64 MsValueINt64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT64 i64MsValueINt64 = 0;
+
+UINT MsValueUint = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT uiMsValueUint = 0;
+
+UINT8 MsValueUint8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT8 u8MsValueUint8 = 0;
+
+UINT16 MsValueUint16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT16 u16MsValueUint16 = 0;
+
+UINT32 MsValueUint32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT32 u32MsValueUint32 = 0;
+
+UINT64 MsValueUint64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT64 u64MsValueUint64 = 0;
+
+PVOID MsValuePvoid = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValuePvoid' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}PVOID pMsValuePvoid = NULL;
+
+
+//===----------------------------------------------------------------------===//
+// Array
+//===----------------------------------------------------------------------===//
+unsigned GlobalUnsignedArray[] = {1, 2, 3};
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned aGlobalUnsignedArray[] = {1, 2, 3};
+
+int GlobalIntArray[] = {1, 2, 3};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aGlobalIntArray[] = {1, 2, 3};
+
+int DataInt[1] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aDataInt[1] = {0};
+
+int DataArray[2] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aDataArray[2] = {0};
+
+
+//===----------------------------------------------------------------------===//
+// Pointer
+//===----------------------------------------------------------------------===//
+int *DataIntPtr[1] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int *paDataIntPtr[1] = {0};
+
+void *BufferPtr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'BufferPtr1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void *pBufferPtr1;
+
+void **BufferPtr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'BufferPtr2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **ppBufferPtr2;
+
+void **pBufferPtr3;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'pBufferPtr3' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **ppBufferPtr3;
+
+int *pBufferPtr4;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'pBufferPtr4' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int *piBufferPtr4;
+
+typedef void (*FUNC_PTR_HELLO)();
+FUNC_PTR_HELLO Hello = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'Hello' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}FUNC_PTR_HELLO fnHello = NULL;
+
+void *ValueVoidPtr = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueVoidPtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void *pValueVoidPtr = NULL;
+
+ptrdiff_t PtrDiff = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ptrdiff_t pPtrDiff = NULL;
+
+int8_t *ValueI8Ptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI8Ptr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int8_t *pi8ValueI8Ptr;
+
+uint8_t *ValueU8Ptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU8Ptr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint8_t *pu8ValueU8Ptr;
+
+void MyFunc2(void* Val){}
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void MyFunc2(void* pVal){}
+
+
+//===----------------------------------------------------------------------===//
+// Reference
+//===----------------------------------------------------------------------===//
+int iValueIndex = 1;
+int &RefValueIndex = iValueIndex;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int &iRefValueIndex = iValueIndex;
+
+const int &ConstRefValue = iValueIndex;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int &iConstRefValue = iValueIndex;
+
+long long llValueLongLong = 2;
+long long &RefValueLongLong = llValueLongLong;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long &llRefValueLongLong = llValueLongLong;
+
+
+//===----------------------------------------------------------------------===//
+// Various types
+//===----------------------------------------------------------------------===//
+int8_t ValueI8;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int8_t i8ValueI8;
+
+int16_t ValueI16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int16_t i16ValueI16 = 0;
+
+int32_t ValueI32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int32_t i32ValueI32 = 0;
+
+int64_t ValueI64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int64_t i64ValueI64 = 0;
+
+uint8_t ValueU8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint8_t u8ValueU8 = 0;
+
+uint16_t ValueU16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint16_t u16ValueU16 = 0;
+
+uint32_t ValueU32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint32_t u32ValueU32 = 0;
+
+uint64_t ValueU64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint64_t u64ValueU64 = 0;
+
+float ValueFloat = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}float fValueFloat = 0;
+
+double ValueDouble = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}double dValueDouble = 0;
+
+char ValueChar = 'c';
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}char cValueChar = 'c';
+
+bool ValueBool = true;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}bool bValueBool = true;
+
+int ValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iValueInt = 0;
+
+size_t ValueSize = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}size_t nValueSize = 0;
+
+wchar_t ValueWchar = 'w';
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}wchar_t wcValueWchar = 'w';
+
+short ValueShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}short sValueShort = 0;
+
+unsigned ValueUnsigned = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned uValueUnsigned = 0;
+
+signed ValueSigned = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed sValueSigned = 0;
+
+long ValueLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long lValueLong = 0;
+
+long long ValueLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long llValueLongLong = 0;
+
+long long int ValueLongLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long int lliValueLongLongInt = 0;
+
+long double ValueLongDouble = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long double ldValueLongDouble = 0;
+
+signed int ValueSignedInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed int siValueSignedInt = 0;
+
+signed short ValueSignedShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed short ssValueSignedShort = 0;
+
+signed short int ValueSignedShortInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed short int ssiValueSignedShortInt = 0;
+
+signed long long ValueSignedLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long long sllValueSignedLongLong = 0;
+
+signed long int ValueSignedLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long int sliValueSignedLongInt = 0;
+
+signed long ValueSignedLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long slValueSignedLong = 0;
+
+unsigned long long int ValueUnsignedLongLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long long int ulliValueUnsignedLongLongInt = 0;
+
+unsigned long long ValueUnsignedLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long long ullValueUnsignedLongLong = 0;
+
+unsigned long int ValueUnsignedLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long int uliValueUnsignedLongInt = 0;
+
+unsigned long ValueUnsignedLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long ulValueUnsignedLong = 0;
+
+unsigned short int ValueUnsignedShortInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned short int usiValueUnsignedShortInt = 0;
+
+unsigned short ValueUnsignedShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned short usValueUnsignedShort = 0;
+
+unsigned int ValueUnsignedInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned int uiValueUnsignedInt = 0;
+
+long int ValueLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long int liValueLongInt = 0;
+
+
+//===----------------------------------------------------------------------===//
+// Specifier, Qualifier, Other keywords
+//===----------------------------------------------------------------------===//
+volatile int VolatileInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}volatile int iVolatileInt = 0;
+
+thread_local int ThreadLocalValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ThreadLocalValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}thread_local int iThreadLocalValueInt = 0;
+
+extern int ExternValueInt;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}extern int iExternValueInt;
+
+struct DataBuffer {
+    mutable size_t Size;
+};
+// CHECK-MESSAGES: :[[@LINE-2]]:20: warning: invalid case style for member 'Size' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}    mutable size_t nSize;
+
+static constexpr int const &ConstExprInt = 42;
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: invalid case style for constexpr variable 'ConstExprInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static constexpr int const &iConstExprInt = 42;
+
+
+//===----------------------------------------------------------------------===//
+// Redefined types
+//===----------------------------------------------------------------------===//
+typedef int INDEX;
+INDEX iIndex = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'iIndex' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INDEX Index = 0;
+
+
+//===----------------------------------------------------------------------===//
+// Class
+//===----------------------------------------------------------------------===//
+class GenericClass { int Func(); };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'GenericClass' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class CGenericClass { int Func(); };
+
+class AbstractClass { virtual int Func() = 0; };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClass' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class IAbstractClass { virtual int Func() = 0; };
+
+class AbstractClass1 { virtual int Func1() = 0; int Func2(); };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClass1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class IAbstractClass1 { virtual int Func1() = 0; int Func2(); };
+
+
+//===----------------------------------------------------------------------===//
+// Other Cases
+//===----------------------------------------------------------------------===//
+int lower_case = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase = 0;
+
+int lower_case1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase1 = 0;
+
+int lower_case_2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase2 = 0;
+
+int UPPER_CASE = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iUpperCase = 0;
+
+int UPPER_CASE_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iUpperCase1 = 0;
+
+int camelBack = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack = 0;
+
+int camelBack_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack1 = 0;
+
+int camelBack2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack2 = 0;
+
+int CamelCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase = 0;
+
+int CamelCase_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase1 = 0;
+
+int CamelCase2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase2 = 0;
+
+int camel_Snake_Back = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeBack = 0;
+
+int camel_Snake_Back_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeBack1 = 0;
+
+int Camel_Snake_Case = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeCase = 0;
+
+int Camel_Snake_Case_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeCase1 = 0;
+
+//===----------------------------------------------------------------------===//
+// Enum
+//===----------------------------------------------------------------------===//
+enum REVINFO_TYPE { RevValid };
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for constant 'RevValid' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}enum REVINFO_TYPE { rtRevValid };
+
+enum DataType { OneByte, TwoByte };
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for constant 'OneByte' [readability-identifier-naming]
+// CHECK-MESSAGES: :[[@LINE-2]]:26: warning: invalid case style for constant 'TwoByte' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}enum DataType { dtOneByte, dtTwoByte };
+// clang-format on

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-hungarian-notation.cpp

+// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
+// RUN:   -config='{ CheckOptions: [ \
+// RUN:     { key: readability-identifier-naming.ClassCase                                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.AbstractClassCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ClassMemberCase                                         , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantCase                                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantMemberCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantParameterCase                                   , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstantPointerParameterCase                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ConstexprVariableCase                                   , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantPointerCase                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.GlobalVariableCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantPointerCase                                , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalPointerCase                                        , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.LocalVariableCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.MemberCase                                              , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ParameterCase                                           , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.PointerParameterCase                                    , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.PrivateMemberCase                                       , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StaticConstantCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StaticVariableCase                                      , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.StructCase                                              , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.UnionCase                                               , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.VariableCase                                            , value: CamelCase }, \
+// RUN:     { key: readability-identifier-naming.ClassHungarianPrefix                                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.AbstractClassHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ClassMemberHungarianPrefix                              , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantHungarianPrefix                                 , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantMemberHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantParameterHungarianPrefix                        , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstantPointerParameterHungarianPrefix                 , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ConstexprVariableHungarianPrefix                        , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalConstantPointerHungarianPrefix                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.GlobalVariableHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalConstantPointerHungarianPrefix                     , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalPointerHungarianPrefix                             , value: On        }, \
+// RUN:     { key: readability-identifier-naming.LocalVariableHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.MemberHungarianPrefix                                   , value: On        }, \
+// RUN:     { key: readability-identifier-naming.ParameterHungarianPrefix                                , value: On        }, \
+// RUN:     { key: readability-identifier-naming.PointerParameterHungarianPrefix                         , value: On        }, \
+// RUN:     { key: readability-identifier-naming.PrivateMemberHungarianPrefix                            , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StaticConstantHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StaticVariableHungarianPrefix                           , value: On        }, \
+// RUN:     { key: readability-identifier-naming.StructHungarianPrefix                                   , value: On        }, \
+// RUN:     { key: readability-identifier-naming.UnionHungarianPrefix                                    , value: On        }, \
+// RUN:     { key: readability-identifier-naming.VariableHungarianPrefix                                 , value: On        }, \
+// RUN:   ]}'
+
+// clang-format off
+typedef signed char         int8_t;     // NOLINT
+typedef short               int16_t;    // NOLINT
+typedef long                int32_t;    // NOLINT
+typedef long long           int64_t;    // NOLINT
+typedef unsigned char       uint8_t;    // NOLINT
+typedef unsigned short      uint16_t;   // NOLINT
+typedef unsigned long       uint32_t;   // NOLINT
+typedef unsigned long long  uint64_t;   // NOLINT
+#ifndef _WIN32
+typedef unsigned long long  size_t;     // NOLINT
+#endif
+typedef long                intptr_t;   // NOLINT
+typedef unsigned long       uintptr_t;  // NOLINT
+typedef long int            ptrdiff_t;  // NOLINT
+typedef unsigned char       BYTE;       // NOLINT
+typedef unsigned short      WORD;       // NOLINT
+typedef unsigned long       DWORD;      // NOLINT
+typedef int                 BOOL;       // NOLINT
+typedef int                 BOOLEAN;    // NOLINT
+typedef float               FLOAT;      // NOLINT
+typedef int                 INT;        // NOLINT
+typedef unsigned int        UINT;       // NOLINT
+typedef unsigned long       ULONG;      // NOLINT
+typedef short               SHORT;      // NOLINT
+typedef unsigned short      USHORT;     // NOLINT
+typedef char                CHAR;       // NOLINT
+typedef unsigned char       UCHAR;      // NOLINT
+typedef signed char         INT8;       // NOLINT
+typedef signed short        INT16;      // NOLINT
+typedef signed int          INT32;      // NOLINT
+typedef signed long long    INT64;      // NOLINT
+typedef unsigned char       UINT8;      // NOLINT
+typedef unsigned short      UINT16;     // NOLINT
+typedef unsigned int        UINT32;     // NOLINT
+typedef unsigned long long  UINT64;     // NOLINT
+typedef long                LONG;       // NOLINT
+typedef signed int          LONG32;     // NOLINT
+typedef unsigned int        ULONG32;    // NOLINT
+typedef uint64_t            ULONG64;    // NOLINT
+typedef unsigned int        DWORD32;    // NOLINT
+typedef uint64_t            DWORD64;    // NOLINT
+typedef uint64_t            ULONGLONG;  // NOLINT
+typedef void*               PVOID;      // NOLINT
+typedef void*               HANDLE;     // NOLINT
+typedef void*               FILE;       // NOLINT
+#define NULL                (0)         // NOLINT
+// clang-format on
+
+// clang-format off
+//===----------------------------------------------------------------------===//
+// Cases to CheckOptions
+//===----------------------------------------------------------------------===//
+class CMyClass1 {
+public:
+  static int ClassMemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  static int iClassMemberCase;
+
+  char const ConstantMemberCase = 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char const cConstantMemberCase = 0;
+
+  void MyFunc1(const int ConstantParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for constant parameter 'ConstantParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void MyFunc1(const int iConstantParameterCase);
+
+  void MyFunc2(const int* ConstantPointerParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: invalid case style for pointer parameter 'ConstantPointerParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void MyFunc2(const int* piConstantPointerParameterCase);
+
+  static constexpr int ConstexprVariableCase = 123;
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constexpr variable 'ConstexprVariableCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  static constexpr int iConstexprVariableCase = 123;
+};
+
+const int GlobalConstantCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int iGlobalConstantCase = 0;
+
+const int* GlobalConstantPointerCase = nullptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'GlobalConstantPointerCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int* piGlobalConstantPointerCase = nullptr;
+
+int GlobalVariableCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iGlobalVariableCase = 0;
+
+void Func1(){
+  int const LocalConstantCase = 3;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int const iLocalConstantCase = 3;
+
+  int* const LocalConstantPointerCase = nullptr;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int* const piLocalConstantPointerCase = nullptr;
+
+  int *LocalPointerCase = nullptr;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int *piLocalPointerCase = nullptr;
+
+  int LocalVariableCase = 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  int iLocalVariableCase = 0;
+}
+
+class CMyClass2 {
+  char MemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char cMemberCase;
+
+  void Func1(int ParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func1(int iParameterCase);
+
+  void Func2(const int ParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constant parameter 'ParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func2(const int iParameterCase);
+
+  void Func3(const int *PointerParameterCase);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for pointer parameter 'PointerParameterCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  void Func3(const int *piPointerParameterCase);
+};
+
+class CMyClass3 {
+private:
+  char PrivateMemberCase;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char cPrivateMemberCase;
+};
+
+static const int StaticConstantCase = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static const int iStaticConstantCase = 3;
+
+static int StaticVariableCase = 3;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static int iStaticVariableCase = 3;
+
+struct MyStruct { int StructCase; };
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for member 'StructCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}struct MyStruct { int iStructCase; };
+
+union MyUnion { int UnionCase1; long lUnionCase2; };
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for member 'UnionCase1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}union MyUnion { int iUnionCase1; long lUnionCase2; };
+
+//===----------------------------------------------------------------------===//
+// C string
+//===----------------------------------------------------------------------===//
+const char *NamePtr = "Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char *szNamePtr = "Name";
+
+const char NameArray[] = "Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char szNameArray[] = "Name";
+
+const char *NamePtrArray[] = {"AA", "BB"};
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const char *pszNamePtrArray[] = {"AA", "BB"};
+
+const wchar_t *WideNamePtr = L"Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t *wszWideNamePtr = L"Name";
+
+const wchar_t WideNameArray[] = L"Name";
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t wszWideNameArray[] = L"Name";
+
+const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"};
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"};
+
+class CMyClass4 {
+private:
+  char *Name = "Text";
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'Name' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  char *szName = "Text";
+
+  const char *ConstName = "Text";
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for private member 'ConstName' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  const char *szConstName = "Text";
+
+public:
+  const char* DuplicateString(const char* Input, size_t nRequiredSize);
+  // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  const char* DuplicateString(const char* szInput, size_t nRequiredSize);
+
+  size_t UpdateText(const char* Buffer, size_t nBufferSize);
+  // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming]
+  // CHECK-FIXES: {{^}}  size_t UpdateText(const char* szBuffer, size_t nBufferSize);
+};
+
+
+//===----------------------------------------------------------------------===//
+// Microsoft Windows data types
+//===----------------------------------------------------------------------===//
+DWORD MsDword = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD dwMsDword = 0;
+
+BYTE MsByte = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BYTE byMsByte = 0;
+
+WORD MsWord = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}WORD wMsWord = 0;
+
+BOOL MsBool = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BOOL bMsBool = 0;
+
+BOOLEAN MsBoolean = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}BOOLEAN bMsBoolean = 0;
+
+CHAR MsValueChar = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}CHAR cMsValueChar = 0;
+
+UCHAR MsValueUchar = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UCHAR ucMsValueUchar = 0;
+
+SHORT MsValueShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}SHORT sMsValueShort = 0;
+
+USHORT MsValueUshort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}USHORT usMsValueUshort = 0;
+
+WORD MsValueWord = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}WORD wMsValueWord = 0;
+
+DWORD MsValueDword = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD dwMsValueDword = 0;
+
+DWORD32 MsValueDword32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD32 dw32MsValueDword32 = 0;
+
+DWORD64 MsValueDword64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}DWORD64 dw64MsValueDword64 = 0;
+
+LONG MsValueLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}LONG lMsValueLong = 0;
+
+ULONG MsValueUlong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG ulMsValueUlong = 0;
+
+ULONG32 MsValueUlong32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG32 ul32MsValueUlong32 = 0;
+
+ULONG64 MsValueUlong64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONG64 ul64MsValueUlong64 = 0;
+
+ULONGLONG MsValueUlongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ULONGLONG ullMsValueUlongLong = 0;
+
+HANDLE MsValueHandle = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueHandle' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}HANDLE hMsValueHandle = 0;
+
+INT MsValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT iMsValueInt = 0;
+
+INT8 MsValueInt8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT8 i8MsValueInt8 = 0;
+
+INT16 MsValueInt16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT16 i16MsValueInt16 = 0;
+
+INT32 MsValueInt32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT32 i32MsValueInt32 = 0;
+
+INT64 MsValueINt64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INT64 i64MsValueINt64 = 0;
+
+UINT MsValueUint = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT uiMsValueUint = 0;
+
+UINT8 MsValueUint8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT8 u8MsValueUint8 = 0;
+
+UINT16 MsValueUint16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT16 u16MsValueUint16 = 0;
+
+UINT32 MsValueUint32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT32 u32MsValueUint32 = 0;
+
+UINT64 MsValueUint64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}UINT64 u64MsValueUint64 = 0;
+
+PVOID MsValuePvoid = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValuePvoid' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}PVOID pMsValuePvoid = NULL;
+
+
+//===----------------------------------------------------------------------===//
+// Array
+//===----------------------------------------------------------------------===//
+unsigned GlobalUnsignedArray[] = {1, 2, 3};
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned aGlobalUnsignedArray[] = {1, 2, 3};
+
+int GlobalIntArray[] = {1, 2, 3};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aGlobalIntArray[] = {1, 2, 3};
+
+int DataInt[1] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aDataInt[1] = {0};
+
+int DataArray[2] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int aDataArray[2] = {0};
+
+
+//===----------------------------------------------------------------------===//
+// Pointer
+//===----------------------------------------------------------------------===//
+int *DataIntPtr[1] = {0};
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int *paDataIntPtr[1] = {0};
+
+void *BufferPtr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'BufferPtr1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void *pBufferPtr1;
+
+void **BufferPtr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'BufferPtr2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **ppBufferPtr2;
+
+void **pBufferPtr3;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'pBufferPtr3' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **ppBufferPtr3;
+
+int *pBufferPtr4;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'pBufferPtr4' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int *piBufferPtr4;
+
+typedef void (*FUNC_PTR_HELLO)();
+FUNC_PTR_HELLO Hello = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'Hello' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}FUNC_PTR_HELLO fnHello = NULL;
+
+void *ValueVoidPtr = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueVoidPtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void *pValueVoidPtr = NULL;
+
+ptrdiff_t PtrDiff = NULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}ptrdiff_t pPtrDiff = NULL;
+
+int8_t *ValueI8Ptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI8Ptr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int8_t *pi8ValueI8Ptr;
+
+uint8_t *ValueU8Ptr;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU8Ptr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint8_t *pu8ValueU8Ptr;
+
+void MyFunc2(void* Val){}
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void MyFunc2(void* pVal){}
+
+
+//===----------------------------------------------------------------------===//
+// Reference
+//===----------------------------------------------------------------------===//
+int iValueIndex = 1;
+int &RefValueIndex = iValueIndex;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int &iRefValueIndex = iValueIndex;
+
+const int &ConstRefValue = iValueIndex;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}const int &iConstRefValue = iValueIndex;
+
+long long llValueLongLong = 2;
+long long &RefValueLongLong = llValueLongLong;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long &llRefValueLongLong = llValueLongLong;
+
+
+//===----------------------------------------------------------------------===//
+// Various types
+//===----------------------------------------------------------------------===//
+int8_t ValueI8;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int8_t i8ValueI8;
+
+int16_t ValueI16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int16_t i16ValueI16 = 0;
+
+int32_t ValueI32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int32_t i32ValueI32 = 0;
+
+int64_t ValueI64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int64_t i64ValueI64 = 0;
+
+uint8_t ValueU8 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint8_t u8ValueU8 = 0;
+
+uint16_t ValueU16 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint16_t u16ValueU16 = 0;
+
+uint32_t ValueU32 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint32_t u32ValueU32 = 0;
+
+uint64_t ValueU64 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}uint64_t u64ValueU64 = 0;
+
+float ValueFloat = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}float fValueFloat = 0;
+
+double ValueDouble = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}double dValueDouble = 0;
+
+char ValueChar = 'c';
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}char cValueChar = 'c';
+
+bool ValueBool = true;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}bool bValueBool = true;
+
+int ValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iValueInt = 0;
+
+size_t ValueSize = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}size_t nValueSize = 0;
+
+wchar_t ValueWchar = 'w';
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}wchar_t wcValueWchar = 'w';
+
+short ValueShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}short sValueShort = 0;
+
+unsigned ValueUnsigned = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned uValueUnsigned = 0;
+
+signed ValueSigned = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed sValueSigned = 0;
+
+long ValueLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long lValueLong = 0;
+
+long long ValueLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long llValueLongLong = 0;
+
+long long int ValueLongLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long long int lliValueLongLongInt = 0;
+
+long double ValueLongDouble = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long double ldValueLongDouble = 0;
+
+signed int ValueSignedInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed int siValueSignedInt = 0;
+
+signed short ValueSignedShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed short ssValueSignedShort = 0;
+
+signed short int ValueSignedShortInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed short int ssiValueSignedShortInt = 0;
+
+signed long long ValueSignedLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long long sllValueSignedLongLong = 0;
+
+signed long int ValueSignedLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long int sliValueSignedLongInt = 0;
+
+signed long ValueSignedLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}signed long slValueSignedLong = 0;
+
+unsigned long long int ValueUnsignedLongLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long long int ulliValueUnsignedLongLongInt = 0;
+
+unsigned long long ValueUnsignedLongLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long long ullValueUnsignedLongLong = 0;
+
+unsigned long int ValueUnsignedLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long int uliValueUnsignedLongInt = 0;
+
+unsigned long ValueUnsignedLong = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned long ulValueUnsignedLong = 0;
+
+unsigned short int ValueUnsignedShortInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned short int usiValueUnsignedShortInt = 0;
+
+unsigned short ValueUnsignedShort = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned short usValueUnsignedShort = 0;
+
+unsigned int ValueUnsignedInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}unsigned int uiValueUnsignedInt = 0;
+
+long int ValueLongInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}long int liValueLongInt = 0;
+
+
+//===----------------------------------------------------------------------===//
+// Specifier, Qualifier, Other keywords
+//===----------------------------------------------------------------------===//
+volatile int VolatileInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}volatile int iVolatileInt = 0;
+
+thread_local int ThreadLocalValueInt = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ThreadLocalValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}thread_local int iThreadLocalValueInt = 0;
+
+extern int ExternValueInt;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}extern int iExternValueInt;
+
+struct DataBuffer {
+    mutable size_t Size;
+};
+// CHECK-MESSAGES: :[[@LINE-2]]:20: warning: invalid case style for member 'Size' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}    mutable size_t nSize;
+
+static constexpr int const &ConstExprInt = 42;
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: invalid case style for constexpr variable 'ConstExprInt' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}static constexpr int const &iConstExprInt = 42;
+
+
+//===----------------------------------------------------------------------===//
+// Redefined types
+//===----------------------------------------------------------------------===//
+typedef int INDEX;
+INDEX iIndex = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'iIndex' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}INDEX Index = 0;
+
+
+//===----------------------------------------------------------------------===//
+// Class
+//===----------------------------------------------------------------------===//
+class GenericClass { int Func(); };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'GenericClass' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class CGenericClass { int Func(); };
+
+class AbstractClass { virtual int Func() = 0; };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClass' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class IAbstractClass { virtual int Func() = 0; };
+
+class AbstractClass1 { virtual int Func1() = 0; int Func2(); };
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClass1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}class IAbstractClass1 { virtual int Func1() = 0; int Func2(); };
+
+
+//===----------------------------------------------------------------------===//
+// Other Cases
+//===----------------------------------------------------------------------===//
+int lower_case = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase = 0;
+
+int lower_case1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase1 = 0;
+
+int lower_case_2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iLowerCase2 = 0;
+
+int UPPER_CASE = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iUpperCase = 0;
+
+int UPPER_CASE_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iUpperCase1 = 0;
+
+int camelBack = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack = 0;
+
+int camelBack_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack1 = 0;
+
+int camelBack2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelBack2 = 0;
+
+int CamelCase = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase = 0;
+
+int CamelCase_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase1 = 0;
+
+int CamelCase2 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelCase2 = 0;
+
+int camel_Snake_Back = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeBack = 0;
+
+int camel_Snake_Back_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeBack1 = 0;
+
+int Camel_Snake_Case = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeCase = 0;
+
+int Camel_Snake_Case_1 = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int iCamelSnakeCase1 = 0;
+
+//===----------------------------------------------------------------------===//
+// Enum
+//===----------------------------------------------------------------------===//
+enum REVINFO_TYPE { RevValid };
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for constant 'RevValid' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}enum REVINFO_TYPE { rtRevValid };
+
+enum DataType { OneByte, TwoByte };
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for constant 'OneByte' [readability-identifier-naming]
+// CHECK-MESSAGES: :[[@LINE-2]]:26: warning: invalid case style for constant 'TwoByte' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}enum DataType { dtOneByte, dtTwoByte };
+// clang-format on