12 #include "llvm/Support/Debug.h"
13 #include "llvm/Support/Format.h"
14 #include "clang/ASTMatchers/ASTMatchFinder.h"
16 #define DEBUG_TYPE "clang-tidy"
18 using namespace clang::ast_matchers;
22 namespace readability {
25 #define NAMING_KEYS(m) \
29 m(ConstexprVariable) \
45 m(ConstantParameter) \
54 m(ConstexprFunction) \
64 m(TypeTemplateParameter) \
65 m(ValueTemplateParameter) \
66 m(TemplateTemplateParameter) \
67 m(TemplateParameter) \
70 #define ENUMERATE(v) SK_ ## v,
78 #define STRINGIZE(v) #v,
86 IdentifierNamingCheck::IdentifierNamingCheck(StringRef
Name,
89 auto const fromString = [](StringRef Str) {
90 return llvm::StringSwitch<CaseType>(Str)
99 NamingStyles.push_back(
105 IgnoreFailedSplit =
Options.
get(
"IgnoreFailedSplit", 0);
109 auto const toString = [](
CaseType Type) {
123 llvm_unreachable(
"Unknown Case Type");
126 for (
size_t i = 0; i <
SK_Count; ++i) {
128 toString(NamingStyles[i].Case));
130 NamingStyles[i].Prefix);
132 NamingStyles[i].Suffix);
135 Options.
store(Opts,
"IgnoreFailedSplit", IgnoreFailedSplit);
139 Finder->addMatcher(namedDecl().bind(
"decl"),
this);
140 Finder->addMatcher(usingDecl().bind(
"using"),
this);
141 Finder->addMatcher(declRefExpr().bind(
"declRef"),
this);
142 Finder->addMatcher(cxxConstructorDecl().bind(
"classRef"),
this);
143 Finder->addMatcher(cxxDestructorDecl().bind(
"classRef"),
this);
144 Finder->addMatcher(typeLoc().bind(
"typeLoc"),
this);
145 Finder->addMatcher(nestedNameSpecifierLoc().bind(
"nestedNameLoc"),
this);
150 static llvm::Regex Matchers[] = {
152 llvm::Regex(
"^[a-z][a-z0-9_]*$"),
153 llvm::Regex(
"^[a-z][a-zA-Z0-9]*$"),
154 llvm::Regex(
"^[A-Z][A-Z0-9_]*$"),
155 llvm::Regex(
"^[A-Z][a-zA-Z0-9]*$"),
159 if (Name.startswith(Style.
Prefix))
160 Name = Name.drop_front(Style.
Prefix.size());
164 if (Name.endswith(Style.
Suffix))
165 Name = Name.drop_back(Style.
Suffix.size());
169 if (!Matchers[static_cast<size_t>(Style.
Case)].match(Name))
177 static llvm::Regex Splitter(
178 "([a-z0-9A-Z]*)(_+)|([A-Z]?[a-z0-9]+)([A-Z]|$)|([A-Z]+)([A-Z]|$)");
180 SmallVector<StringRef, 8> Substrs;
181 Name.split(Substrs,
"_", -1,
false);
183 SmallVector<StringRef, 8> Words;
184 for (
auto Substr : Substrs) {
185 while (!Substr.empty()) {
186 SmallVector<StringRef, 8> Groups;
187 if (!Splitter.match(Substr, &Groups))
190 if (Groups[2].size() > 0) {
191 Words.push_back(Groups[1]);
192 Substr = Substr.substr(Groups[0].size());
193 }
else if (Groups[3].size() > 0) {
194 Words.push_back(Groups[3]);
195 Substr = Substr.substr(Groups[0].size() - Groups[4].size());
196 }
else if (Groups[5].size() > 0) {
197 Words.push_back(Groups[5]);
198 Substr = Substr.substr(Groups[0].size() - Groups[6].size());
213 for (
auto const &Word : Words) {
214 if (&Word != &Words.front())
216 Fixup += Word.lower();
221 for (
auto const &Word : Words) {
222 if (&Word != &Words.front())
224 Fixup += Word.upper();
229 for (
auto const &Word : Words) {
230 Fixup += Word.substr(0, 1).upper();
231 Fixup += Word.substr(1).lower();
236 for (
auto const &Word : Words) {
237 if (&Word == &Words.front()) {
238 Fixup += Word.lower();
240 Fixup += Word.substr(0, 1).upper();
241 Fixup += Word.substr(1).lower();
257 const std::vector<IdentifierNamingCheck::NamingStyle> &NamingStyles) {
258 if (isa<TypedefDecl>(D) && NamingStyles[SK_Typedef].isSet())
261 if (
const auto *Decl = dyn_cast<NamespaceDecl>(D)) {
262 if (Decl->isAnonymousNamespace())
265 if (Decl->isInline() && NamingStyles[SK_InlineNamespace].isSet())
266 return SK_InlineNamespace;
268 if (NamingStyles[SK_Namespace].isSet())
272 if (isa<EnumDecl>(D) && NamingStyles[SK_Enum].isSet())
275 if (isa<EnumConstantDecl>(D)) {
276 if (NamingStyles[SK_EnumConstant].isSet())
277 return SK_EnumConstant;
279 if (NamingStyles[SK_Constant].isSet())
285 if (
const auto *Decl = dyn_cast<CXXRecordDecl>(D)) {
286 if (Decl->isAnonymousStructOrUnion())
289 if (Decl->hasDefinition() && Decl->isAbstract() &&
290 NamingStyles[SK_AbstractClass].isSet())
291 return SK_AbstractClass;
293 if (Decl->isStruct() && NamingStyles[SK_Struct].isSet())
296 if (Decl->isStruct() && NamingStyles[SK_Class].isSet())
299 if (Decl->isClass() && NamingStyles[SK_Class].isSet())
302 if (Decl->isClass() && NamingStyles[SK_Struct].isSet())
305 if (Decl->isUnion() && NamingStyles[SK_Union].isSet())
308 if (Decl->isEnum() && NamingStyles[SK_Enum].isSet())
314 if (
const auto *Decl = dyn_cast<FieldDecl>(D)) {
315 QualType Type = Decl->getType();
317 if (!Type.isNull() && Type.isLocalConstQualified() &&
318 NamingStyles[SK_ConstantMember].isSet())
319 return SK_ConstantMember;
321 if (!Type.isNull() && Type.isLocalConstQualified() &&
322 NamingStyles[SK_Constant].isSet())
325 if (Decl->getAccess() == AS_private &&
326 NamingStyles[SK_PrivateMember].isSet())
327 return SK_PrivateMember;
329 if (Decl->getAccess() == AS_protected &&
330 NamingStyles[SK_ProtectedMember].isSet())
331 return SK_ProtectedMember;
333 if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMember].isSet())
334 return SK_PublicMember;
336 if (NamingStyles[SK_Member].isSet())
342 if (
const auto *Decl = dyn_cast<ParmVarDecl>(D)) {
343 QualType Type = Decl->getType();
345 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
346 return SK_ConstexprVariable;
348 if (!Type.isNull() && Type.isLocalConstQualified() &&
349 NamingStyles[SK_ConstantParameter].isSet())
350 return SK_ConstantParameter;
352 if (!Type.isNull() && Type.isLocalConstQualified() &&
353 NamingStyles[SK_Constant].isSet())
356 if (Decl->isParameterPack() && NamingStyles[SK_ParameterPack].isSet())
357 return SK_ParameterPack;
359 if (NamingStyles[SK_Parameter].isSet())
365 if (
const auto *Decl = dyn_cast<VarDecl>(D)) {
366 QualType Type = Decl->getType();
368 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprVariable].isSet())
369 return SK_ConstexprVariable;
371 if (!Type.isNull() && Type.isLocalConstQualified() &&
372 Decl->isStaticDataMember() && NamingStyles[SK_ClassConstant].isSet())
373 return SK_ClassConstant;
375 if (!Type.isNull() && Type.isLocalConstQualified() &&
376 Decl->isFileVarDecl() && NamingStyles[SK_GlobalConstant].isSet())
377 return SK_GlobalConstant;
379 if (!Type.isNull() && Type.isLocalConstQualified() &&
380 Decl->isStaticLocal() && NamingStyles[SK_StaticConstant].isSet())
381 return SK_StaticConstant;
383 if (!Type.isNull() && Type.isLocalConstQualified() &&
384 Decl->isLocalVarDecl() && NamingStyles[SK_LocalConstant].isSet())
385 return SK_LocalConstant;
387 if (!Type.isNull() && Type.isLocalConstQualified() &&
388 Decl->isFunctionOrMethodVarDecl() &&
389 NamingStyles[SK_LocalConstant].isSet())
390 return SK_LocalConstant;
392 if (!Type.isNull() && Type.isLocalConstQualified() &&
393 NamingStyles[SK_Constant].isSet())
396 if (Decl->isStaticDataMember() && NamingStyles[SK_ClassMember].isSet())
397 return SK_ClassMember;
399 if (Decl->isFileVarDecl() && NamingStyles[SK_GlobalVariable].isSet())
400 return SK_GlobalVariable;
402 if (Decl->isStaticLocal() && NamingStyles[SK_StaticVariable].isSet())
403 return SK_StaticVariable;
405 if (Decl->isLocalVarDecl() && NamingStyles[SK_LocalVariable].isSet())
406 return SK_LocalVariable;
408 if (Decl->isFunctionOrMethodVarDecl() &&
409 NamingStyles[SK_LocalVariable].isSet())
410 return SK_LocalVariable;
412 if (NamingStyles[SK_Variable].isSet())
418 if (
const auto *Decl = dyn_cast<CXXMethodDecl>(D)) {
419 if (Decl->isMain() || !Decl->isUserProvided() ||
420 Decl->isUsualDeallocationFunction() ||
421 Decl->isCopyAssignmentOperator() || Decl->isMoveAssignmentOperator() ||
422 Decl->size_overridden_methods() > 0)
425 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprMethod].isSet())
426 return SK_ConstexprMethod;
428 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
429 return SK_ConstexprFunction;
431 if (Decl->isStatic() && NamingStyles[SK_ClassMethod].isSet())
432 return SK_ClassMethod;
434 if (Decl->isVirtual() && NamingStyles[SK_VirtualMethod].isSet())
435 return SK_VirtualMethod;
437 if (Decl->getAccess() == AS_private &&
438 NamingStyles[SK_PrivateMethod].isSet())
439 return SK_PrivateMethod;
441 if (Decl->getAccess() == AS_protected &&
442 NamingStyles[SK_ProtectedMethod].isSet())
443 return SK_ProtectedMethod;
445 if (Decl->getAccess() == AS_public && NamingStyles[SK_PublicMethod].isSet())
446 return SK_PublicMethod;
448 if (NamingStyles[SK_Method].isSet())
451 if (NamingStyles[SK_Function].isSet())
457 if (
const auto *Decl = dyn_cast<FunctionDecl>(D)) {
461 if (Decl->isConstexpr() && NamingStyles[SK_ConstexprFunction].isSet())
462 return SK_ConstexprFunction;
464 if (Decl->isGlobal() && NamingStyles[SK_GlobalFunction].isSet())
465 return SK_GlobalFunction;
467 if (NamingStyles[SK_Function].isSet())
471 if (isa<TemplateTypeParmDecl>(D)) {
472 if (NamingStyles[SK_TypeTemplateParameter].isSet())
473 return SK_TypeTemplateParameter;
475 if (NamingStyles[SK_TemplateParameter].isSet())
476 return SK_TemplateParameter;
481 if (isa<NonTypeTemplateParmDecl>(D)) {
482 if (NamingStyles[SK_ValueTemplateParameter].isSet())
483 return SK_ValueTemplateParameter;
485 if (NamingStyles[SK_TemplateParameter].isSet())
486 return SK_TemplateParameter;
491 if (isa<TemplateTemplateParmDecl>(D)) {
492 if (NamingStyles[SK_TemplateTemplateParameter].isSet())
493 return SK_TemplateTemplateParameter;
495 if (NamingStyles[SK_TemplateParameter].isSet())
496 return SK_TemplateParameter;
505 const NamedDecl *Decl, SourceRange
Range,
506 const SourceManager *
SM) {
508 if (Range.getBegin().isInvalid() || Range.getEnd().isInvalid())
513 auto &Failure = Failures[Decl];
514 if (!Failure.RawUsageLocs.insert(Range.getBegin().getRawEncoding()).second)
517 Failure.ShouldFix = Failure.ShouldFix && !Range.getBegin().isMacroID() &&
518 !Range.getEnd().isMacroID();
522 if (
const auto *Decl =
523 Result.Nodes.getNodeAs<CXXConstructorDecl>(
"classRef")) {
524 if (Decl->isImplicit())
527 addUsage(NamingCheckFailures, Decl->getParent(),
528 Decl->getNameInfo().getSourceRange(), Result.SourceManager);
532 if (
const auto *Decl =
533 Result.Nodes.getNodeAs<CXXDestructorDecl>(
"classRef")) {
534 if (Decl->isImplicit())
537 SourceRange
Range = Decl->getNameInfo().getSourceRange();
538 if (Range.getBegin().isInvalid())
542 Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
545 Result.SourceManager);
549 if (
const auto *
Loc = Result.Nodes.getNodeAs<TypeLoc>(
"typeLoc")) {
550 NamedDecl *Decl =
nullptr;
551 if (
const auto &Ref =
Loc->getAs<TagTypeLoc>()) {
552 Decl = Ref.getDecl();
553 }
else if (
const auto &Ref =
Loc->getAs<InjectedClassNameTypeLoc>()) {
554 Decl = Ref.getDecl();
555 }
else if (
const auto &Ref =
Loc->getAs<UnresolvedUsingTypeLoc>()) {
556 Decl = Ref.getDecl();
557 }
else if (
const auto &Ref =
Loc->getAs<TemplateTypeParmTypeLoc>()) {
558 Decl = Ref.getDecl();
562 addUsage(NamingCheckFailures, Decl,
Loc->getSourceRange(),
563 Result.SourceManager);
567 if (
const auto &Ref =
Loc->getAs<TemplateSpecializationTypeLoc>()) {
569 Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();
571 SourceRange
Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
572 if (
const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
573 addUsage(NamingCheckFailures, ClassDecl->getTemplatedDecl(),
Range,
574 Result.SourceManager);
579 if (
const auto &Ref =
580 Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
581 addUsage(NamingCheckFailures, Ref.getTypePtr()->getAsTagDecl(),
582 Loc->getSourceRange(), Result.SourceManager);
587 if (
const auto *
Loc =
588 Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
"nestedNameLoc")) {
589 if (NestedNameSpecifier *Spec =
Loc->getNestedNameSpecifier()) {
590 if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
591 addUsage(NamingCheckFailures, Decl,
Loc->getLocalSourceRange(),
592 Result.SourceManager);
598 if (
const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>(
"using")) {
599 for (
const auto &Shadow : Decl->shadows()) {
600 addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
601 Decl->getNameInfo().getSourceRange(), Result.SourceManager);
606 if (
const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>(
"declRef")) {
607 SourceRange
Range = DeclRef->getNameInfo().getSourceRange();
609 Result.SourceManager);
613 if (
const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>(
"decl")) {
614 if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
619 if (isa<ClassTemplateSpecializationDecl>(Decl))
627 StringRef
Name = Decl->getName();
632 std::replace(KindName.begin(), KindName.end(),
'_',
' ');
635 if (StringRef(Fixup).equals(Name)) {
636 if (!IgnoreFailedSplit) {
637 DEBUG(llvm::dbgs() << Decl->getLocStart().printToString(
638 *Result.SourceManager)
639 << format(
": unable to split words for %s '%s'\n",
640 KindName.c_str(),
Name));
645 DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
648 Failure.
Fixup = std::move(Fixup);
649 Failure.
KindName = std::move(KindName);
650 addUsage(NamingCheckFailures, Decl, Range, Result.SourceManager);
656 for (
const auto &Pair : NamingCheckFailures) {
657 const NamedDecl &Decl = *Pair.first;
664 auto Diag =
diag(Decl.getLocation(),
"invalid case style for %0 '%1'")
665 << Failure.
KindName << Decl.getName();
678 Diag << FixItHint::CreateReplacement(
679 SourceRange(SourceLocation::getFromRawEncoding(
Loc)),
SourceLocation Loc
'#' location in the include directive
static StyleKind findStyleKind(const NamedDecl *D, const std::vector< IdentifierNamingCheck::NamingStyle > &NamingStyles)
std::string get(StringRef LocalName, std::string Default) const
Read a named option from the Context.
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.
Base class for all clang-tidy checks.
static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures, const NamedDecl *Decl, SourceRange Range, const SourceManager *SM)
static std::string fixupWithStyle(StringRef Name, IdentifierNamingCheck::NamingStyle Style)
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 ASTMatchers 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)
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.
llvm::DenseMap< const NamedDecl *, NamingCheckFailure > NamingCheckFailureMap
bool ShouldFix
Whether the failure should be fixed or not.