This is an archive of the discontinued LLVM Phabricator instance.

Differential D36154

Adapt clang-tidy checks to changing semantics of hasDeclaration.
ClosedPublic

Authored by klimek on Aug 1 2017, 8:32 AM.

Details

Reviewers
bkramer
Commits
rG7b9c117b82eb: Adapt clang-tidy checks to changing semantics of hasDeclaration.
rCTE309810: Adapt clang-tidy checks to changing semantics of hasDeclaration.
rL309810: Adapt clang-tidy checks to changing semantics of hasDeclaration.

Diff Detail

Event Timeline

klimek created this revision.Aug 1 2017, 8:32 AM
Herald added a subscriber: JDevlieghere. · View Herald TranscriptAug 1 2017, 8:32 AM
bkramer added inline comments.Aug 1 2017, 9:10 AM
clang-tidy/google/StringReferenceMemberCheck.cpp
31

I think this should be namedDecl too.

klimek updated this revision to Diff 109287.Aug 2 2017, 12:31 AM
klimek marked an inline comment as done.

Address review comment.

klimek added a comment.Aug 2 2017, 12:57 AM

ptal

bkramer accepted this revision.Aug 2 2017, 1:21 AM

looks good

This revision is now accepted and ready to land.Aug 2 2017, 1:21 AM
Closed by commit rL309810: Adapt clang-tidy checks to changing semantics of hasDeclaration. (authored by klimek). · Explain WhyAug 2 2017, 6:14 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 109128

clang-tidy/google/StringReferenceMemberCheck.cpp

Show All 21 Lines
void StringReferenceMemberCheck::registerMatchers( void StringReferenceMemberCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not // Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign. // provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
// Look for const references to std::string or ::string. // Look for const references to std::string or ::string.
auto String = anyOf(recordDecl(hasName("::std::basic_string")), auto String = anyOf(namedDecl(hasName("::std::string")),
recordDecl(hasName("::string"))); recordDecl(hasName("::string")));
bkramerUnsubmitted
Done
ReplyInline Actions

I think this should be namedDecl too.

bkramer: I think this should be namedDecl too.
auto ConstString = qualType(isConstQualified(), hasDeclaration(String)); auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
// Ignore members in template instantiations. // Ignore members in template instantiations.
Finder->addMatcher( Finder->addMatcher(
fieldDecl(hasType(references(ConstString)), unless(isInstantiated())) fieldDecl(hasType(references(ConstString)), unless(isInstantiated()))
.bind("member"), .bind("member"),
this); this);
} }
Show All 12 Lines

