xref: /llvm-project/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp (revision c79e5acfe8d4bb01d5ae7297dcb900ad8c39c580) 
1 //===--- IdentifierNamingCheck.cpp - clang-tidy ---------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "IdentifierNamingCheck.h"
10 
11 #include "../GlobList.h"
12 #include "../utils/ASTUtils.h"
13 #include "clang/AST/CXXInheritance.h"
14 #include "clang/Lex/PPCallbacks.h"
15 #include "clang/Lex/Preprocessor.h"
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMapInfo.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Support/Debug.h"
20 #include "llvm/Support/Error.h"
21 #include "llvm/Support/FormatVariadic.h"
22 #include "llvm/Support/Path.h"
23 #include "llvm/Support/Regex.h"
24 #include "llvm/Support/YAMLParser.h"
25 #include <optional>
26 
27 #define DEBUG_TYPE "clang-tidy"
28 
29 // FixItHint
30 
31 using namespace clang::ast_matchers;
32 
33 namespace clang::tidy {
34 
35 llvm::ArrayRef<
36     std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>>
37 OptionEnumMapping<
38     readability::IdentifierNamingCheck::CaseType>::getEnumMapping() {
39   static constexpr std::pair<readability::IdentifierNamingCheck::CaseType,
40                              StringRef>
41       Mapping[] = {
42           {readability::IdentifierNamingCheck::CT_AnyCase, "aNy_CasE"},
43           {readability::IdentifierNamingCheck::CT_LowerCase, "lower_case"},
44           {readability::IdentifierNamingCheck::CT_UpperCase, "UPPER_CASE"},
45           {readability::IdentifierNamingCheck::CT_CamelBack, "camelBack"},
46           {readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"},
47           {readability::IdentifierNamingCheck::CT_CamelSnakeCase,
48            "Camel_Snake_Case"},
49           {readability::IdentifierNamingCheck::CT_CamelSnakeBack,
50            "camel_Snake_Back"},
51           {readability::IdentifierNamingCheck::CT_LeadingUpperSnakeCase,
52            "Leading_upper_snake_case"}};
53   return {Mapping};
54 }
55 
56 template <>
57 struct OptionEnumMapping<
58     readability::IdentifierNamingCheck::HungarianPrefixType> {
59   using HungarianPrefixType =
60       readability::IdentifierNamingCheck::HungarianPrefixType;
61   static llvm::ArrayRef<std::pair<HungarianPrefixType, StringRef>>
62   getEnumMapping() {
63     static constexpr std::pair<HungarianPrefixType, StringRef> Mapping[] = {
64         {HungarianPrefixType::HPT_Off, "Off"},
65         {HungarianPrefixType::HPT_On, "On"},
66         {HungarianPrefixType::HPT_LowerCase, "LowerCase"},
67         {HungarianPrefixType::HPT_CamelCase, "CamelCase"}};
68     return {Mapping};
69   }
70 };
71 
72 namespace readability {
73 
74 // clang-format off
75 #define NAMING_KEYS(m) \
76     m(Namespace) \
77     m(InlineNamespace) \
78     m(EnumConstant) \
79     m(ScopedEnumConstant) \
80     m(ConstexprVariable) \
81     m(ConstantMember) \
82     m(PrivateMember) \
83     m(ProtectedMember) \
84     m(PublicMember) \
85     m(Member) \
86     m(ClassConstant) \
87     m(ClassMember) \
88     m(GlobalConstant) \
89     m(GlobalConstantPointer) \
90     m(GlobalPointer) \
91     m(GlobalVariable) \
92     m(LocalConstant) \
93     m(LocalConstantPointer) \
94     m(LocalPointer) \
95     m(LocalVariable) \
96     m(StaticConstant) \
97     m(StaticVariable) \
98     m(Constant) \
99     m(Variable) \
100     m(ConstantParameter) \
101     m(ParameterPack) \
102     m(Parameter) \
103     m(PointerParameter) \
104     m(ConstantPointerParameter) \
105     m(AbstractClass) \
106     m(Struct) \
107     m(Class) \
108     m(Union) \
109     m(Enum) \
110     m(GlobalFunction) \
111     m(ConstexprFunction) \
112     m(Function) \
113     m(ConstexprMethod) \
114     m(VirtualMethod) \
115     m(ClassMethod) \
116     m(PrivateMethod) \
117     m(ProtectedMethod) \
118     m(PublicMethod) \
119     m(Method) \
120     m(Typedef) \
121     m(TypeTemplateParameter) \
122     m(ValueTemplateParameter) \
123     m(TemplateTemplateParameter) \
124     m(TemplateParameter) \
125     m(TypeAlias) \
126     m(MacroDefinition) \
127     m(ObjcIvar) \
128     m(Concept) \
129 
130 enum StyleKind : int {
131 #define ENUMERATE(v) SK_ ## v,
132   NAMING_KEYS(ENUMERATE)
133 #undef ENUMERATE
134   SK_Count,
135   SK_Invalid
136 };
137 
138 static StringRef const StyleNames[] = {
139 #define STRINGIZE(v) #v,
140   NAMING_KEYS(STRINGIZE)
141 #undef STRINGIZE
142 };
143 
144 #define HUNGARIAN_NOTATION_PRIMITIVE_TYPES(m) \
145      m(int8_t) \
146      m(int16_t) \
147      m(int32_t) \
148      m(int64_t) \
149      m(uint8_t) \
150      m(uint16_t) \
151      m(uint32_t) \
152      m(uint64_t) \
153      m(char8_t) \
154      m(char16_t) \
155      m(char32_t) \
156      m(float) \
157      m(double) \
158      m(char) \
159      m(bool) \
160      m(_Bool) \
161      m(int) \
162      m(size_t) \
163      m(wchar_t) \
164      m(short-int) \
165      m(short) \
166      m(signed-int) \
167      m(signed-short) \
168      m(signed-short-int) \
169      m(signed-long-long-int) \
170      m(signed-long-long) \
171      m(signed-long-int) \
172      m(signed-long) \
173      m(signed) \
174      m(unsigned-long-long-int) \
175      m(unsigned-long-long) \
176      m(unsigned-long-int) \
177      m(unsigned-long) \
178      m(unsigned-short-int) \
179      m(unsigned-short) \
180      m(unsigned-int) \
181      m(unsigned-char) \
182      m(unsigned) \
183      m(long-long-int) \
184      m(long-double) \
185      m(long-long) \
186      m(long-int) \
187      m(long) \
188      m(ptrdiff_t) \
189      m(void) \
190 
191 static StringRef const HungarainNotationPrimitiveTypes[] = {
192 #define STRINGIZE(v) #v,
193   HUNGARIAN_NOTATION_PRIMITIVE_TYPES(STRINGIZE)
194 #undef STRINGIZE
195 };
196 
197 #define HUNGARIAN_NOTATION_USER_DEFINED_TYPES(m) \
198      m(BOOL) \
199      m(BOOLEAN) \
200      m(BYTE) \
201      m(CHAR) \
202      m(UCHAR) \
203      m(SHORT) \
204      m(USHORT) \
205      m(WORD) \
206      m(DWORD) \
207      m(DWORD32) \
208      m(DWORD64) \
209      m(LONG) \
210      m(ULONG) \
211      m(ULONG32) \
212      m(ULONG64) \
213      m(ULONGLONG) \
214      m(HANDLE) \
215      m(INT) \
216      m(INT8) \
217      m(INT16) \
218      m(INT32) \
219      m(INT64) \
220      m(UINT) \
221      m(UINT8) \
222      m(UINT16) \
223      m(UINT32) \
224      m(UINT64) \
225      m(PVOID) \
226 
227 static StringRef const HungarainNotationUserDefinedTypes[] = {
228 #define STRINGIZE(v) #v,
229   HUNGARIAN_NOTATION_USER_DEFINED_TYPES(STRINGIZE)
230 #undef STRINGIZE
231 };
232 
233 
234 #undef NAMING_KEYS
235 // clang-format on
236 
237 IdentifierNamingCheck::NamingStyle::NamingStyle(
238     std::optional<IdentifierNamingCheck::CaseType> Case, StringRef Prefix,
239     StringRef Suffix, StringRef IgnoredRegexpStr, HungarianPrefixType HPType)
240     : Case(Case), Prefix(Prefix), Suffix(Suffix),
241       IgnoredRegexpStr(IgnoredRegexpStr), HPType(HPType) {
242   if (!IgnoredRegexpStr.empty()) {
243     IgnoredRegexp =
244         llvm::Regex(llvm::SmallString<128>({"^", IgnoredRegexpStr, "$"}));
245     if (!IgnoredRegexp.isValid())
246       llvm::errs() << "Invalid IgnoredRegexp regular expression: "
247                    << IgnoredRegexpStr;
248   }
249 }
250 
251 IdentifierNamingCheck::FileStyle IdentifierNamingCheck::getFileStyleFromOptions(
252     const ClangTidyCheck::OptionsView &Options) const {
253   IdentifierNamingCheck::HungarianNotationOption HNOption;
254 
255   HungarianNotation.loadDefaultConfig(HNOption);
256   HungarianNotation.loadFileConfig(Options, HNOption);
257 
258   SmallVector<std::optional<IdentifierNamingCheck::NamingStyle>, 0> Styles;
259   Styles.resize(SK_Count);
260   SmallString<64> StyleString;
261   for (unsigned I = 0; I < SK_Count; ++I) {
262     size_t StyleSize = StyleNames[I].size();
263     StyleString.assign({StyleNames[I], "HungarianPrefix"});
264 
265     auto HPTOpt =
266         Options.get<IdentifierNamingCheck::HungarianPrefixType>(StyleString);
267     if (HPTOpt && !HungarianNotation.checkOptionValid(I))
268       configurationDiag("invalid identifier naming option '%0'") << StyleString;
269 
270     memcpy(&StyleString[StyleSize], "IgnoredRegexp", 13);
271     StyleString.truncate(StyleSize + 13);
272     std::optional<StringRef> IgnoredRegexpStr = Options.get(StyleString);
273     memcpy(&StyleString[StyleSize], "Prefix", 6);
274     StyleString.truncate(StyleSize + 6);
275     std::optional<StringRef> Prefix(Options.get(StyleString));
276     // Fast replacement of [Pre]fix -> [Suf]fix.
277     memcpy(&StyleString[StyleSize], "Suf", 3);
278     std::optional<StringRef> Postfix(Options.get(StyleString));
279     memcpy(&StyleString[StyleSize], "Case", 4);
280     StyleString.pop_back_n(2);
281     std::optional<CaseType> CaseOptional =
282         Options.get<IdentifierNamingCheck::CaseType>(StyleString);
283 
284     if (CaseOptional || Prefix || Postfix || IgnoredRegexpStr || HPTOpt)
285       Styles[I].emplace(std::move(CaseOptional), Prefix.value_or(""),
286                         Postfix.value_or(""), IgnoredRegexpStr.value_or(""),
287                         HPTOpt.value_or(IdentifierNamingCheck::HPT_Off));
288   }
289   bool IgnoreMainLike = Options.get("IgnoreMainLikeFunctions", false);
290   bool CheckAnonFieldInParent = Options.get("CheckAnonFieldInParent", false);
291   return {std::move(Styles), std::move(HNOption), IgnoreMainLike,
292           CheckAnonFieldInParent};
293 }
294 
295 std::string IdentifierNamingCheck::HungarianNotation::getDeclTypeName(
296     const NamedDecl *ND) const {
297   const auto *VD = dyn_cast<ValueDecl>(ND);
298   if (!VD)
299     return {};
300 
301   if (isa<FunctionDecl, EnumConstantDecl>(ND))
302     return {};
303 
304   // Get type text of variable declarations.
305   auto &SM = VD->getASTContext().getSourceManager();
306   const char *Begin = SM.getCharacterData(VD->getBeginLoc());
307   const char *End = SM.getCharacterData(VD->getEndLoc());
308   intptr_t StrLen = End - Begin;
309 
310   // FIXME: Sometimes the value that returns from ValDecl->getEndLoc()
311   // is wrong(out of location of Decl). This causes `StrLen` will be assigned
312   // an unexpected large value. Current workaround to find the terminated
313   // character instead of the `getEndLoc()` function.
314   const char *EOL = strchr(Begin, '\n');
315   if (!EOL)
316     EOL = Begin + strlen(Begin);
317 
318   const char *PosList[] = {strchr(Begin, '='), strchr(Begin, ';'),
319                            strchr(Begin, ','), strchr(Begin, ')'), EOL};
320   for (const auto &Pos : PosList) {
321     if (Pos > Begin)
322       EOL = std::min(EOL, Pos);
323   }
324 
325   StrLen = EOL - Begin;
326   std::string TypeName;
327   if (StrLen > 0) {
328     std::string Type(Begin, StrLen);
329 
330     static constexpr StringRef Keywords[] = {
331         // Constexpr specifiers
332         "constexpr", "constinit", "consteval",
333         // Qualifier
334         "const", "volatile", "restrict", "mutable",
335         // Storage class specifiers
336         "register", "static", "extern", "thread_local",
337         // Other keywords
338         "virtual"};
339 
340     // Remove keywords
341     for (StringRef Kw : Keywords) {
342       for (size_t Pos = 0;
343            (Pos = Type.find(Kw.data(), Pos)) != std::string::npos;) {
344         Type.replace(Pos, Kw.size(), "");
345       }
346     }
347     TypeName = Type.erase(0, Type.find_first_not_of(' '));
348 
349     // Remove template parameters
350     const size_t Pos = Type.find('<');
351     if (Pos != std::string::npos) {
352       TypeName = Type.erase(Pos, Type.size() - Pos);
353     }
354 
355     // Replace spaces with single space.
356     for (size_t Pos = 0; (Pos = Type.find("  ", Pos)) != std::string::npos;
357          Pos += strlen(" ")) {
358       Type.replace(Pos, strlen("  "), " ");
359     }
360 
361     // Replace " &" with "&".
362     for (size_t Pos = 0; (Pos = Type.find(" &", Pos)) != std::string::npos;
363          Pos += strlen("&")) {
364       Type.replace(Pos, strlen(" &"), "&");
365     }
366 
367     // Replace " *" with "* ".
368     for (size_t Pos = 0; (Pos = Type.find(" *", Pos)) != std::string::npos;
369          Pos += strlen("*")) {
370       Type.replace(Pos, strlen(" *"), "* ");
371     }
372 
373     // Remove redundant tailing.
374     static constexpr StringRef TailsOfMultiWordType[] = {
375         " int", " char", " double", " long", " short"};
376     bool RedundantRemoved = false;
377     for (auto Kw : TailsOfMultiWordType) {
378       size_t Pos = Type.rfind(Kw.data());
379       if (Pos != std::string::npos) {
380         const size_t PtrCount = getAsteriskCount(Type, ND);
381         Type = Type.substr(0, Pos + Kw.size() + PtrCount);
382         RedundantRemoved = true;
383         break;
384       }
385     }
386 
387     TypeName = Type.erase(0, Type.find_first_not_of(' '));
388     if (!RedundantRemoved) {
389       std::size_t FoundSpace = Type.find(' ');
390       if (FoundSpace != std::string::npos)
391         Type = Type.substr(0, FoundSpace);
392     }
393 
394     TypeName = Type.erase(0, Type.find_first_not_of(' '));
395 
396     QualType QT = VD->getType();
397     if (!QT.isNull() && QT->isArrayType())
398       TypeName.append("[]");
399   }
400 
401   return TypeName;
402 }
403 
404 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
405                                              ClangTidyContext *Context)
406     : RenamerClangTidyCheck(Name, Context), Context(Context),
407       GetConfigPerFile(Options.get("GetConfigPerFile", true)),
408       IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)) {
409 
410   auto IterAndInserted = NamingStylesCache.try_emplace(
411       llvm::sys::path::parent_path(Context->getCurrentFile()),
412       getFileStyleFromOptions(Options));
413   assert(IterAndInserted.second && "Couldn't insert Style");
414   // Holding a reference to the data in the vector is safe as it should never
415   // move.
416   MainFileStyle = &IterAndInserted.first->getValue();
417 }
418 
419 IdentifierNamingCheck::~IdentifierNamingCheck() = default;
420 
421 bool IdentifierNamingCheck::HungarianNotation::checkOptionValid(
422     int StyleKindIndex) const {
423   if ((StyleKindIndex >= SK_EnumConstant) &&
424       (StyleKindIndex <= SK_ConstantParameter))
425     return true;
426 
427   if ((StyleKindIndex >= SK_Parameter) && (StyleKindIndex <= SK_Enum))
428     return true;
429 
430   return false;
431 }
432 
433 bool IdentifierNamingCheck::HungarianNotation::isOptionEnabled(
434     StringRef OptionKey, const llvm::StringMap<std::string> &StrMap) const {
435   if (OptionKey.empty())
436     return false;
437 
438   auto Iter = StrMap.find(OptionKey);
439   if (Iter == StrMap.end())
440     return false;
441 
442   return *llvm::yaml::parseBool(Iter->getValue());
443 }
444 
445 void IdentifierNamingCheck::HungarianNotation::loadFileConfig(
446     const ClangTidyCheck::OptionsView &Options,
447     IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
448 
449   static constexpr StringRef HNOpts[] = {"TreatStructAsClass"};
450   static constexpr StringRef HNDerivedTypes[] = {"Array", "Pointer",
451                                                  "FunctionPointer"};
452 
453   StringRef Section = "HungarianNotation.";
454 
455   SmallString<128> Buffer = {Section, "General."};
456   size_t DefSize = Buffer.size();
457   for (const auto &Opt : HNOpts) {
458     Buffer.truncate(DefSize);
459     Buffer.append(Opt);
460     StringRef Val = Options.get(Buffer, "");
461     if (!Val.empty())
462       HNOption.General[Opt] = Val.str();
463   }
464 
465   Buffer = {Section, "DerivedType."};
466   DefSize = Buffer.size();
467   for (const auto &Type : HNDerivedTypes) {
468     Buffer.truncate(DefSize);
469     Buffer.append(Type);
470     StringRef Val = Options.get(Buffer, "");
471     if (!Val.empty())
472       HNOption.DerivedType[Type] = Val.str();
473   }
474 
475   static constexpr std::pair<StringRef, StringRef> HNCStrings[] = {
476       {"CharPointer", "char*"},
477       {"CharArray", "char[]"},
478       {"WideCharPointer", "wchar_t*"},
479       {"WideCharArray", "wchar_t[]"}};
480 
481   Buffer = {Section, "CString."};
482   DefSize = Buffer.size();
483   for (const auto &CStr : HNCStrings) {
484     Buffer.truncate(DefSize);
485     Buffer.append(CStr.first);
486     StringRef Val = Options.get(Buffer, "");
487     if (!Val.empty())
488       HNOption.CString[CStr.second] = Val.str();
489   }
490 
491   Buffer = {Section, "PrimitiveType."};
492   DefSize = Buffer.size();
493   for (const auto &PrimType : HungarainNotationPrimitiveTypes) {
494     Buffer.truncate(DefSize);
495     Buffer.append(PrimType);
496     StringRef Val = Options.get(Buffer, "");
497     if (!Val.empty()) {
498       std::string Type = PrimType.str();
499       std::replace(Type.begin(), Type.end(), '-', ' ');
500       HNOption.PrimitiveType[Type] = Val.str();
501     }
502   }
503 
504   Buffer = {Section, "UserDefinedType."};
505   DefSize = Buffer.size();
506   for (const auto &Type : HungarainNotationUserDefinedTypes) {
507     Buffer.truncate(DefSize);
508     Buffer.append(Type);
509     StringRef Val = Options.get(Buffer, "");
510     if (!Val.empty())
511       HNOption.UserDefinedType[Type] = Val.str();
512   }
513 }
514 
515 std::string IdentifierNamingCheck::HungarianNotation::getPrefix(
516     const Decl *D,
517     const IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
518   if (!D)
519     return {};
520   const auto *ND = dyn_cast<NamedDecl>(D);
521   if (!ND)
522     return {};
523 
524   std::string Prefix;
525   if (const auto *ECD = dyn_cast<EnumConstantDecl>(ND)) {
526     Prefix = getEnumPrefix(ECD);
527   } else if (const auto *CRD = dyn_cast<CXXRecordDecl>(ND)) {
528     Prefix = getClassPrefix(CRD, HNOption);
529   } else if (isa<VarDecl, FieldDecl, RecordDecl>(ND)) {
530     std::string TypeName = getDeclTypeName(ND);
531     if (!TypeName.empty())
532       Prefix = getDataTypePrefix(TypeName, ND, HNOption);
533   }
534 
535   return Prefix;
536 }
537 
538 bool IdentifierNamingCheck::HungarianNotation::removeDuplicatedPrefix(
539     SmallVector<StringRef, 8> &Words,
540     const IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
541   if (Words.size() <= 1)
542     return true;
543 
544   std::string CorrectName = Words[0].str();
545   std::vector<llvm::StringMap<std::string>> MapList = {
546       HNOption.CString, HNOption.DerivedType, HNOption.PrimitiveType,
547       HNOption.UserDefinedType};
548 
549   for (const auto &Map : MapList) {
550     for (const auto &Str : Map) {
551       if (Str.getValue() == CorrectName) {
552         Words.erase(Words.begin(), Words.begin() + 1);
553         return true;
554       }
555     }
556   }
557 
558   return false;
559 }
560 
561 std::string IdentifierNamingCheck::HungarianNotation::getDataTypePrefix(
562     StringRef TypeName, const NamedDecl *ND,
563     const IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
564   if (!ND || TypeName.empty())
565     return TypeName.str();
566 
567   std::string ModifiedTypeName(TypeName);
568 
569   // Derived types
570   std::string PrefixStr;
571   if (const auto *TD = dyn_cast<ValueDecl>(ND)) {
572     QualType QT = TD->getType();
573     if (QT->isFunctionPointerType()) {
574       PrefixStr = HNOption.DerivedType.lookup("FunctionPointer");
575     } else if (QT->isPointerType()) {
576       for (const auto &CStr : HNOption.CString) {
577         std::string Key = CStr.getKey().str();
578         if (ModifiedTypeName.find(Key) == 0) {
579           PrefixStr = CStr.getValue();
580           ModifiedTypeName = ModifiedTypeName.substr(
581               Key.size(), ModifiedTypeName.size() - Key.size());
582           break;
583         }
584       }
585     } else if (QT->isArrayType()) {
586       for (const auto &CStr : HNOption.CString) {
587         std::string Key = CStr.getKey().str();
588         if (ModifiedTypeName.find(Key) == 0) {
589           PrefixStr = CStr.getValue();
590           break;
591         }
592       }
593       if (PrefixStr.empty())
594         PrefixStr = HNOption.DerivedType.lookup("Array");
595     } else if (QT->isReferenceType()) {
596       size_t Pos = ModifiedTypeName.find_last_of('&');
597       if (Pos != std::string::npos)
598         ModifiedTypeName = ModifiedTypeName.substr(0, Pos);
599     }
600   }
601 
602   // Pointers
603   size_t PtrCount = getAsteriskCount(ModifiedTypeName);
604   if (PtrCount > 0) {
605     ModifiedTypeName = [&](std::string Str, StringRef From, StringRef To) {
606       size_t StartPos = 0;
607       while ((StartPos = Str.find(From.data(), StartPos)) !=
608              std::string::npos) {
609         Str.replace(StartPos, From.size(), To.data());
610         StartPos += To.size();
611       }
612       return Str;
613     }(ModifiedTypeName, "*", "");
614   }
615 
616   // Primitive types
617   if (PrefixStr.empty()) {
618     for (const auto &Type : HNOption.PrimitiveType) {
619       if (ModifiedTypeName == Type.getKey()) {
620         PrefixStr = Type.getValue();
621         break;
622       }
623     }
624   }
625 
626   // User-Defined types
627   if (PrefixStr.empty()) {
628     for (const auto &Type : HNOption.UserDefinedType) {
629       if (ModifiedTypeName == Type.getKey()) {
630         PrefixStr = Type.getValue();
631         break;
632       }
633     }
634   }
635 
636   for (size_t Idx = 0; Idx < PtrCount; Idx++)
637     PrefixStr.insert(0, HNOption.DerivedType.lookup("Pointer"));
638 
639   return PrefixStr;
640 }
641 
642 std::string IdentifierNamingCheck::HungarianNotation::getClassPrefix(
643     const CXXRecordDecl *CRD,
644     const IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
645 
646   if (CRD->isUnion())
647     return {};
648 
649   if (CRD->isStruct() &&
650       !isOptionEnabled("TreatStructAsClass", HNOption.General))
651     return {};
652 
653   return CRD->isAbstract() ? "I" : "C";
654 }
655 
656 std::string IdentifierNamingCheck::HungarianNotation::getEnumPrefix(
657     const EnumConstantDecl *ECD) const {
658   const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
659 
660   std::string Name = ED->getName().str();
661   if (StringRef(Name).contains("enum")) {
662     Name = Name.substr(strlen("enum"), Name.length() - strlen("enum"));
663     Name = Name.erase(0, Name.find_first_not_of(' '));
664   }
665 
666   static llvm::Regex Splitter(
667       "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
668 
669   StringRef EnumName(Name);
670   SmallVector<StringRef, 8> Substrs;
671   EnumName.split(Substrs, "_", -1, false);
672 
673   SmallVector<StringRef, 8> Words;
674   SmallVector<StringRef, 8> Groups;
675   for (auto Substr : Substrs) {
676     while (!Substr.empty()) {
677       Groups.clear();
678       if (!Splitter.match(Substr, &Groups))
679         break;
680 
681       if (!Groups[2].empty()) {
682         Words.push_back(Groups[1]);
683         Substr = Substr.substr(Groups[0].size());
684       } else if (!Groups[3].empty()) {
685         Words.push_back(Groups[3]);
686         Substr = Substr.substr(Groups[0].size() - Groups[4].size());
687       } else if (!Groups[5].empty()) {
688         Words.push_back(Groups[5]);
689         Substr = Substr.substr(Groups[0].size() - Groups[6].size());
690       }
691     }
692   }
693 
694   std::string Initial;
695   for (StringRef Word : Words)
696     Initial += tolower(Word[0]);
697 
698   return Initial;
699 }
700 
701 size_t IdentifierNamingCheck::HungarianNotation::getAsteriskCount(
702     const std::string &TypeName) const {
703   size_t Pos = TypeName.find('*');
704   size_t Count = 0;
705   for (; Pos < TypeName.length(); Pos++, Count++) {
706     if ('*' != TypeName[Pos])
707       break;
708   }
709   return Count;
710 }
711 
712 size_t IdentifierNamingCheck::HungarianNotation::getAsteriskCount(
713     const std::string &TypeName, const NamedDecl *ND) const {
714   size_t PtrCount = 0;
715   if (const auto *TD = dyn_cast<ValueDecl>(ND)) {
716     QualType QT = TD->getType();
717     if (QT->isPointerType())
718       PtrCount = getAsteriskCount(TypeName);
719   }
720   return PtrCount;
721 }
722 
723 void IdentifierNamingCheck::HungarianNotation::loadDefaultConfig(
724     IdentifierNamingCheck::HungarianNotationOption &HNOption) const {
725 
726   // Options
727   static constexpr std::pair<StringRef, StringRef> General[] = {
728       {"TreatStructAsClass", "false"}};
729   for (const auto &G : General)
730     HNOption.General.try_emplace(G.first, G.second);
731 
732   // Derived types
733   static constexpr std::pair<StringRef, StringRef> DerivedTypes[] = {
734       {"Array", "a"}, {"Pointer", "p"}, {"FunctionPointer", "fn"}};
735   for (const auto &DT : DerivedTypes)
736     HNOption.DerivedType.try_emplace(DT.first, DT.second);
737 
738   // C strings
739   static constexpr std::pair<StringRef, StringRef> CStrings[] = {
740       {"char*", "sz"},
741       {"char[]", "sz"},
742       {"wchar_t*", "wsz"},
743       {"wchar_t[]", "wsz"}};
744   for (const auto &CStr : CStrings)
745     HNOption.CString.try_emplace(CStr.first, CStr.second);
746 
747   // clang-format off
748   static constexpr std::pair<StringRef, StringRef> PrimitiveTypes[] = {
749         {"int8_t",                  "i8"  },
750         {"int16_t",                 "i16" },
751         {"int32_t",                 "i32" },
752         {"int64_t",                 "i64" },
753         {"uint8_t",                 "u8"  },
754         {"uint16_t",                "u16" },
755         {"uint32_t",                "u32" },
756         {"uint64_t",                "u64" },
757         {"char8_t",                 "c8"  },
758         {"char16_t",                "c16" },
759         {"char32_t",                "c32" },
760         {"float",                   "f"   },
761         {"double",                  "d"   },
762         {"char",                    "c"   },
763         {"bool",                    "b"   },
764         {"_Bool",                   "b"   },
765         {"int",                     "i"   },
766         {"size_t",                  "n"   },
767         {"wchar_t",                 "wc"  },
768         {"short int",               "si"  },
769         {"short",                   "s"   },
770         {"signed int",              "si"  },
771         {"signed short",            "ss"  },
772         {"signed short int",        "ssi" },
773         {"signed long long int",    "slli"},
774         {"signed long long",        "sll" },
775         {"signed long int",         "sli" },
776         {"signed long",             "sl"  },
777         {"signed",                  "s"   },
778         {"unsigned long long int",  "ulli"},
779         {"unsigned long long",      "ull" },
780         {"unsigned long int",       "uli" },
781         {"unsigned long",           "ul"  },
782         {"unsigned short int",      "usi" },
783         {"unsigned short",          "us"  },
784         {"unsigned int",            "ui"  },
785         {"unsigned char",           "uc"  },
786         {"unsigned",                "u"   },
787         {"long long int",           "lli" },
788         {"long double",             "ld"  },
789         {"long long",               "ll"  },
790         {"long int",                "li"  },
791         {"long",                    "l"   },
792         {"ptrdiff_t",               "p"   },
793         {"void",                    ""    }};
794   // clang-format on
795   for (const auto &PT : PrimitiveTypes)
796     HNOption.PrimitiveType.try_emplace(PT.first, PT.second);
797 
798   // clang-format off
799   static constexpr std::pair<StringRef, StringRef> UserDefinedTypes[] = {
800       // Windows data types
801       {"BOOL",                    "b"   },
802       {"BOOLEAN",                 "b"   },
803       {"BYTE",                    "by"  },
804       {"CHAR",                    "c"   },
805       {"UCHAR",                   "uc"  },
806       {"SHORT",                   "s"   },
807       {"USHORT",                  "us"  },
808       {"WORD",                    "w"   },
809       {"DWORD",                   "dw"  },
810       {"DWORD32",                 "dw32"},
811       {"DWORD64",                 "dw64"},
812       {"LONG",                    "l"   },
813       {"ULONG",                   "ul"  },
814       {"ULONG32",                 "ul32"},
815       {"ULONG64",                 "ul64"},
816       {"ULONGLONG",               "ull" },
817       {"HANDLE",                  "h"   },
818       {"INT",                     "i"   },
819       {"INT8",                    "i8"  },
820       {"INT16",                   "i16" },
821       {"INT32",                   "i32" },
822       {"INT64",                   "i64" },
823       {"UINT",                    "ui"  },
824       {"UINT8",                   "u8"  },
825       {"UINT16",                  "u16" },
826       {"UINT32",                  "u32" },
827       {"UINT64",                  "u64" },
828       {"PVOID",                   "p"   } };
829   // clang-format on
830   for (const auto &UDT : UserDefinedTypes)
831     HNOption.UserDefinedType.try_emplace(UDT.first, UDT.second);
832 }
833 
834 void IdentifierNamingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
835   RenamerClangTidyCheck::storeOptions(Opts);
836   SmallString<64> StyleString;
837   ArrayRef<std::optional<NamingStyle>> Styles = MainFileStyle->getStyles();
838   for (size_t I = 0; I < SK_Count; ++I) {
839     if (!Styles[I])
840       continue;
841     size_t StyleSize = StyleNames[I].size();
842     StyleString.assign({StyleNames[I], "HungarianPrefix"});
843 
844     Options.store(Opts, StyleString, Styles[I]->HPType);
845 
846     memcpy(&StyleString[StyleSize], "IgnoredRegexp", 13);
847     StyleString.truncate(StyleSize + 13);
848     Options.store(Opts, StyleString, Styles[I]->IgnoredRegexpStr);
849     memcpy(&StyleString[StyleSize], "Prefix", 6);
850     StyleString.truncate(StyleSize + 6);
851     Options.store(Opts, StyleString, Styles[I]->Prefix);
852     // Fast replacement of [Pre]fix -> [Suf]fix.
853     memcpy(&StyleString[StyleSize], "Suf", 3);
854     Options.store(Opts, StyleString, Styles[I]->Suffix);
855     if (Styles[I]->Case) {
856       memcpy(&StyleString[StyleSize], "Case", 4);
857       StyleString.pop_back_n(2);
858       Options.store(Opts, StyleString, *Styles[I]->Case);
859     }
860   }
861   Options.store(Opts, "GetConfigPerFile", GetConfigPerFile);
862   Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
863   Options.store(Opts, "IgnoreMainLikeFunctions",
864                 MainFileStyle->isIgnoringMainLikeFunction());
865   Options.store(Opts, "CheckAnonFieldInParent",
866                 MainFileStyle->isCheckingAnonFieldInParentScope());
867 }
868 
869 bool IdentifierNamingCheck::matchesStyle(
870     StringRef Type, StringRef Name,
871     const IdentifierNamingCheck::NamingStyle &Style,
872     const IdentifierNamingCheck::HungarianNotationOption &HNOption,
873     const NamedDecl *Decl) const {
874   static llvm::Regex Matchers[] = {
875       llvm::Regex("^.*$"),
876       llvm::Regex("^[a-z][a-z0-9_]*$"),
877       llvm::Regex("^[a-z][a-zA-Z0-9]*$"),
878       llvm::Regex("^[A-Z][A-Z0-9_]*$"),
879       llvm::Regex("^[A-Z][a-zA-Z0-9]*$"),
880       llvm::Regex("^[A-Z]+([a-z0-9]*_[A-Z0-9]+)*[a-z0-9]*$"),
881       llvm::Regex("^[a-z]+([a-z0-9]*_[A-Z0-9]+)*[a-z0-9]*$"),
882       llvm::Regex("^[A-Z]([a-z0-9_]*[a-z])*$"),
883   };
884 
885   if (!Name.consume_front(Style.Prefix))
886     return false;
887   if (!Name.consume_back(Style.Suffix))
888     return false;
889   if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType) {
890     std::string HNPrefix = HungarianNotation.getPrefix(Decl, HNOption);
891     if (!HNPrefix.empty()) {
892       if (!Name.consume_front(HNPrefix))
893         return false;
894       if (Style.HPType ==
895               IdentifierNamingCheck::HungarianPrefixType::HPT_LowerCase &&
896           !Name.consume_front("_"))
897         return false;
898     }
899   }
900 
901   // Ensure the name doesn't have any extra underscores beyond those specified
902   // in the prefix and suffix.
903   if (Name.starts_with("_") || Name.ends_with("_"))
904     return false;
905 
906   if (Style.Case && !Matchers[static_cast<size_t>(*Style.Case)].match(Name))
907     return false;
908 
909   return true;
910 }
911 
912 std::string IdentifierNamingCheck::fixupWithCase(
913     StringRef Type, StringRef Name, const Decl *D,
914     const IdentifierNamingCheck::NamingStyle &Style,
915     const IdentifierNamingCheck::HungarianNotationOption &HNOption,
916     IdentifierNamingCheck::CaseType Case) const {
917   static llvm::Regex Splitter(
918       "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
919 
920   SmallVector<StringRef, 8> Substrs;
921   Name.split(Substrs, "_", -1, false);
922 
923   SmallVector<StringRef, 8> Words;
924   SmallVector<StringRef, 8> Groups;
925   for (auto Substr : Substrs) {
926     while (!Substr.empty()) {
927       Groups.clear();
928       if (!Splitter.match(Substr, &Groups))
929         break;
930 
931       if (!Groups[2].empty()) {
932         Words.push_back(Groups[1]);
933         Substr = Substr.substr(Groups[0].size());
934       } else if (!Groups[3].empty()) {
935         Words.push_back(Groups[3]);
936         Substr = Substr.substr(Groups[0].size() - Groups[4].size());
937       } else if (!Groups[5].empty()) {
938         Words.push_back(Groups[5]);
939         Substr = Substr.substr(Groups[0].size() - Groups[6].size());
940       }
941     }
942   }
943 
944   if (Words.empty())
945     return Name.str();
946 
947   if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType) {
948     HungarianNotation.removeDuplicatedPrefix(Words, HNOption);
949   }
950 
951   SmallString<128> Fixup;
952   switch (Case) {
953   case IdentifierNamingCheck::CT_AnyCase:
954     return Name.str();
955     break;
956 
957   case IdentifierNamingCheck::CT_LowerCase:
958     for (auto const &Word : Words) {
959       if (&Word != &Words.front())
960         Fixup += "_";
961       Fixup += Word.lower();
962     }
963     break;
964 
965   case IdentifierNamingCheck::CT_UpperCase:
966     for (auto const &Word : Words) {
967       if (&Word != &Words.front())
968         Fixup += "_";
969       Fixup += Word.upper();
970     }
971     break;
972 
973   case IdentifierNamingCheck::CT_CamelCase:
974     for (auto const &Word : Words) {
975       Fixup += toupper(Word.front());
976       Fixup += Word.substr(1).lower();
977     }
978     break;
979 
980   case IdentifierNamingCheck::CT_CamelBack:
981     for (auto const &Word : Words) {
982       if (&Word == &Words.front()) {
983         Fixup += Word.lower();
984       } else {
985         Fixup += toupper(Word.front());
986         Fixup += Word.substr(1).lower();
987       }
988     }
989     break;
990 
991   case IdentifierNamingCheck::CT_CamelSnakeCase:
992     for (auto const &Word : Words) {
993       if (&Word != &Words.front())
994         Fixup += "_";
995       Fixup += toupper(Word.front());
996       Fixup += Word.substr(1).lower();
997     }
998     break;
999 
1000   case IdentifierNamingCheck::CT_CamelSnakeBack:
1001     for (auto const &Word : Words) {
1002       if (&Word != &Words.front()) {
1003         Fixup += "_";
1004         Fixup += toupper(Word.front());
1005       } else {
1006         Fixup += tolower(Word.front());
1007       }
1008       Fixup += Word.substr(1).lower();
1009     }
1010     break;
1011 
1012   case IdentifierNamingCheck::CT_LeadingUpperSnakeCase:
1013     for (auto const &Word : Words) {
1014       if (&Word != &Words.front()) {
1015         Fixup += "_";
1016         Fixup += Word.lower();
1017       } else {
1018         Fixup += toupper(Word.front());
1019         Fixup += Word.substr(1).lower();
1020       }
1021     }
1022     break;
1023   }
1024 
1025   return Fixup.str().str();
1026 }
1027 
1028 bool IdentifierNamingCheck::isParamInMainLikeFunction(
1029     const ParmVarDecl &ParmDecl, bool IncludeMainLike) const {
1030   const auto *FDecl =
1031       dyn_cast_or_null<FunctionDecl>(ParmDecl.getParentFunctionOrMethod());
1032   if (!FDecl)
1033     return false;
1034   if (FDecl->isMain())
1035     return true;
1036   if (!IncludeMainLike)
1037     return false;
1038   if (FDecl->getAccess() != AS_public && FDecl->getAccess() != AS_none)
1039     return false;
1040   // If the function doesn't have a name that's an identifier, can occur if the
1041   // function is an operator overload, bail out early.
1042   if (!FDecl->getDeclName().isIdentifier())
1043     return false;
1044   enum MainType { None, Main, WMain };
1045   auto IsCharPtrPtr = [](QualType QType) -> MainType {
1046     if (QType.isNull())
1047       return None;
1048     if (QType = QType->getPointeeType(), QType.isNull())
1049       return None;
1050     if (QType = QType->getPointeeType(), QType.isNull())
1051       return None;
1052     if (QType->isCharType())
1053       return Main;
1054     if (QType->isWideCharType())
1055       return WMain;
1056     return None;
1057   };
1058   auto IsIntType = [](QualType QType) {
1059     if (QType.isNull())
1060       return false;
1061     if (const auto *Builtin =
1062             dyn_cast<BuiltinType>(QType->getUnqualifiedDesugaredType())) {
1063       return Builtin->getKind() == BuiltinType::Int;
1064     }
1065     return false;
1066   };
1067   if (!IsIntType(FDecl->getReturnType()))
1068     return false;
1069   if (FDecl->getNumParams() < 2 || FDecl->getNumParams() > 3)
1070     return false;
1071   if (!IsIntType(FDecl->parameters()[0]->getType()))
1072     return false;
1073   MainType Type = IsCharPtrPtr(FDecl->parameters()[1]->getType());
1074   if (Type == None)
1075     return false;
1076   if (FDecl->getNumParams() == 3 &&
1077       IsCharPtrPtr(FDecl->parameters()[2]->getType()) != Type)
1078     return false;
1079 
1080   if (Type == Main) {
1081     static llvm::Regex Matcher(
1082         "(^[Mm]ain([_A-Z]|$))|([a-z0-9_]Main([_A-Z]|$))|(_main(_|$))");
1083     assert(Matcher.isValid() && "Invalid Matcher for main like functions.");
1084     return Matcher.match(FDecl->getName());
1085   }
1086   static llvm::Regex Matcher("(^((W[Mm])|(wm))ain([_A-Z]|$))|([a-z0-9_]W[Mm]"
1087                              "ain([_A-Z]|$))|(_wmain(_|$))");
1088   assert(Matcher.isValid() && "Invalid Matcher for wmain like functions.");
1089   return Matcher.match(FDecl->getName());
1090 }
1091 
1092 std::string IdentifierNamingCheck::fixupWithStyle(
1093     StringRef Type, StringRef Name,
1094     const IdentifierNamingCheck::NamingStyle &Style,
1095     const IdentifierNamingCheck::HungarianNotationOption &HNOption,
1096     const Decl *D) const {
1097   Name.consume_front(Style.Prefix);
1098   Name.consume_back(Style.Suffix);
1099   std::string Fixed = fixupWithCase(
1100       Type, Name, D, Style, HNOption,
1101       Style.Case.value_or(IdentifierNamingCheck::CaseType::CT_AnyCase));
1102 
1103   std::string HungarianPrefix;
1104   using HungarianPrefixType = IdentifierNamingCheck::HungarianPrefixType;
1105   if (HungarianPrefixType::HPT_Off != Style.HPType) {
1106     HungarianPrefix = HungarianNotation.getPrefix(D, HNOption);
1107     if (!HungarianPrefix.empty()) {
1108       if (Style.HPType == HungarianPrefixType::HPT_LowerCase)
1109         HungarianPrefix += "_";
1110 
1111       if (Style.HPType == HungarianPrefixType::HPT_CamelCase)
1112         Fixed[0] = toupper(Fixed[0]);
1113     }
1114   }
1115   StringRef Mid = StringRef(Fixed).trim("_");
1116   if (Mid.empty())
1117     Mid = "_";
1118 
1119   return (Style.Prefix + HungarianPrefix + Mid + Style.Suffix).str();
1120 }
1121 
1122 StyleKind IdentifierNamingCheck::findStyleKind(
1123     const NamedDecl *D,
1124     ArrayRef<std::optional<IdentifierNamingCheck::NamingStyle>> NamingStyles,
1125     bool IgnoreMainLikeFunctions, bool CheckAnonFieldInParentScope) const {
1126   assert(D && D->getIdentifier() && !D->getName().empty() && !D->isImplicit() &&
1127          "Decl must be an explicit identifier with a name.");
1128 
1129   if (isa<ObjCIvarDecl>(D) && NamingStyles[SK_ObjcIvar])
1130     return SK_ObjcIvar;
1131 
1132   if (isa<TypedefDecl>(D) && NamingStyles[SK_Typedef])
1133     return SK_Typedef;
1134 
1135   if (isa<TypeAliasDecl>(D) && NamingStyles[SK_TypeAlias])
1136     return SK_TypeAlias;
1137 
1138   if (isa<NamespaceAliasDecl>(D) && NamingStyles[SK_Namespace])
1139     return SK_Namespace;
1140 
1141   if (const auto *Decl = dyn_cast<NamespaceDecl>(D)) {
1142     if (Decl->isAnonymousNamespace())
1143       return SK_Invalid;
1144 
1145     if (Decl->isInline() && NamingStyles[SK_InlineNamespace])
1146       return SK_InlineNamespace;
1147 
1148     if (NamingStyles[SK_Namespace])
1149       return SK_Namespace;
1150   }
1151 
1152   if (isa<EnumDecl>(D) && NamingStyles[SK_Enum])
1153     return SK_Enum;
1154 
1155   if (const auto *EnumConst = dyn_cast<EnumConstantDecl>(D)) {
1156     if (cast<EnumDecl>(EnumConst->getDeclContext())->isScoped() &&
1157         NamingStyles[SK_ScopedEnumConstant])
1158       return SK_ScopedEnumConstant;
1159 
1160     if (NamingStyles[SK_EnumConstant])
1161       return SK_EnumConstant;
1162 
1163     if (NamingStyles[SK_Constant])
1164       return SK_Constant;
1165 
1166     return SK_Invalid;
1167   }
1168 
1169   if (const auto *Decl = dyn_cast<RecordDecl>(D)) {
1170     if (Decl->isAnonymousStructOrUnion())
1171       return SK_Invalid;
1172 
1173     if (const auto *Definition = Decl->getDefinition()) {
1174       if (const auto *CxxRecordDecl = dyn_cast<CXXRecordDecl>(Definition)) {
1175         if (CxxRecordDecl->isAbstract() && NamingStyles[SK_AbstractClass])
1176           return SK_AbstractClass;
1177       }
1178 
1179       if (Definition->isStruct() && NamingStyles[SK_Struct])
1180         return SK_Struct;
1181 
1182       if (Definition->isStruct() && NamingStyles[SK_Class])
1183         return SK_Class;
1184 
1185       if (Definition->isClass() && NamingStyles[SK_Class])
1186         return SK_Class;
1187 
1188       if (Definition->isClass() && NamingStyles[SK_Struct])
1189         return SK_Struct;
1190 
1191       if (Definition->isUnion() && NamingStyles[SK_Union])
1192         return SK_Union;
1193 
1194       if (Definition->isEnum() && NamingStyles[SK_Enum])
1195         return SK_Enum;
1196     }
1197 
1198     return SK_Invalid;
1199   }
1200 
1201   if (const auto *Decl = dyn_cast<FieldDecl>(D)) {
1202     if (CheckAnonFieldInParentScope) {
1203       const RecordDecl *Record = Decl->getParent();
1204       if (Record->isAnonymousStructOrUnion()) {
1205         return findStyleKindForAnonField(Decl, NamingStyles);
1206       }
1207     }
1208 
1209     return findStyleKindForField(Decl, Decl->getType(), NamingStyles);
1210   }
1211 
1212   if (const auto *Decl = dyn_cast<ParmVarDecl>(D)) {
1213     if (isParamInMainLikeFunction(*Decl, IgnoreMainLikeFunctions))
1214       return SK_Invalid;
1215     QualType Type = Decl->getType();
1216 
1217     if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable])
1218       return SK_ConstexprVariable;
1219 
1220     if (!Type.isNull() && Type.isConstQualified()) {
1221       if (Type.getTypePtr()->isAnyPointerType() &&
1222           NamingStyles[SK_ConstantPointerParameter])
1223         return SK_ConstantPointerParameter;
1224 
1225       if (NamingStyles[SK_ConstantParameter])
1226         return SK_ConstantParameter;
1227 
1228       if (NamingStyles[SK_Constant])
1229         return SK_Constant;
1230     }
1231 
1232     if (Decl->isParameterPack() && NamingStyles[SK_ParameterPack])
1233       return SK_ParameterPack;
1234 
1235     if (!Type.isNull() && Type.getTypePtr()->isAnyPointerType() &&
1236         NamingStyles[SK_PointerParameter])
1237       return SK_PointerParameter;
1238 
1239     if (NamingStyles[SK_Parameter])
1240       return SK_Parameter;
1241 
1242     return SK_Invalid;
1243   }
1244 
1245   if (const auto *Decl = dyn_cast<VarDecl>(D)) {
1246     return findStyleKindForVar(Decl, Decl->getType(), NamingStyles);
1247   }
1248 
1249   if (const auto *Decl = dyn_cast<CXXMethodDecl>(D)) {
1250     if (Decl->isMain() || !Decl->isUserProvided() ||
1251         Decl->size_overridden_methods() > 0 || Decl->hasAttr<OverrideAttr>())
1252       return SK_Invalid;
1253 
1254     // If this method has the same name as any base method, this is likely
1255     // necessary even if it's not an override. e.g. CRTP.
1256     for (const CXXBaseSpecifier &Base : Decl->getParent()->bases())
1257       if (const auto *RD = Base.getType()->getAsCXXRecordDecl())
1258         if (RD->hasMemberName(Decl->getDeclName()))
1259           return SK_Invalid;
1260 
1261     if (Decl->isConstexpr() && NamingStyles[SK_ConstexprMethod])
1262       return SK_ConstexprMethod;
1263 
1264     if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction])
1265       return SK_ConstexprFunction;
1266 
1267     if (Decl->isStatic() && NamingStyles[SK_ClassMethod])
1268       return SK_ClassMethod;
1269 
1270     if (Decl->isVirtual() && NamingStyles[SK_VirtualMethod])
1271       return SK_VirtualMethod;
1272 
1273     if (Decl->getAccess() == AS_private && NamingStyles[SK_PrivateMethod])
1274       return SK_PrivateMethod;
1275 
1276     if (Decl->getAccess() == AS_protected && NamingStyles[SK_ProtectedMethod])
1277       return SK_ProtectedMethod;
1278 
1279     if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMethod])
1280       return SK_PublicMethod;
1281 
1282     if (NamingStyles[SK_Method])
1283       return SK_Method;
1284 
1285     if (NamingStyles[SK_Function])
1286       return SK_Function;
1287 
1288     return SK_Invalid;
1289   }
1290 
1291   if (const auto *Decl = dyn_cast<FunctionDecl>(D)) {
1292     if (Decl->isMain())
1293       return SK_Invalid;
1294 
1295     if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction])
1296       return SK_ConstexprFunction;
1297 
1298     if (Decl->isGlobal() && NamingStyles[SK_GlobalFunction])
1299       return SK_GlobalFunction;
1300 
1301     if (NamingStyles[SK_Function])
1302       return SK_Function;
1303   }
1304 
1305   if (isa<TemplateTypeParmDecl>(D)) {
1306     if (NamingStyles[SK_TypeTemplateParameter])
1307       return SK_TypeTemplateParameter;
1308 
1309     if (NamingStyles[SK_TemplateParameter])
1310       return SK_TemplateParameter;
1311 
1312     return SK_Invalid;
1313   }
1314 
1315   if (isa<NonTypeTemplateParmDecl>(D)) {
1316     if (NamingStyles[SK_ValueTemplateParameter])
1317       return SK_ValueTemplateParameter;
1318 
1319     if (NamingStyles[SK_TemplateParameter])
1320       return SK_TemplateParameter;
1321 
1322     return SK_Invalid;
1323   }
1324 
1325   if (isa<TemplateTemplateParmDecl>(D)) {
1326     if (NamingStyles[SK_TemplateTemplateParameter])
1327       return SK_TemplateTemplateParameter;
1328 
1329     if (NamingStyles[SK_TemplateParameter])
1330       return SK_TemplateParameter;
1331 
1332     return SK_Invalid;
1333   }
1334 
1335   if (isa<ConceptDecl>(D) && NamingStyles[SK_Concept])
1336     return SK_Concept;
1337 
1338   return SK_Invalid;
1339 }
1340 
1341 std::optional<RenamerClangTidyCheck::FailureInfo>
1342 IdentifierNamingCheck::getFailureInfo(
1343     StringRef Type, StringRef Name, const NamedDecl *ND,
1344     SourceLocation Location,
1345     ArrayRef<std::optional<IdentifierNamingCheck::NamingStyle>> NamingStyles,
1346     const IdentifierNamingCheck::HungarianNotationOption &HNOption,
1347     StyleKind SK, const SourceManager &SM, bool IgnoreFailedSplit) const {
1348   if (SK == SK_Invalid || !NamingStyles[SK])
1349     return std::nullopt;
1350 
1351   const IdentifierNamingCheck::NamingStyle &Style = *NamingStyles[SK];
1352   if (Style.IgnoredRegexp.isValid() && Style.IgnoredRegexp.match(Name))
1353     return std::nullopt;
1354 
1355   if (matchesStyle(Type, Name, Style, HNOption, ND))
1356     return std::nullopt;
1357 
1358   std::string KindName =
1359       fixupWithCase(Type, StyleNames[SK], ND, Style, HNOption,
1360                     IdentifierNamingCheck::CT_LowerCase);
1361   std::replace(KindName.begin(), KindName.end(), '_', ' ');
1362 
1363   std::string Fixup = fixupWithStyle(Type, Name, Style, HNOption, ND);
1364   if (StringRef(Fixup) == Name) {
1365     if (!IgnoreFailedSplit) {
1366       LLVM_DEBUG(Location.print(llvm::dbgs(), SM);
1367                  llvm::dbgs()
1368                  << llvm::formatv(": unable to split words for {0} '{1}'\n",
1369                                   KindName, Name));
1370     }
1371     return std::nullopt;
1372   }
1373   return RenamerClangTidyCheck::FailureInfo{std::move(KindName),
1374                                             std::move(Fixup)};
1375 }
1376 
1377 std::optional<RenamerClangTidyCheck::FailureInfo>
1378 IdentifierNamingCheck::getDeclFailureInfo(const NamedDecl *Decl,
1379                                           const SourceManager &SM) const {
1380   // Implicit identifiers cannot be renamed.
1381   if (Decl->isImplicit())
1382     return std::nullopt;
1383 
1384   SourceLocation Loc = Decl->getLocation();
1385   const FileStyle &FileStyle = getStyleForFile(SM.getFilename(Loc));
1386   if (!FileStyle.isActive())
1387     return std::nullopt;
1388 
1389   return getFailureInfo(
1390       HungarianNotation.getDeclTypeName(Decl), Decl->getName(), Decl, Loc,
1391       FileStyle.getStyles(), FileStyle.getHNOption(),
1392       findStyleKind(Decl, FileStyle.getStyles(),
1393                     FileStyle.isIgnoringMainLikeFunction(),
1394                     FileStyle.isCheckingAnonFieldInParentScope()),
1395       SM, IgnoreFailedSplit);
1396 }
1397 
1398 std::optional<RenamerClangTidyCheck::FailureInfo>
1399 IdentifierNamingCheck::getMacroFailureInfo(const Token &MacroNameTok,
1400                                            const SourceManager &SM) const {
1401   SourceLocation Loc = MacroNameTok.getLocation();
1402   const FileStyle &Style = getStyleForFile(SM.getFilename(Loc));
1403   if (!Style.isActive())
1404     return std::nullopt;
1405 
1406   return getFailureInfo("", MacroNameTok.getIdentifierInfo()->getName(),
1407                         nullptr, Loc, Style.getStyles(), Style.getHNOption(),
1408                         SK_MacroDefinition, SM, IgnoreFailedSplit);
1409 }
1410 
1411 RenamerClangTidyCheck::DiagInfo
1412 IdentifierNamingCheck::getDiagInfo(const NamingCheckId &ID,
1413                                    const NamingCheckFailure &Failure) const {
1414   return DiagInfo{"invalid case style for %0 '%1'",
1415                   [&](DiagnosticBuilder &Diag) {
1416                     Diag << Failure.Info.KindName << ID.second;
1417                   }};
1418 }
1419 
1420 StringRef IdentifierNamingCheck::getRealFileName(StringRef FileName) const {
1421   auto Iter = RealFileNameCache.try_emplace(FileName);
1422   SmallString<256U> &RealFileName = Iter.first->getValue();
1423   if (!Iter.second)
1424     return RealFileName;
1425   llvm::sys::fs::real_path(FileName, RealFileName);
1426   return RealFileName;
1427 }
1428 
1429 const IdentifierNamingCheck::FileStyle &
1430 IdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
1431   if (!GetConfigPerFile)
1432     return *MainFileStyle;
1433 
1434   StringRef RealFileName = getRealFileName(FileName);
1435   StringRef Parent = llvm::sys::path::parent_path(RealFileName);
1436   auto Iter = NamingStylesCache.find(Parent);
1437   if (Iter != NamingStylesCache.end())
1438     return Iter->getValue();
1439 
1440   llvm::StringRef CheckName = getID();
1441   ClangTidyOptions Options = Context->getOptionsForFile(RealFileName);
1442   if (Options.Checks && GlobList(*Options.Checks).contains(CheckName)) {
1443     auto It = NamingStylesCache.try_emplace(
1444         Parent,
1445         getFileStyleFromOptions({CheckName, Options.CheckOptions, Context}));
1446     assert(It.second);
1447     return It.first->getValue();
1448   }
1449   // Default construction gives an empty style.
1450   auto It = NamingStylesCache.try_emplace(Parent);
1451   assert(It.second);
1452   return It.first->getValue();
1453 }
1454 
1455 StyleKind IdentifierNamingCheck::findStyleKindForAnonField(
1456     const FieldDecl *AnonField,
1457     ArrayRef<std::optional<NamingStyle>> NamingStyles) const {
1458   const IndirectFieldDecl *IFD =
1459       utils::findOutermostIndirectFieldDeclForField(AnonField);
1460   assert(IFD && "Found an anonymous record field without an IndirectFieldDecl");
1461 
1462   QualType Type = AnonField->getType();
1463 
1464   if (const auto *F = dyn_cast<FieldDecl>(IFD->chain().front())) {
1465     return findStyleKindForField(F, Type, NamingStyles);
1466   }
1467 
1468   if (const auto *V = IFD->getVarDecl()) {
1469     return findStyleKindForVar(V, Type, NamingStyles);
1470   }
1471 
1472   return SK_Invalid;
1473 }
1474 
1475 StyleKind IdentifierNamingCheck::findStyleKindForField(
1476     const FieldDecl *Field, QualType Type,
1477     ArrayRef<std::optional<NamingStyle>> NamingStyles) const {
1478   if (!Type.isNull() && Type.isConstQualified()) {
1479     if (NamingStyles[SK_ConstantMember])
1480       return SK_ConstantMember;
1481 
1482     if (NamingStyles[SK_Constant])
1483       return SK_Constant;
1484   }
1485 
1486   if (Field->getAccess() == AS_private && NamingStyles[SK_PrivateMember])
1487     return SK_PrivateMember;
1488 
1489   if (Field->getAccess() == AS_protected && NamingStyles[SK_ProtectedMember])
1490     return SK_ProtectedMember;
1491 
1492   if (Field->getAccess() == AS_public && NamingStyles[SK_PublicMember])
1493     return SK_PublicMember;
1494 
1495   if (NamingStyles[SK_Member])
1496     return SK_Member;
1497 
1498   return SK_Invalid;
1499 }
1500 
1501 StyleKind IdentifierNamingCheck::findStyleKindForVar(
1502     const VarDecl *Var, QualType Type,
1503     ArrayRef<std::optional<NamingStyle>> NamingStyles) const {
1504   if (Var->isConstexpr() && NamingStyles[SK_ConstexprVariable])
1505     return SK_ConstexprVariable;
1506 
1507   if (!Type.isNull() && Type.isConstQualified()) {
1508     if (Var->isStaticDataMember() && NamingStyles[SK_ClassConstant])
1509       return SK_ClassConstant;
1510 
1511     if (Var->isFileVarDecl() && Type.getTypePtr()->isAnyPointerType() &&
1512         NamingStyles[SK_GlobalConstantPointer])
1513       return SK_GlobalConstantPointer;
1514 
1515     if (Var->isFileVarDecl() && NamingStyles[SK_GlobalConstant])
1516       return SK_GlobalConstant;
1517 
1518     if (Var->isStaticLocal() && NamingStyles[SK_StaticConstant])
1519       return SK_StaticConstant;
1520 
1521     if (Var->isLocalVarDecl() && Type.getTypePtr()->isAnyPointerType() &&
1522         NamingStyles[SK_LocalConstantPointer])
1523       return SK_LocalConstantPointer;
1524 
1525     if (Var->isLocalVarDecl() && NamingStyles[SK_LocalConstant])
1526       return SK_LocalConstant;
1527 
1528     if (Var->isFunctionOrMethodVarDecl() && NamingStyles[SK_LocalConstant])
1529       return SK_LocalConstant;
1530 
1531     if (NamingStyles[SK_Constant])
1532       return SK_Constant;
1533   }
1534 
1535   if (Var->isStaticDataMember() && NamingStyles[SK_ClassMember])
1536     return SK_ClassMember;
1537 
1538   if (Var->isFileVarDecl() && Type.getTypePtr()->isAnyPointerType() &&
1539       NamingStyles[SK_GlobalPointer])
1540     return SK_GlobalPointer;
1541 
1542   if (Var->isFileVarDecl() && NamingStyles[SK_GlobalVariable])
1543     return SK_GlobalVariable;
1544 
1545   if (Var->isStaticLocal() && NamingStyles[SK_StaticVariable])
1546     return SK_StaticVariable;
1547 
1548   if (Var->isLocalVarDecl() && Type.getTypePtr()->isAnyPointerType() &&
1549       NamingStyles[SK_LocalPointer])
1550     return SK_LocalPointer;
1551 
1552   if (Var->isLocalVarDecl() && NamingStyles[SK_LocalVariable])
1553     return SK_LocalVariable;
1554 
1555   if (Var->isFunctionOrMethodVarDecl() && NamingStyles[SK_LocalVariable])
1556     return SK_LocalVariable;
1557 
1558   if (NamingStyles[SK_Variable])
1559     return SK_Variable;
1560 
1561   return SK_Invalid;
1562 }
1563 
1564 } // namespace readability
1565 } // namespace clang::tidy
1566