[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

229

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

514

OK~ Thank you. I will check them.

590

OK.

607–633

OK.

616

Nice, thank you.

623–630

OK.

634–638

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();
  // ...
}

675

OK.

676

OK, thank you.

745

OK.

747–748

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

[njames93]

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

[njames93]

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

229

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.

434–449

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

229

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

434–449

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

123

Is this line needed?

233

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

358

360

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

361–362

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

416

776

[dougpuob]

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

123

I will remove it. Thank you.

233

Thank you. I will change it.

360

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?

361–362

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

229–413

Formatting

237

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

254

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?

376–380

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

421–422

566–567

577–578

642

653–655

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

669

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

756

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)) {
  ...
}

761

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

801–802

825

989–1007

1299–1300

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

1344

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

132

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 ↗

(On Diff #306411)

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 ↗

(On Diff #306411)

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 ↗

(On Diff #306411)

2315 ↗

(On Diff #306411)

2318 ↗

(On Diff #306411)

2321–2322 ↗

(On Diff #306411)

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

229–413

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

254

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"}};

376–380

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

594–597

649–650

718

Similar to what was suggested above.

776

This comment doesn't appear to have been handled.

[Eugene.Zelenko]

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

592

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

235–239

244–248

256–260

308–312

347–348

366

373

386

392–401

407–409

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

131–132

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

398–404

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

398–404

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.

421–448

[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

425

[dougpuob]

Hi @njames93,

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

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

425

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

338

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,
struct HungarianNotationOption {
     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, HungarianPrefixType HPType)
         : Case(Case), Prefix(Prefix), Suffix(Suffix), HPType(HPType) {}
 
     llvm::Optional<CaseType> Case;
     std::string Prefix;
     std::string Suffix;
 
     HungarianPrefixType HPType;
   };
 
   struct FileStyle {
     FileStyle() : IsActive(false), IgnoreMainLikeFunctions(false) {}
     FileStyle(SmallVectorImpl<Optional<NamingStyle>> &&Styles,
-              bool IgnoreMainLike)
-        : Styles(std::move(Styles)), IsActive(true),
-          IgnoreMainLikeFunctions(IgnoreMainLike) {}
+              HungarianNotationOption HNOption, bool IgnoreMainLike)
+        : Styles(std::move(Styles)), HNOption(std::move(HNOption)),
+          IsActive(true), IgnoreMainLikeFunctions(IgnoreMainLike) {}
 
     ArrayRef<Optional<NamingStyle>> getStyles() const {
       assert(IsActive);
       return Styles;
     }
+
+    const HungarianNotationOption &getHNOption() const {
+      assert(IsActive);
+      return HNOption;
+    }
+
     bool isActive() const { return IsActive; }
     bool isIgnoringMainLikeFunction() const { return IgnoreMainLikeFunctions; }
 
   private:
     SmallVector<Optional<NamingStyle>, 0> Styles;
+    HungarianNotationOption HNOption;
     bool IsActive;
     bool IgnoreMainLikeFunctions;
   };
 
 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;
 
   const FileStyle &getStyleForFile(StringRef FileName) const;
 
   /// Stores the style options as a vector, indexed by the specified \ref
   /// StyleKind, for a given directory.
   mutable llvm::StringMap<FileStyle> NamingStylesCache;
   FileStyle *MainFileStyle;
   ClangTidyContext *const Context;
   const std::string CheckName;
   const bool GetConfigPerFile;
   const bool IgnoreFailedSplit;
-
-  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

#define NAMING_KEYS(m) \
     m(Typedef) \
     m(TypeTemplateParameter) \
     m(ValueTemplateParameter) \
     m(TemplateTemplateParameter) \
     m(TemplateParameter) \
     m(TypeAlias) \
     m(MacroDefinition) \
     m(ObjcIvar) \
 
 enum StyleKind {
 #define ENUMERATE(v) SK_ ## v,
   NAMING_KEYS(ENUMERATE)
 #undef ENUMERATE
   SK_Count,
   SK_Invalid
 };
 
#define HUNGARIAN_NOTATION_PRIMITIVE_TYPES(m) \
      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<StringRef, StringRef> Options[] = {
+  static constexpr std::pair<StringRef, StringRef> General[] = {
       {"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()});
-  }
+  for (const auto &G : General)
+    HNOption.General.try_emplace(G.first, G.second);
 
   // Derived types
   static constexpr std::pair<StringRef, 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()});
-  }
+  for (const auto &DT : DerivedTypes)
+    HNOption.DerivedType.try_emplace(DT.first, DT.second);
 
   // C strings
   static constexpr std::pair<StringRef, 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()});
-  }
+  for (const auto &CStr : CStrings)
+    HNOption.CString.try_emplace(CStr.first, CStr.second);
 
   // clang-format off
   static constexpr std::pair<StringRef, 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()});
