12 #include "llvm/Support/Debug.h"
13 #include "llvm/Support/Format.h"
14 #include "clang/ASTMatchers/ASTMatchFinder.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Lex/PPCallbacks.h"
17 #include "clang/Lex/Preprocessor.h"
18 #include "llvm/ADT/DenseMapInfo.h"
20 #define DEBUG_TYPE "clang-tidy"
22 using namespace clang::ast_matchers;
34 clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-1)),
40 clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-2)),
45 assert(Val != getEmptyKey() &&
"Cannot hash the empty key!");
46 assert(Val != getTombstoneKey() &&
"Cannot hash the tombstone key!");
48 std::hash<NamingCheckId::second_type> SecondHash;
49 return Val.first.getRawEncoding() + SecondHash(Val.second);
53 if (RHS == getEmptyKey())
54 return LHS == getEmptyKey();
55 if (RHS == getTombstoneKey())
56 return LHS == getTombstoneKey();
64 namespace readability {
67 #define NAMING_KEYS(m) \
71 m(ConstexprVariable) \
87 m(ConstantParameter) \
96 m(ConstexprFunction) \
106 m(TypeTemplateParameter) \
107 m(ValueTemplateParameter) \
108 m(TemplateTemplateParameter) \
109 m(TemplateParameter) \
114 #define ENUMERATE(v) SK_ ## v,
122 #define STRINGIZE(v) #v,
132 class IdentifierNamingCheckPPCallbacks :
public PPCallbacks {
134 IdentifierNamingCheckPPCallbacks(Preprocessor *
PP,
135 IdentifierNamingCheck *
Check)
136 : PP(PP), Check(Check) {}
139 void MacroDefined(
const Token &MacroNameTok,
140 const MacroDirective *MD)
override {
141 Check->checkMacro(
PP->getSourceManager(), MacroNameTok, MD->getMacroInfo());
145 void MacroExpands(
const Token &MacroNameTok,
const MacroDefinition &MD,
147 const MacroArgs * )
override {
148 Check->expandMacro(MacroNameTok, MD.getMacroInfo());
157 IdentifierNamingCheck::IdentifierNamingCheck(StringRef
Name,
160 auto const fromString = [](StringRef Str) {
161 return llvm::StringSwitch<CaseType>(Str)
170 NamingStyles.push_back(
176 IgnoreFailedSplit =
Options.
get(
"IgnoreFailedSplit", 0);
180 auto const toString = [](
CaseType Type) {
194 llvm_unreachable(
"Unknown Case Type");
197 for (
size_t i = 0; i <
SK_Count; ++i) {
199 toString(NamingStyles[i].Case));
201 NamingStyles[i].Prefix);
203 NamingStyles[i].Suffix);
206 Options.
store(Opts,
"IgnoreFailedSplit", IgnoreFailedSplit);
210 Finder->addMatcher(namedDecl().bind(
"decl"),
this);
211 Finder->addMatcher(usingDecl().bind(
"using"),
this);
212 Finder->addMatcher(declRefExpr().bind(
"declRef"),
this);
213 Finder->addMatcher(cxxConstructorDecl().bind(
"classRef"),
this);
214 Finder->addMatcher(cxxDestructorDecl().bind(
"classRef"),
this);
215 Finder->addMatcher(typeLoc().bind(
"typeLoc"),
this);
216 Finder->addMatcher(nestedNameSpecifierLoc().bind(
"nestedNameLoc"),
this);
220 Compiler.getPreprocessor().addPPCallbacks(
221 llvm::make_unique<IdentifierNamingCheckPPCallbacks>(
222 &Compiler.getPreprocessor(),
this));
227 static llvm::Regex Matchers[] = {
229 llvm::Regex(
"^[a-z][a-z0-9_]*$"),
230 llvm::Regex(
"^[a-z][a-zA-Z0-9]*$"),
231 llvm::Regex(
"^[A-Z][A-Z0-9_]*$"),
232 llvm::Regex(
"^[A-Z][a-zA-Z0-9]*$"),
236 if (Name.startswith(Style.
Prefix))
237 Name = Name.drop_front(Style.
Prefix.size());
241 if (Name.endswith(Style.
Suffix))
242 Name = Name.drop_back(Style.
Suffix.size());
246 if (!Matchers[static_cast<size_t>(Style.
Case)].match(Name))
254 static llvm::Regex Splitter(
255 "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
257 SmallVector<StringRef, 8> Substrs;
258 Name.split(Substrs,
"_", -1,
false);
260 SmallVector<StringRef, 8> Words;
261 for (
auto Substr : Substrs) {
262 while (!Substr.empty()) {
263 SmallVector<StringRef, 8> Groups;
264 if (!Splitter.match(Substr, &Groups))
267 if (Groups[2].size() > 0) {
268 Words.push_back(Groups[1]);
269 Substr = Substr.substr(Groups[0].size());
270 }
else if (Groups[3].size() > 0) {
271 Words.push_back(Groups[3]);
272 Substr = Substr.substr(Groups[0].size() - Groups[4].size());
273 }
else if (Groups[5].size() > 0) {
274 Words.push_back(Groups[5]);
275 Substr = Substr.substr(Groups[0].size() - Groups[6].size());
290 for (
auto const &Word : Words) {
291 if (&Word != &Words.front())
293 Fixup += Word.lower();
298 for (
auto const &Word : Words) {
299 if (&Word != &Words.front())
301 Fixup += Word.upper();
306 for (
auto const &Word : Words) {
307 Fixup += Word.substr(0, 1).upper();
308 Fixup += Word.substr(1).lower();
313 for (
auto const &Word : Words) {
314 if (&Word == &Words.front()) {
315 Fixup += Word.lower();
317 Fixup += Word.substr(0, 1).upper();
318 Fixup += Word.substr(1).lower();
334 const std::vector<IdentifierNamingCheck::NamingStyle> &NamingStyles) {
335 if (isa<TypedefDecl>(D) && NamingStyles[SK_Typedef].isSet())
338 if (isa<TypeAliasDecl>(D) && NamingStyles[SK_TypeAlias].isSet())
341 if (
const auto *Decl = dyn_cast<NamespaceDecl>(D)) {
342 if (Decl->isAnonymousNamespace())
345 if (Decl->isInline() && NamingStyles[SK_InlineNamespace].isSet())
346 return SK_InlineNamespace;
348 if (NamingStyles[SK_Namespace].isSet())
352 if (isa<EnumDecl>(D) && NamingStyles[SK_Enum].isSet())
355 if (isa<EnumConstantDecl>(D)) {
356 if (NamingStyles[SK_EnumConstant].isSet())
357 return SK_EnumConstant;
359 if (NamingStyles[SK_Constant].isSet())
365 if (
const auto *Decl = dyn_cast<CXXRecordDecl>(D)) {
366 if (Decl->isAnonymousStructOrUnion())
369 if (Decl->hasDefinition() && Decl->isAbstract() &&
370 NamingStyles[SK_AbstractClass].isSet())
371 return SK_AbstractClass;
373 if (Decl->isStruct() && NamingStyles[SK_Struct].isSet())
376 if (Decl->isStruct() && NamingStyles[SK_Class].isSet())
379 if (Decl->isClass() && NamingStyles[SK_Class].isSet())
382 if (Decl->isClass() && NamingStyles[SK_Struct].isSet())
385 if (Decl->isUnion() && NamingStyles[SK_Union].isSet())
388 if (Decl->isEnum() && NamingStyles[SK_Enum].isSet())
394 if (
const auto *Decl = dyn_cast<FieldDecl>(D)) {
395 QualType Type = Decl->getType();
397 if (!Type.isNull() && Type.isLocalConstQualified() &&
398 NamingStyles[SK_ConstantMember].isSet())
399 return SK_ConstantMember;
401 if (!Type.isNull() && Type.isLocalConstQualified() &&
402 NamingStyles[SK_Constant].isSet())
405 if (Decl->getAccess() == AS_private &&
406 NamingStyles[SK_PrivateMember].isSet())
407 return SK_PrivateMember;
409 if (Decl->getAccess() == AS_protected &&
410 NamingStyles[SK_ProtectedMember].isSet())
411 return SK_ProtectedMember;
413 if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMember].isSet())
414 return SK_PublicMember;
416 if (NamingStyles[SK_Member].isSet())
422 if (
const auto *Decl = dyn_cast<ParmVarDecl>(D)) {
423 QualType Type = Decl->getType();
425 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
426 return SK_ConstexprVariable;
428 if (!Type.isNull() && Type.isLocalConstQualified() &&
429 NamingStyles[SK_ConstantParameter].isSet())
430 return SK_ConstantParameter;
432 if (!Type.isNull() && Type.isLocalConstQualified() &&
433 NamingStyles[SK_Constant].isSet())
436 if (Decl->isParameterPack() && NamingStyles[SK_ParameterPack].isSet())
437 return SK_ParameterPack;
439 if (NamingStyles[SK_Parameter].isSet())
445 if (
const auto *Decl = dyn_cast<VarDecl>(D)) {
446 QualType Type = Decl->getType();
448 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
449 return SK_ConstexprVariable;
451 if (!Type.isNull() && Type.isLocalConstQualified() &&
452 Decl->isStaticDataMember() && NamingStyles[SK_ClassConstant].isSet())
453 return SK_ClassConstant;
455 if (!Type.isNull() && Type.isLocalConstQualified() &&
456 Decl->isFileVarDecl() && NamingStyles[SK_GlobalConstant].isSet())
457 return SK_GlobalConstant;
459 if (!Type.isNull() && Type.isLocalConstQualified() &&
460 Decl->isStaticLocal() && NamingStyles[SK_StaticConstant].isSet())
461 return SK_StaticConstant;
463 if (!Type.isNull() && Type.isLocalConstQualified() &&
464 Decl->isLocalVarDecl() && NamingStyles[SK_LocalConstant].isSet())
465 return SK_LocalConstant;
467 if (!Type.isNull() && Type.isLocalConstQualified() &&
468 Decl->isFunctionOrMethodVarDecl() &&
469 NamingStyles[SK_LocalConstant].isSet())
470 return SK_LocalConstant;
472 if (!Type.isNull() && Type.isLocalConstQualified() &&
473 NamingStyles[SK_Constant].isSet())
476 if (Decl->isStaticDataMember() && NamingStyles[SK_ClassMember].isSet())
477 return SK_ClassMember;
479 if (Decl->isFileVarDecl() && NamingStyles[SK_GlobalVariable].isSet())
480 return SK_GlobalVariable;
482 if (Decl->isStaticLocal() && NamingStyles[SK_StaticVariable].isSet())
483 return SK_StaticVariable;
485 if (Decl->isLocalVarDecl() && NamingStyles[SK_LocalVariable].isSet())
486 return SK_LocalVariable;
488 if (Decl->isFunctionOrMethodVarDecl() &&
489 NamingStyles[SK_LocalVariable].isSet())
490 return SK_LocalVariable;
492 if (NamingStyles[SK_Variable].isSet())
498 if (
const auto *Decl = dyn_cast<CXXMethodDecl>(D)) {
499 if (Decl->isMain() || !Decl->isUserProvided() ||
500 Decl->isUsualDeallocationFunction() ||
501 Decl->isCopyAssignmentOperator() || Decl->isMoveAssignmentOperator() ||
502 Decl->size_overridden_methods() > 0)
505 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprMethod].isSet())
506 return SK_ConstexprMethod;
508 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
509 return SK_ConstexprFunction;
511 if (Decl->isStatic() && NamingStyles[SK_ClassMethod].isSet())
512 return SK_ClassMethod;
514 if (Decl->isVirtual() && NamingStyles[SK_VirtualMethod].isSet())
515 return SK_VirtualMethod;
517 if (Decl->getAccess() == AS_private &&
518 NamingStyles[SK_PrivateMethod].isSet())
519 return SK_PrivateMethod;
521 if (Decl->getAccess() == AS_protected &&
522 NamingStyles[SK_ProtectedMethod].isSet())
523 return SK_ProtectedMethod;
525 if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMethod].isSet())
526 return SK_PublicMethod;
528 if (NamingStyles[SK_Method].isSet())
531 if (NamingStyles[SK_Function].isSet())
537 if (
const auto *Decl = dyn_cast<FunctionDecl>(D)) {
541 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
542 return SK_ConstexprFunction;
544 if (Decl->isGlobal() && NamingStyles[SK_GlobalFunction].isSet())
545 return SK_GlobalFunction;
547 if (NamingStyles[SK_Function].isSet())
551 if (isa<TemplateTypeParmDecl>(D)) {
552 if (NamingStyles[SK_TypeTemplateParameter].isSet())
553 return SK_TypeTemplateParameter;
555 if (NamingStyles[SK_TemplateParameter].isSet())
556 return SK_TemplateParameter;
561 if (isa<NonTypeTemplateParmDecl>(D)) {
562 if (NamingStyles[SK_ValueTemplateParameter].isSet())
563 return SK_ValueTemplateParameter;
565 if (NamingStyles[SK_TemplateParameter].isSet())
566 return SK_TemplateParameter;
571 if (isa<TemplateTemplateParmDecl>(D)) {
572 if (NamingStyles[SK_TemplateTemplateParameter].isSet())
573 return SK_TemplateTemplateParameter;
575 if (NamingStyles[SK_TemplateParameter].isSet())
576 return SK_TemplateParameter;
588 if (Range.getBegin().isInvalid() || Range.getEnd().isInvalid())
593 auto &Failure = Failures[Decl];
594 if (!Failure.RawUsageLocs.insert(Range.getBegin().getRawEncoding()).second)
597 Failure.ShouldFix = Failure.ShouldFix && !Range.getBegin().isMacroID() &&
598 !Range.getEnd().isMacroID();
603 const NamedDecl *Decl, SourceRange
Range) {
605 Decl->getLocation(), Decl->getNameAsString()),
610 if (
const auto *Decl =
611 Result.Nodes.getNodeAs<CXXConstructorDecl>(
"classRef")) {
612 if (Decl->isImplicit())
615 addUsage(NamingCheckFailures, Decl->getParent(),
616 Decl->getNameInfo().getSourceRange());
620 if (
const auto *Decl =
621 Result.Nodes.getNodeAs<CXXDestructorDecl>(
"classRef")) {
622 if (Decl->isImplicit())
625 SourceRange
Range = Decl->getNameInfo().getSourceRange();
626 if (Range.getBegin().isInvalid())
630 Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
636 if (
const auto *
Loc = Result.Nodes.getNodeAs<TypeLoc>(
"typeLoc")) {
637 NamedDecl *Decl =
nullptr;
638 if (
const auto &Ref =
Loc->getAs<TagTypeLoc>()) {
639 Decl = Ref.getDecl();
640 }
else if (
const auto &Ref =
Loc->getAs<InjectedClassNameTypeLoc>()) {
641 Decl = Ref.getDecl();
642 }
else if (
const auto &Ref =
Loc->getAs<UnresolvedUsingTypeLoc>()) {
643 Decl = Ref.getDecl();
644 }
else if (
const auto &Ref =
Loc->getAs<TemplateTypeParmTypeLoc>()) {
645 Decl = Ref.getDecl();
649 addUsage(NamingCheckFailures, Decl,
Loc->getSourceRange());
653 if (
const auto &Ref =
Loc->getAs<TemplateSpecializationTypeLoc>()) {
655 Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();
657 SourceRange
Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
658 if (
const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
659 if (
const auto *TemplDecl = ClassDecl->getTemplatedDecl())
665 if (
const auto &Ref =
666 Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
667 if (
const auto *Decl = Ref.getTypePtr()->getAsTagDecl())
668 addUsage(NamingCheckFailures, Decl,
Loc->getSourceRange());
673 if (
const auto *
Loc =
674 Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
"nestedNameLoc")) {
675 if (NestedNameSpecifier *Spec =
Loc->getNestedNameSpecifier()) {
676 if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
677 addUsage(NamingCheckFailures, Decl,
Loc->getLocalSourceRange());
683 if (
const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>(
"using")) {
684 for (
const auto &Shadow : Decl->shadows()) {
685 addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
686 Decl->getNameInfo().getSourceRange());
691 if (
const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>(
"declRef")) {
692 SourceRange
Range = DeclRef->getNameInfo().getSourceRange();
697 if (
const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>(
"decl")) {
698 if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
702 if (
const auto *Value = Result.Nodes.getNodeAs<ValueDecl>(
"decl")) {
703 if (
const auto *Typedef =
704 Value->getType().getTypePtr()->getAs<TypedefType>()) {
705 addUsage(NamingCheckFailures, Typedef->getDecl(),
706 Value->getSourceRange());
711 if (
const auto *Value = Result.Nodes.getNodeAs<FunctionDecl>(
"decl")) {
712 if (
const auto *Typedef =
713 Value->getReturnType().getTypePtr()->getAs<TypedefType>()) {
714 addUsage(NamingCheckFailures, Typedef->getDecl(),
715 Value->getSourceRange());
717 for (
unsigned i = 0; i < Value->getNumParams(); ++i) {
718 if (
const auto *Typedef = Value->parameters()[i]
721 ->getAs<TypedefType>()) {
722 addUsage(NamingCheckFailures, Typedef->getDecl(),
723 Value->getSourceRange());
730 if (isa<ClassTemplateSpecializationDecl>(Decl))
738 StringRef
Name = Decl->getName();
743 std::replace(KindName.begin(), KindName.end(),
'_',
' ');
746 if (StringRef(Fixup).equals(Name)) {
747 if (!IgnoreFailedSplit) {
749 << Decl->getLocStart().printToString(*Result.SourceManager)
750 << llvm::format(
": unable to split words for %s '%s'\n",
751 KindName.c_str(),
Name));
755 Decl->getLocation(), Decl->getNameAsString())];
757 DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
760 Failure.
Fixup = std::move(Fixup);
761 Failure.
KindName = std::move(KindName);
762 addUsage(NamingCheckFailures, Decl, Range);
768 const Token &MacroNameTok,
769 const MacroInfo *MI) {
770 StringRef
Name = MacroNameTok.getIdentifierInfo()->getName();
771 NamingStyle Style = NamingStyles[SK_MacroDefinition];
775 std::string KindName =
777 std::replace(KindName.begin(), KindName.end(),
'_',
' ');
780 if (StringRef(Fixup).equals(Name)) {
781 if (!IgnoreFailedSplit) {
783 llvm::dbgs() << MacroNameTok.getLocation().printToString(SourceMgr)
784 << llvm::format(
": unable to split words for %s '%s'\n",
785 KindName.c_str(),
Name));
790 SourceRange
Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
792 Failure.Fixup = std::move(Fixup);
793 Failure.KindName = std::move(KindName);
799 const MacroInfo *MI) {
800 StringRef
Name = MacroNameTok.getIdentifierInfo()->getName();
803 auto Failure = NamingCheckFailures.find(ID);
804 if (Failure == NamingCheckFailures.end())
807 SourceRange
Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
812 for (
const auto &Pair : NamingCheckFailures) {
820 auto Diag =
diag(Decl.first,
"invalid case style for %0 '%1'")
834 Diag << FixItHint::CreateReplacement(
835 SourceRange(SourceLocation::getFromRawEncoding(
Loc)),
static unsigned getHashValue(NamingCheckId Val)
SourceLocation Loc
'#' location in the include directive
static StyleKind findStyleKind(const NamedDecl *D, const std::vector< IdentifierNamingCheck::NamingStyle > &NamingStyles)
void registerPPCallbacks(CompilerInstance &Compiler) override
Override this to register PPCallbacks with Compiler.
std::unique_ptr< ast_matchers::MatchFinder > Finder
Holds an identifier name check failure, tracking the kind of the identifer, its possible fixup and th...
static bool matchesStyle(StringRef Name, IdentifierNamingCheck::NamingStyle Style)
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
static NamingCheckId getEmptyKey()
Base class for all clang-tidy checks.
clang::tidy::readability::IdentifierNamingCheck::NamingCheckId NamingCheckId
IdentifierNamingCheck * Check
std::string get(StringRef LocalName, StringRef Default) const
Read a named option from the Context.
static std::string fixupWithStyle(StringRef Name, IdentifierNamingCheck::NamingStyle Style)
void expandMacro(const Token &MacroNameTok, const MacroInfo *MI)
Add a usage of a macro if it already has a violation.
std::pair< SourceLocation, std::string > NamingCheckId
static NamingCheckId getTombstoneKey()
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
std::map< std::string, std::string > OptionMap
void onEndOfTranslationUnit() override
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
static std::string fixupWithCase(StringRef Name, IdentifierNamingCheck::CaseType Case)
void checkMacro(SourceManager &sourceMgr, const Token &MacroNameTok, const MacroInfo *MI)
Check Macros for style violations.
static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures, const IdentifierNamingCheck::NamingCheckId &Decl, SourceRange Range)
llvm::DenseMap< NamingCheckId, NamingCheckFailure > NamingCheckFailureMap
CharSourceRange Range
SourceRange for the file name.
ClangTidyContext & Context
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
static StringRef const StyleNames[]
llvm::DenseSet< unsigned > RawUsageLocs
A set of all the identifier usages starting SourceLocation, in their encoded form.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
static bool isEqual(NamingCheckId LHS, NamingCheckId RHS)
bool ShouldFix
Whether the failure should be fixed or not.