clang-tidy/misc/DanglingHandleCheck.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesast_matchers::internal::BindableMatcher<Stmt> makeContainerMatcher(
// the bug. A little more complicated than what we have now. // the bug. A little more complicated than what we have now.
return callExpr( return callExpr(
hasAnyArgument( hasAnyArgument(
ignoringParenImpCasts(handleFromTemporaryValue(IsAHandle))), ignoringParenImpCasts(handleFromTemporaryValue(IsAHandle))),
anyOf( anyOf(
// For sequences: assign, push_back, resize. // For sequences: assign, push_back, resize.
cxxMemberCallExpr( cxxMemberCallExpr(
callee(functionDecl(hasAnyName("assign", "push_back", "resize"))), callee(functionDecl(hasAnyName("assign", "push_back", "resize"))),
on(expr(hasType(recordDecl(isASequence()))))), on(expr(hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(recordDecl(isASequence())))))))),
// For sequences and sets: insert. // For sequences and sets: insert.
cxxMemberCallExpr( cxxMemberCallExpr(callee(functionDecl(hasName("insert"))),
callee(functionDecl(hasName("insert"))), on(expr(hasType(hasUnqualifiedDesugaredType(
on(expr(hasType(recordDecl(anyOf(isASequence(), isASet())))))), recordType(hasDeclaration(recordDecl(
anyOf(isASequence(), isASet()))))))))),
// For maps: operator[]. // For maps: operator[].
cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(isAMap()))), cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(isAMap()))),
hasOverloadedOperatorName("[]")))); hasOverloadedOperatorName("[]"))));
} }
} // anonymous namespace } // anonymous namespace
DanglingHandleCheck::DanglingHandleCheck(StringRef Name, DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
Show All 11 Lines Options.store(Opts, "HandleClasses",
utils::options::serializeStringList(HandleClasses)); utils::options::serializeStringList(HandleClasses));
} }
void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) { void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {
const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle); const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle);
// Find 'Handle foo(ReturnsAValue());' // Find 'Handle foo(ReturnsAValue());'
Finder->addMatcher( Finder->addMatcher(
varDecl(hasType(cxxRecordDecl(IsAHandle)), varDecl(hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
hasInitializer( hasInitializer(
exprWithCleanups(has(ignoringParenImpCasts(ConvertedHandle))) exprWithCleanups(has(ignoringParenImpCasts(ConvertedHandle)))
.bind("bad_stmt"))), .bind("bad_stmt"))),
this); this);
// Find 'Handle foo = ReturnsAValue();' // Find 'Handle foo = ReturnsAValue();'
Finder->addMatcher( Finder->addMatcher(
varDecl( varDecl(
hasType(cxxRecordDecl(IsAHandle)), unless(parmVarDecl()), hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
unless(parmVarDecl()),
hasInitializer(exprWithCleanups(has(ignoringParenImpCasts(handleFrom( hasInitializer(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
IsAHandle, ConvertedHandle)))) IsAHandle, ConvertedHandle))))
.bind("bad_stmt"))), .bind("bad_stmt"))),
this); this);
// Find 'foo = ReturnsAValue(); // foo is Handle' // Find 'foo = ReturnsAValue(); // foo is Handle'
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))), cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))),
hasOverloadedOperatorName("="), hasOverloadedOperatorName("="),
Show All 10 Linesvoid DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
returnStmt( returnStmt(
// The AST contains two constructor calls: // The AST contains two constructor calls:
// 1. Value to Handle conversion. // 1. Value to Handle conversion.
// 2. Handle copy construction. // 2. Handle copy construction.
// We have to match both. // We have to match both.
has(ignoringImplicit(handleFrom( has(ignoringImplicit(handleFrom(
IsAHandle, IsAHandle,
handleFrom(IsAHandle, declRefExpr(to(varDecl( handleFrom(IsAHandle,
declRefExpr(to(varDecl(
// Is function scope ... // Is function scope ...
hasAutomaticStorageDuration(), hasAutomaticStorageDuration(),
// ... and it is a local array or Value. // ... and it is a local array or Value.
anyOf(hasType(arrayType()), anyOf(hasType(arrayType()),
hasType(recordDecl( hasType(hasUnqualifiedDesugaredType(
unless(IsAHandle))))))))))), recordType(hasDeclaration(recordDecl(
unless(IsAHandle)))))))))))))),
// Temporary fix for false positives inside lambdas. // Temporary fix for false positives inside lambdas.
unless(hasAncestor(lambdaExpr()))) unless(hasAncestor(lambdaExpr())))
.bind("bad_stmt"), .bind("bad_stmt"),
this); this);
// Return a temporary. // Return a temporary.
Finder->addMatcher( Finder->addMatcher(
returnStmt( returnStmt(
Show All 21 Lines

clang-tidy/misc/InaccurateEraseCheck.cpp

Show All 33 Lines const auto EndCall =
hasArgument( hasArgument(
1, 1,
anyOf(cxxConstructExpr(has(ignoringImplicit( anyOf(cxxConstructExpr(has(ignoringImplicit(
cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end")))) cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
.bind("end")))), .bind("end")))),
anything()))) anything())))
.bind("alg"); .bind("alg");
const auto DeclInStd = decl(isInStdNamespace()); const auto DeclInStd = type(hasUnqualifiedDesugaredType(
tagType(hasDeclaration(decl(isInStdNamespace())))));
Finder->addMatcher( Finder->addMatcher(
cxxMemberCallExpr( cxxMemberCallExpr(
on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))), on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),
callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1), callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
hasArgument(0, has(ignoringImplicit( hasArgument(0, has(ignoringImplicit(
anyOf(EndCall, has(ignoringImplicit(EndCall)))))), anyOf(EndCall, has(ignoringImplicit(EndCall)))))),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("erase"), .bind("erase"),
Show All 30 Lines

clang-tidy/misc/UseAfterMoveCheck.cpp

Show First 20 Lines • Show All 265 Lines • ▼ Show 20 Lines
void UseAfterMoveFinder::getReinits( void UseAfterMoveFinder::getReinits(
const CFGBlock *Block, const ValueDecl *MovedVariable, const CFGBlock *Block, const ValueDecl *MovedVariable,
llvm::SmallPtrSetImpl<const Stmt *> *Stmts, llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) { llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) {
auto DeclRefMatcher = auto DeclRefMatcher =
declRefExpr(hasDeclaration(equalsNode(MovedVariable))).bind("declref"); declRefExpr(hasDeclaration(equalsNode(MovedVariable))).bind("declref");
auto StandardContainerTypeMatcher = hasType(cxxRecordDecl( auto StandardContainerTypeMatcher = hasType(hasUnqualifiedDesugaredType(
hasAnyName("::std::basic_string", "::std::vector", "::std::deque", recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
"::std::forward_list", "::std::list", "::std::set", "::std::basic_string", "::std::vector", "::std::deque",
"::std::map", "::std::multiset", "::std::multimap", "::std::forward_list", "::std::list", "::std::set", "::std::map",
"::std::unordered_set", "::std::unordered_map", "::std::multiset", "::std::multimap", "::std::unordered_set",
"::std::unordered_multiset", "::std::unordered_multimap"))); "::std::unordered_map", "::std::unordered_multiset",
"::std::unordered_multimap"))))));
auto StandardSmartPointerTypeMatcher = hasType(cxxRecordDecl(
hasAnyName("::std::unique_ptr", "::std::shared_ptr", "::std::weak_ptr"))); auto StandardSmartPointerTypeMatcher = hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
"::std::unique_ptr", "::std::shared_ptr", "::std::weak_ptr"))))));
// Matches different types of reinitialization. // Matches different types of reinitialization.
auto ReinitMatcher = auto ReinitMatcher =
stmt(anyOf( stmt(anyOf(
// Assignment. In addition to the overloaded assignment operator, // Assignment. In addition to the overloaded assignment operator,
// test for built-in assignment as well, since template functions // test for built-in assignment as well, since template functions
// may be instantiated to use std::move() on built-in types. // may be instantiated to use std::move() on built-in types.
binaryOperator(hasOperatorName("="), hasLHS(DeclRefMatcher)), binaryOperator(hasOperatorName("="), hasLHS(DeclRefMatcher)),
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

clang-tidy/modernize/LoopConvertCheck.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines auto OverloadedNEQMatcher = ignoringImplicit(
cxxOperatorCallExpr(hasOverloadedOperatorName("!="), argumentCountIs(2), cxxOperatorCallExpr(hasOverloadedOperatorName("!="), argumentCountIs(2),
hasArgument(0, IteratorComparisonMatcher), hasArgument(0, IteratorComparisonMatcher),
hasArgument(1, IteratorBoundMatcher))); hasArgument(1, IteratorBoundMatcher)));
// This matcher tests that a declaration is a CXXRecordDecl that has an // This matcher tests that a declaration is a CXXRecordDecl that has an
// overloaded operator*(). If the operator*() returns by value instead of by // overloaded operator*(). If the operator*() returns by value instead of by
// reference then the return type is tagged with DerefByValueResultName. // reference then the return type is tagged with DerefByValueResultName.
internal::Matcher<VarDecl> TestDerefReturnsByValue = internal::Matcher<VarDecl> TestDerefReturnsByValue =
hasType(cxxRecordDecl(hasMethod(allOf( hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(hasMethod(allOf(
hasOverloadedOperatorName("*"), hasOverloadedOperatorName("*"),
anyOf( anyOf(
// Tag the return type if it's by value. // Tag the return type if it's by value.
returns(qualType(unless(hasCanonicalType(referenceType()))) returns(qualType(unless(hasCanonicalType(referenceType())))
.bind(DerefByValueResultName)), .bind(DerefByValueResultName)),
returns( returns(
// Skip loops where the iterator's operator* returns an // Skip loops where the iterator's operator* returns an
// rvalue reference. This is just weird. // rvalue reference. This is just weird.
qualType(unless(hasCanonicalType(rValueReferenceType()))) qualType(unless(hasCanonicalType(rValueReferenceType())))
.bind(DerefByRefResultName))))))); .bind(DerefByRefResultName))))))))));
return forStmt( return forStmt(
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
hasLoopInit(anyOf(declStmt(declCountIs(2), hasLoopInit(anyOf(declStmt(declCountIs(2),
containsDeclaration(0, InitDeclMatcher), containsDeclaration(0, InitDeclMatcher),
containsDeclaration(1, EndDeclMatcher)), containsDeclaration(1, EndDeclMatcher)),
declStmt(hasSingleDecl(InitDeclMatcher)))), declStmt(hasSingleDecl(InitDeclMatcher)))),
hasCondition( hasCondition(
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 LinesStatementMatcher makePseudoArrayLoopMatcher() {
// return type of begin/end is an iterator that dereferences to the same as // return type of begin/end is an iterator that dereferences to the same as
// what operator[] or at() returns. Such a test isn't likely to fail except // what operator[] or at() returns. Such a test isn't likely to fail except
// for pathological cases. // for pathological cases.
// //
// FIXME: Also, a record doesn't necessarily need begin() and end(). Free // FIXME: Also, a record doesn't necessarily need begin() and end(). Free
// functions called begin() and end() taking the container as an argument // functions called begin() and end() taking the container as an argument
// are also allowed. // are also allowed.
TypeMatcher RecordWithBeginEnd = qualType(anyOf( TypeMatcher RecordWithBeginEnd = qualType(anyOf(
qualType(isConstQualified(), qualType(
hasDeclaration(cxxRecordDecl( isConstQualified(),
hasUnqualifiedDesugaredType(recordType(hasDeclaration(cxxRecordDecl(
hasMethod(cxxMethodDecl(hasName("begin"), isConst())), hasMethod(cxxMethodDecl(hasName("begin"), isConst())),
hasMethod(cxxMethodDecl(hasName("end"), hasMethod(cxxMethodDecl(hasName("end"),
isConst())))) // hasDeclaration isConst())))) // hasDeclaration
), // qualType ))), // qualType
qualType( qualType(unless(isConstQualified()),
unless(isConstQualified()), hasUnqualifiedDesugaredType(recordType(hasDeclaration(
hasDeclaration(cxxRecordDecl(hasMethod(hasName("begin")), cxxRecordDecl(hasMethod(hasName("begin")),
hasMethod(hasName("end"))))) // qualType hasMethod(hasName("end"))))))) // qualType
)); ));
StatementMatcher SizeCallMatcher = cxxMemberCallExpr( StatementMatcher SizeCallMatcher = cxxMemberCallExpr(
argumentCountIs(0), argumentCountIs(0),
callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))), callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
on(anyOf(hasType(pointsTo(RecordWithBeginEnd)), on(anyOf(hasType(pointsTo(RecordWithBeginEnd)),
hasType(RecordWithBeginEnd)))); hasType(RecordWithBeginEnd))));
▲ Show 20 Lines • Show All 656 Lines • Show Last 20 Lines

clang-tidy/modernize/MakeSharedCheck.cpp

Show All 14 Lines
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context) MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
: MakeSmartPtrCheck(Name, Context, "std::make_shared") {} : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}
MakeSharedCheck::SmartPtrTypeMatcher MakeSharedCheck::SmartPtrTypeMatcher
MakeSharedCheck::getSmartPointerTypeMatcher() const { MakeSharedCheck::getSmartPointerTypeMatcher() const {
return qualType(hasDeclaration(classTemplateSpecializationDecl( return qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::shared_ptr"), templateArgumentCountIs(1), hasName("::std::shared_ptr"), templateArgumentCountIs(1),
hasTemplateArgument( hasTemplateArgument(0, templateArgument(refersToType(
0, templateArgument(refersToType(qualType().bind(PointerType))))))); qualType().bind(PointerType)))))))));
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/MakeUniqueCheck.cpp

Show All 15 Lines
namespace modernize { namespace modernize {
MakeUniqueCheck::MakeUniqueCheck(StringRef Name, MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
clang::tidy::ClangTidyContext *Context) clang::tidy::ClangTidyContext *Context)
: MakeSmartPtrCheck(Name, Context, "std::make_unique") {} : MakeSmartPtrCheck(Name, Context, "std::make_unique") {}
MakeUniqueCheck::SmartPtrTypeMatcher MakeUniqueCheck::SmartPtrTypeMatcher
MakeUniqueCheck::getSmartPointerTypeMatcher() const { MakeUniqueCheck::getSmartPointerTypeMatcher() const {
return qualType(hasDeclaration(classTemplateSpecializationDecl( return qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::unique_ptr"), templateArgumentCountIs(2), hasName("::std::unique_ptr"), templateArgumentCountIs(2),
hasTemplateArgument( hasTemplateArgument(
0, templateArgument(refersToType(qualType().bind(PointerType)))), 0, templateArgument(refersToType(qualType().bind(PointerType)))),
hasTemplateArgument( hasTemplateArgument(
1, 1, templateArgument(refersToType(
templateArgument(refersToType(
qualType(hasDeclaration(classTemplateSpecializationDecl( qualType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::default_delete"), templateArgumentCountIs(1), hasName("::std::default_delete"),
templateArgumentCountIs(1),
hasTemplateArgument( hasTemplateArgument(
0, templateArgument(refersToType( 0, templateArgument(refersToType(qualType(
qualType(equalsBoundNode(PointerType)))))))))))))); equalsBoundNode(PointerType))))))))))))))));
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/FasterStringFindCheck.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines const auto StringFindFunctions =
hasAnyName("find", "rfind", "find_first_of", "find_first_not_of", hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",
"find_last_of", "find_last_not_of"); "find_last_of", "find_last_not_of");
Finder->addMatcher( Finder->addMatcher(
cxxMemberCallExpr( cxxMemberCallExpr(
callee(functionDecl(StringFindFunctions).bind("func")), callee(functionDecl(StringFindFunctions).bind("func")),
anyOf(argumentCountIs(1), argumentCountIs(2)), anyOf(argumentCountIs(1), argumentCountIs(2)),
hasArgument(0, SingleChar), hasArgument(0, SingleChar),
on(expr(hasType(recordDecl(hasAnyName(SmallVector<StringRef, 4>( on(expr(
StringLikeClasses.begin(), StringLikeClasses.end())))), hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
recordDecl(hasAnyName(SmallVector<StringRef, 4>(
StringLikeClasses.begin(), StringLikeClasses.end()))))))),
unless(hasSubstitutedType())))), unless(hasSubstitutedType())))),
this); this);
} }
void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) { void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal"); const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
auto Replacement = MakeCharacterLiteral(Literal); auto Replacement = MakeCharacterLiteral(Literal);
Show All 15 Lines

clang-tidy/performance/InefficientStringConcatenationCheck.cpp

Show All 27 Lines : ClangTidyCheck(Name, Context),
StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {} StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}
void InefficientStringConcatenationCheck::registerMatchers( void InefficientStringConcatenationCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
const auto BasicStringType = const auto BasicStringType =
hasType(cxxRecordDecl(hasName("::std::basic_string"))); hasType(qualType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));
const auto BasicStringPlusOperator = cxxOperatorCallExpr( const auto BasicStringPlusOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("+"), hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType)))); hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))));
const auto PlusOperator = const auto PlusOperator =
cxxOperatorCallExpr( cxxOperatorCallExpr(
hasOverloadedOperatorName("+"), hasOverloadedOperatorName("+"),
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

clang-tidy/readability/ContainerSizeEmptyCheck.cpp

Show All 26 LinesContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) { void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not // Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign. // provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
const auto ValidContainer = cxxRecordDecl(isSameOrDerivedFrom( const auto ValidContainer = qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(isSameOrDerivedFrom(
namedDecl( namedDecl(
has(cxxMethodDecl( has(cxxMethodDecl(
isConst(), parameterCountIs(0), isPublic(), hasName("size"), isConst(), parameterCountIs(0), isPublic(),
hasName("size"),
returns(qualType(isInteger(), unless(booleanType())))) returns(qualType(isInteger(), unless(booleanType()))))
.bind("size")), .bind("size")),
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(), has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("empty"), returns(booleanType())) hasName("empty"), returns(booleanType()))
.bind("empty"))) .bind("empty")))
.bind("container"))); .bind("container")))))));
const auto WrongUse = anyOf( const auto WrongUse = anyOf(
hasParent(binaryOperator( hasParent(binaryOperator(
matchers::isComparisonOperator(), matchers::isComparisonOperator(),
hasEitherOperand(ignoringImpCasts(anyOf( hasEitherOperand(ignoringImpCasts(anyOf(
integerLiteral(equals(1)), integerLiteral(equals(0)))))) integerLiteral(equals(1)), integerLiteral(equals(0))))))
.bind("SizeBinaryOp")), .bind("SizeBinaryOp")),
hasParent(implicitCastExpr( hasParent(implicitCastExpr(
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

clang-tidy/readability/RedundantStringCStrCheck.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
void RedundantStringCStrCheck::registerMatchers( void RedundantStringCStrCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not // Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign. // provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
// Match expressions of type 'string' or 'string*'. // Match expressions of type 'string' or 'string*'.
const auto StringDecl = cxxRecordDecl(hasName("::std::basic_string")); const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
const auto StringExpr = const auto StringExpr =
expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl))))); expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
// Match string constructor. // Match string constructor.
const auto StringConstructorExpr = expr(anyOf( const auto StringConstructorExpr = expr(anyOf(
cxxConstructExpr(argumentCountIs(1), cxxConstructExpr(argumentCountIs(1),
hasDeclaration(cxxMethodDecl(hasName("basic_string")))), hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
cxxConstructExpr( cxxConstructExpr(
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

clang-tidy/readability/RedundantStringInitCheck.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines const auto EmptyStringCtorExprWithTemporaries =
hasArgument(0, ignoringImplicit(EmptyStringCtorExpr))); hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)));
// Match a variable declaration with an empty string literal as initializer. // Match a variable declaration with an empty string literal as initializer.
// Examples: // Examples:
// string foo = ""; // string foo = "";
// string bar(""); // string bar("");
Finder->addMatcher( Finder->addMatcher(
namedDecl( namedDecl(
varDecl(hasType(cxxRecordDecl(hasName("basic_string"))), varDecl(hasType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("basic_string")))))),
hasInitializer(expr(ignoringImplicit(anyOf( hasInitializer(expr(ignoringImplicit(anyOf(
EmptyStringCtorExpr, EmptyStringCtorExpr,
EmptyStringCtorExprWithTemporaries))) EmptyStringCtorExprWithTemporaries)))
.bind("expr"))), .bind("expr"))),
unless(parmVarDecl())) unless(parmVarDecl()))
.bind("decl"), .bind("decl"),
this); this);
} }
Show All 12 Lines