-  }
+  for (const auto &PT : PrimitiveTypes)
+    HNOption.PrimitiveType.try_emplace(PT.first, PT.second);
 
   // clang-format off
   static constexpr std::pair<StringRef, 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()});
-  }
+  for (const auto &UDT : UserDefinedTypes)
+    HNOption.UserDefinedType.try_emplace(UDT.first, UDT.second);
 }
 
 static constexpr StringRef HNOpts[] = {"TreatStructAsClass"};
 static constexpr StringRef HNDerivedTypes[] = {"Array", "Pointer",
                                                "FunctionPointer"};
 static void getHungarianNotationFileConfig(
     const ClangTidyCheck::OptionsView &Options,
     IdentifierNamingCheck::HungarianNotationOption &HNOption) {
   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;
+      HNOption.General[Opt] = std::move(Val);
   }
 
   for (const auto &Type : HNDerivedTypes) {
     Buffer.assign({Section, "DerivedType.", Type});
     std::string Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.DerivedType[Type] = Val;
+      HNOption.DerivedType[Type] = std::move(Val);
   }
 
   static constexpr std::pair<StringRef, 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;
+      HNOption.CString[CStr.first] = std::move(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;
+      std::string Type = PrimType.str();
+      std::replace(Type.begin(), Type.end(), '-', ' ');
+      HNOption.PrimitiveType[Type] = std::move(Val);
     }
   }
 
-  for (const auto &WDType : HungarainNotationUserDefinedTypes) {
-    Buffer.assign({Section, "UserDefinedType.", WDType});
+  for (const auto &Type : HungarainNotationUserDefinedTypes) {
+    Buffer.assign({Section, "UserDefinedType.", Type});
     std::string Val = Options.get(Buffer, "");
-    std::string Type = WDType.str();
     if (!Val.empty())
-      HNOption.UserDefinedType[Type] = Val;
+      HNOption.UserDefinedType[Type] = std::move(Val);
   }
 }
 
 static bool
 isHungarianNotationOptionEnabled(StringRef OptionKey,
                                  const llvm::StringMap<std::string> &StrMap) {
   if (OptionKey.empty())
     return false;
 
   std::string OptionVal = StrMap.lookup(OptionKey);
   llvm::transform(OptionVal, OptionVal.begin(), toupper);
 
   if (OptionVal == "1" || OptionVal == "TRUE" || OptionVal == "ON")
     return true;
 
   return false;
 }
 
-static IdentifierNamingCheck::FileStyle getFileStyleFromOptions(
-    const ClangTidyCheck::OptionsView &Options,
-    IdentifierNamingCheck::HungarianNotationOption &HNOption) {
+static IdentifierNamingCheck::FileStyle
+getFileStyleFromOptions(const ClangTidyCheck::OptionsView &Options) {
+
+  IdentifierNamingCheck::HungarianNotationOption HNOption;
   getHungarianNotationDefaultConfig(HNOption);
   getHungarianNotationFileConfig(Options, HNOption);
 
   SmallVector<llvm::Optional<IdentifierNamingCheck::NamingStyle>, 0> 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();
     using HungarianPrefixType = IdentifierNamingCheck::HungarianPrefixType;
     auto HPTVal = HungarianPrefixType::HPT_Off;
     std::string HPrefixVal = Options.get(HPrefixKey, "");
     if (!HPrefixVal.empty()) {
       if (auto HPTypeVal = Options.get<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() ||
         !HPrefixVal.empty())
       Styles[I].emplace(std::move(CaseOptional), std::move(Prefix),
                         std::move(Postfix), HPTVal);
   }
   bool IgnoreMainLike = Options.get("IgnoreMainLikeFunctions", false);
-  return {std::move(Styles), IgnoreMainLike};
+  return {std::move(Styles), std::move(HNOption), IgnoreMainLike};
 }
 
 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : RenamerClangTidyCheck(Name, Context), Context(Context), CheckName(Name),
       GetConfigPerFile(Options.get("GetConfigPerFile", true)),
       IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)) {
-
   auto IterAndInserted = NamingStylesCache.try_emplace(
       llvm::sys::path::parent_path(Context->getCurrentFile()),
-      getFileStyleFromOptions(Options, HNOption));
+      getFileStyleFromOptions(Options));
   assert(IterAndInserted.second && "Couldn't insert Style");
   // Holding a reference to the data in the vector is safe as it should never
   // move.
   MainFileStyle = &IterAndInserted.first->getValue();
 }
 
 IdentifierNamingCheck::~IdentifierNamingCheck() = default;
 
 void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   RenamerClangTidyCheck::storeOptions(Opts);
   SmallString<64> StyleString;
   ArrayRef<llvm::Optional<NamingStyle>> Styles = MainFileStyle->getStyles();
   for (size_t I = 0; I < SK_Count; ++I) {
     if (!Styles[I])
       continue;
     StyleString = StyleNames[I];
     size_t StyleSize = StyleString.size();
 
     Options.store(Opts, (StyleString + "HungarianPrefix").str(),
                   Styles[I]->HPType);
 
     StyleString.append("Prefix");
     Options.store(Opts, StyleString, Styles[I]->Prefix);
     // Fast replacement of [Pre]fix -> [Suf]fix.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     Options.store(Opts, StyleString, Styles[I]->Suffix);
     if (Styles[I]->Case) {
       memcpy(&StyleString[StyleSize], "Case", 4);
       StyleString.pop_back();
       StyleString.pop_back();
       Options.store(Opts, StyleString, *Styles[I]->Case);
     }
   }
   Options.store(Opts, "GetConfigPerFile", GetConfigPerFile);
   Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