include-fixer/find-all-symbols/FindAllSymbols.cpp

Show First 20 Lines • Show All 224 Lines • ▼ Show 20 Lines MatchFinder->addMatcher(
loc(typedefType(hasDeclaration(Typedefs.bind("use"))))), loc(typedefType(hasDeclaration(Typedefs.bind("use"))))),
this); this);
// Uses of class templates: // Uses of class templates:
// The typeLoc names the templateSpecializationType. Its declaration is the // The typeLoc names the templateSpecializationType. Its declaration is the
// ClassTemplateDecl, which contains the CXXRecordDecl we want. // ClassTemplateDecl, which contains the CXXRecordDecl we want.
MatchFinder->addMatcher( MatchFinder->addMatcher(
typeLoc(isExpansionInMainFile(), typeLoc(isExpansionInMainFile(),
loc(templateSpecializationType(hasDeclaration( loc(templateSpecializationType(hasDeclaration(
classTemplateDecl(has(CXXRecords.bind("use"))))))), classTemplateSpecializationDecl(hasSpecializedTemplate(
classTemplateDecl(has(CXXRecords.bind("use"))))))))),
this); this);
} }
void FindAllSymbols::run(const MatchFinder::MatchResult &Result) { void FindAllSymbols::run(const MatchFinder::MatchResult &Result) {
// Ignore Results in failing TUs. // Ignore Results in failing TUs.
if (Result.Context->getDiagnostics().hasErrorOccurred()) { if (Result.Context->getDiagnostics().hasErrorOccurred()) {
return; return;
} }
Show All 27 Lines