static const std::string getHungarianNotationDataTypePrefix(
   // 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()) {
ModifiedTypeName = [&](std::string Str, StringRef From, StringRef To) {
         StartPos += To.size();
       }
       return Str;
     }(ModifiedTypeName, "*", "");
   }
 
   // Primitive types
   if (PrefixStr.empty()) {
     for (const auto &Type : HNOption.PrimitiveType) {
       if (ModifiedTypeName == Type.getKey()) {
         PrefixStr = Type.getValue();
         break;
       }
     }
   }
 
   // User-Defined types
   if (PrefixStr.empty()) {
     for (const auto &Type : HNOption.UserDefinedType) {
       if (ModifiedTypeName == Type.getKey()) {
         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]|$)");
 
   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 (StringRef 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 (isa<FunctionDecl, EnumConstantDecl>(ND))
     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.
   const char *EOL = strchr(Begin, '\n');
   if (!EOL)
     EOL = 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, Pos);
   }
 
   StrLen = EOL - Begin;
   std::string TypeName;
   if (StrLen > 0) {
     std::string Type(Begin, StrLen);
 
     static constexpr StringRef Keywords[] = {
         // Constexpr specifiers
         "constexpr", "constinit", "consteval",
         // Qualifier
         "const", "volatile", "restrict", "mutable",
         // Storage class specifiers
         "register", "static", "extern", "thread_local",
if (StrLen > 0) {
     for (size_t Pos = 0; (Pos = Type.find(" *", Pos)) != std::string::npos;
          Pos += strlen("*")) {
       Type.replace(Pos, strlen(" *"), "* ");
     }
 
     // Remove redundant tailing.
     static constexpr StringRef TailsOfMultiWordType[] = {
         " int", " char", " double", " long", " short"};
     bool RedundantRemoved = false;
     for (auto Kw : TailsOfMultiWordType) {
       size_t Pos = Type.rfind(Kw.data());
       if (Pos != std::string::npos) {
         Type = Type.substr(0, Pos + Kw.size());
         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(" "));
 
     QualType QT = VD->getType();
     if (!QT.isNull() && QT->isArrayType())
       TypeName.append("[]");
   }
 
   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;
   if (const auto *ECD = dyn_cast<EnumConstantDecl>(ND)) {
     Prefix = getHungarianNotationEnumPrefix(ECD);
   } else if (const auto *CRD = dyn_cast<CXXRecordDecl>(ND)) {
     Prefix = getHungarianNotationClassPrefix(CRD, HNOption);
   } else if (isa<VarDecl, FieldDecl, RecordDecl>(ND)) {
     std::string TypeName = getDeclTypeName(ND);
     if (!TypeName.empty())
       Prefix = getHungarianNotationDataTypePrefix(TypeName, ND, HNOption);
   }
 
   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 (const auto &Map : MapList) {
     for (const auto &Str : Map) {
       if (Str.getValue() == CorrectName) {
         Words.erase(Words.begin(), Words.begin() + 1);
         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 Type, StringRef Name, const Decl *D,
               const IdentifierNamingCheck::NamingStyle &Style,
               const IdentifierNamingCheck::HungarianNotationOption &HNOption,
               IdentifierNamingCheck::CaseType Case) {
   static llvm::Regex Splitter(
       "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
 
   SmallVector<StringRef, 8> Substrs;
   Name.split(Substrs, "_", -1, false);
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 Type, 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;
   using HungarianPrefixType = IdentifierNamingCheck::HungarianPrefixType;
   if (HungarianPrefixType::HPT_Off != Style.HPType) {
     HungarianPrefix = getHungarianNotationPrefix(D, HNOption);
     if (!HungarianPrefix.empty()) {
       if (Style.HPType == HungarianPrefixType::HPT_LowerCase)
         HungarianPrefix += "_";
 
       if (Style.HPType == HungarianPrefixType::HPT_CamelCase)
         Fixed[0] = toupper(Fixed[0]);
     }
   }
   StringRef Mid = StringRef(Fixed).trim("_");
   if (Mid.empty())
     Mid = "_";
 
   return (Style.Prefix + HungarianPrefix + Mid + Style.Suffix).str();
 }
 
 static StyleKind findStyleKind(
if (isa<TemplateTemplateParmDecl>(D)) {
 
     return SK_Invalid;
   }
 
   return SK_Invalid;
 }
 
 static llvm::Optional<RenamerClangTidyCheck::FailureInfo> getFailureInfo(
     StringRef Type, 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(Type, Name, Style, HNOption, ND))

 IdentifierNamingCheck::GetDeclFailureInfo(const NamedDecl *Decl,
                                           const SourceManager &SM) const {
   SourceLocation Loc = Decl->getLocation();
   const FileStyle &FileStyle = getStyleForFile(SM.getFilename(Loc));
   if (!FileStyle.isActive())
     return llvm::None;
 
   return getFailureInfo(getDeclTypeName(Decl), Decl->getName(), Decl, Loc,
-                        FileStyle.getStyles(), HNOption,
+                        FileStyle.getStyles(), FileStyle.getHNOption(),
                         findStyleKind(Decl, FileStyle.getStyles(),
                                       FileStyle.isIgnoringMainLikeFunction()),
                         SM, IgnoreFailedSplit);
 }
 
 llvm::Optional<RenamerClangTidyCheck::FailureInfo>
 IdentifierNamingCheck::GetMacroFailureInfo(const Token &MacroNameTok,
                                            const SourceManager &SM) const {
   SourceLocation Loc = MacroNameTok.getLocation();
   const FileStyle &Style = getStyleForFile(SM.getFilename(Loc));
   if (!Style.isActive())
     return llvm::None;
 
   return getFailureInfo("", MacroNameTok.getIdentifierInfo()->getName(), NULL,
-                        Loc, Style.getStyles(), HNOption, SK_MacroDefinition,
-                        SM, IgnoreFailedSplit);
+                        Loc, Style.getStyles(), Style.getHNOption(),
+                        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;
                   }};
 }
 
 const IdentifierNamingCheck::FileStyle &
 IdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
   if (!GetConfigPerFile)
     return *MainFileStyle;
   StringRef Parent = llvm::sys::path::parent_path(FileName);
   auto Iter = NamingStylesCache.find(Parent);
   if (Iter != NamingStylesCache.end())
     return Iter->getValue();
 
   ClangTidyOptions Options = Context->getOptionsForFile(FileName);
   if (Options.Checks && GlobList(*Options.Checks).contains(CheckName)) {
-    HungarianNotationOption HNOption;
     auto It = NamingStylesCache.try_emplace(
-        Parent,
-        getFileStyleFromOptions({CheckName, Options.CheckOptions}, HNOption));
+        Parent, getFileStyleFromOptions({CheckName, Options.CheckOptions}));
     assert(It.second);
     return It.first->getValue();
   }
   // Default construction gives an empty style.
   auto It = NamingStylesCache.try_emplace(Parent);
   assert(It.second);
   return It.first->getValue();
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang