This is an archive of the discontinued LLVM Phabricator instance.

Differential D72530

Set traversal explicitly where needed in clang-tidy
ClosedPublic

Authored by steveire on Jan 10 2020, 11:49 AM.

Details

Reviewers
aaron.ballman
Commits
rGa72307c3a6f1: Set traversal explicitly where needed in clang-tidy

Diff Detail

Event Timeline

steveire created this revision.Jan 10 2020, 11:49 AM
Herald added a project: Restricted Project. · View Herald TranscriptJan 10 2020, 11:49 AM
Herald added subscribers: cfe-commits, arphaman, kbarton, nemanjai. · View Herald Transcript
Harbormaster completed remote builds in B43711: Diff 237406.Jan 10 2020, 11:56 AM
Herald added a subscriber: • wuzish. · View Herald TranscriptJan 10 2020, 11:56 AM
Herald added a subscriber: • wuzish. · View Herald Transcript
Herald added a subscriber: • wuzish. · View Herald Transcript
steveire updated this revision to Diff 237417.Jan 10 2020, 12:38 PM

Fix case

Harbormaster completed remote builds in B43718: Diff 237417.Jan 10 2020, 12:42 PM
steveire updated this revision to Diff 240816.Jan 28 2020, 2:59 AM

Rebase

Harbormaster completed remote builds in B45105: Diff 240816.Jan 28 2020, 3:00 AM
steveire updated this revision to Diff 263538.May 12 2020, 3:31 PM

Update

Harbormaster completed remote builds in B56494: Diff 263538.May 12 2020, 4:43 PM
aaron.ballman added a comment.May 15 2020, 6:56 AM

The changes here look reasonable, but can some of this code be simplified to use the default behavior and less complex matchers that don't have to carefully ignore implicit nodes? This would demonstrate that the feature really is an improvement over the status quo and would also exercise more test code with the new defaults demonstrating equivalence. I'm not envisioning anything onerous, more just wondering if you think there is some low-hanging fruit that could be picked rather than converting everything to AsIs.

steveire added a comment.EditedMay 17 2020, 3:43 AM
In D72530#2038561, @aaron.ballman wrote:

The changes here look reasonable, but can some of this code be simplified to use the default behavior and less complex matchers that don't have to carefully ignore implicit nodes? This would demonstrate that the feature really is an improvement over the status quo and would also exercise more test code with the new defaults demonstrating equivalence. I'm not envisioning anything onerous, more just wondering if you think there is some low-hanging fruit that could be picked rather than converting everything to AsIs.

After changing the default there will be opportunities for that as a follow-up, yes. But this patch is ordered before changing the default. The change you describe is a follow-up. What I am doing with that ordering is called "non-atomic refactoring".

Here's an example of such a future change: https://gist.github.com/steveire/32fbf457377bc6c57bd3906cc9c8fb9c

aaron.ballman accepted this revision.May 17 2020, 8:03 AM
In D72530#2040521, @steveire wrote:
In D72530#2038561, @aaron.ballman wrote:

The changes here look reasonable, but can some of this code be simplified to use the default behavior and less complex matchers that don't have to carefully ignore implicit nodes? This would demonstrate that the feature really is an improvement over the status quo and would also exercise more test code with the new defaults demonstrating equivalence. I'm not envisioning anything onerous, more just wondering if you think there is some low-hanging fruit that could be picked rather than converting everything to AsIs.

After changing the default there will be opportunities for that as a follow-up, yes. But this patch is ordered before changing the default. The change you describe is a follow-up. What I am doing with that ordering is called "non-atomic refactoring".

Here's an example of such a future change: https://gist.github.com/steveire/32fbf457377bc6c57bd3906cc9c8fb9c

Thanks for the example, that's the kind of improvement I was hoping to see. Given that one of the claims in the RFC is that this makes writing matchers easier, I think it's reasonable to expect a patch showing that it actually does make writing those matchers more simple. I suppose I'm fine if it's a separate patch from this one, but I'd slightly prefer it was done in this patch so that we don't churn the code unnecessarily (and it makes it easier to do the comparison between the original code and the code for simplified matcher, as your changes here are adding interim complexity). Regardless, I'd like to see a patch that shows some of these simplifications as part of this patch set (if not this specific review).

This revision is now accepted and ready to land.May 17 2020, 8:03 AM
Closed by commit rGa72307c3a6f1: Set traversal explicitly where needed in clang-tidy (authored by • stephenkelly). · Explain WhyMay 21 2020, 3:12 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
abseil/
4 lines
9 lines
4 lines
8 lines
5 lines
bugprone/
3 lines
3 lines
16 lines
4 lines
3 lines
3 lines
14 lines
3 lines
3 lines
4 lines
3 lines
4 lines
3 lines
3 lines
15 lines
3 lines
9 lines
cert/
4 lines
4 lines
4 lines
4 lines
cppcoreguidelines/
4 lines
6 lines
46 lines
4 lines
4 lines
fuchsia/
4 lines
llvm/
7 lines
4 lines
misc/
39 lines
modernize/
11 lines
8 lines
3 lines
19 lines
4 lines
4 lines
4 lines
3 lines
7 lines
5 lines
33 lines
5 lines
performance/
7 lines
4 lines
4 lines
9 lines
4 lines
4 lines
12 lines
11 lines
readability/
7 lines
4 lines
11 lines
3 lines
4 lines
5 lines
5 lines
5 lines
16 lines
9 lines
8 lines
9 lines
4 lines
utils/
1 line
zircon/
8 lines

Diff 237406

clang-tools-extra/clang-tidy/abseil/DurationDivisionCheck.cpp

Show All 16 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
void DurationDivisionCheck::registerMatchers(MatchFinder *finder) { void DurationDivisionCheck::registerMatchers(MatchFinder *finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
const auto DurationExpr = const auto DurationExpr =
expr(hasType(cxxRecordDecl(hasName("::absl::Duration")))); expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))));
finder->addMatcher( finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
hasSourceExpression(ignoringParenCasts( hasSourceExpression(ignoringParenCasts(
cxxOperatorCallExpr(hasOverloadedOperatorName("/"), cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
hasArgument(0, DurationExpr), hasArgument(0, DurationExpr),
hasArgument(1, DurationExpr)) hasArgument(1, DurationExpr))
.bind("OpCall"))), .bind("OpCall"))),
hasImplicitDestinationType(qualType(unless(isInteger()))), hasImplicitDestinationType(qualType(unless(isInteger()))),
unless(hasParent(cxxStaticCastExpr())), unless(hasParent(cxxStaticCastExpr())),
unless(hasParent(cStyleCastExpr())), unless(hasParent(cStyleCastExpr())),
unless(isInTemplateInstantiation())), unless(isInTemplateInstantiation()))),
this); this);
} }
void DurationDivisionCheck::check(const MatchFinder::MatchResult &result) { void DurationDivisionCheck::check(const MatchFinder::MatchResult &result) {
const auto *OpCall = result.Nodes.getNodeAs<CXXOperatorCallExpr>("OpCall"); const auto *OpCall = result.Nodes.getNodeAs<CXXOperatorCallExpr>("OpCall");
diag(OpCall->getOperatorLoc(), diag(OpCall->getOperatorLoc(),
"operator/ on absl::Duration objects performs integer division; " "operator/ on absl::Duration objects performs integer division; "
"did you mean to use FDivDuration()?") "did you mean to use FDivDuration()?")
Show All 15 Lines

clang-tools-extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines auto ByAnyCharArg =
expr(has(ignoringElidableConstructorCall( expr(has(ignoringElidableConstructorCall(
ignoringParenCasts(cxxBindTemporaryExpr(has(cxxConstructExpr( ignoringParenCasts(cxxBindTemporaryExpr(has(cxxConstructExpr(
hasType(recordDecl(hasName("::absl::ByAnyChar"))), hasType(recordDecl(hasName("::absl::ByAnyChar"))),
hasArgument(0, StringViewArg)))))))) hasArgument(0, StringViewArg))))))))
.bind("ByAnyChar"); .bind("ByAnyChar");
// Find uses of absl::StrSplit(..., "x") and absl::StrSplit(..., // Find uses of absl::StrSplit(..., "x") and absl::StrSplit(...,
// absl::ByAnyChar("x")) to transform them into absl::StrSplit(..., 'x'). // absl::ByAnyChar("x")) to transform them into absl::StrSplit(..., 'x').
Finder->addMatcher(callExpr(callee(functionDecl(hasName("::absl::StrSplit"))), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
hasArgument(1, anyOf(ByAnyCharArg, SingleChar)), hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("StrSplit"), .bind("StrSplit")),
this); this);
// Find uses of absl::MaxSplits("x", N) and // Find uses of absl::MaxSplits("x", N) and
// absl::MaxSplits(absl::ByAnyChar("x"), N) to transform them into // absl::MaxSplits(absl::ByAnyChar("x"), N) to transform them into
// absl::MaxSplits('x', N). // absl::MaxSplits('x', N).
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr( callExpr(
callee(functionDecl(hasName("::absl::MaxSplits"))), callee(functionDecl(hasName("::absl::MaxSplits"))),
hasArgument(0, anyOf(ByAnyCharArg, ignoringParenCasts(SingleChar))), hasArgument(0, anyOf(ByAnyCharArg, ignoringParenCasts(SingleChar))),
unless(isInTemplateInstantiation())), unless(isInTemplateInstantiation()))),
this); this);
} }
void FasterStrsplitDelimiterCheck::check( void FasterStrsplitDelimiterCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("Literal"); const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("Literal");
if (Literal->getBeginLoc().isMacroID() || Literal->getEndLoc().isMacroID()) if (Literal->getBeginLoc().isMacroID() || Literal->getEndLoc().isMacroID())
Show All 24 Lines

clang-tools-extra/clang-tidy/abseil/RedundantStrcatCallsCheck.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesconst clang::CallExpr* ProcessArgument(const Expr* Arg,
const MatchFinder::MatchResult& Result, const MatchFinder::MatchResult& Result,
StrCatCheckResult* CheckResult) { StrCatCheckResult* CheckResult) {
const auto IsAlphanum = hasDeclaration(cxxMethodDecl(hasName("AlphaNum"))); const auto IsAlphanum = hasDeclaration(cxxMethodDecl(hasName("AlphaNum")));
static const auto* const Strcat = new auto(hasName("::absl::StrCat")); static const auto* const Strcat = new auto(hasName("::absl::StrCat"));
const auto IsStrcat = cxxBindTemporaryExpr( const auto IsStrcat = cxxBindTemporaryExpr(
has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat"))); has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat")));
if (const auto* SubStrcatCall = selectFirst<const CallExpr>( if (const auto* SubStrcatCall = selectFirst<const CallExpr>(
"StrCat", "StrCat",
match(stmt(anyOf( match(stmt(traverse(ast_type_traits::TK_AsIs, anyOf(
cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)), cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)),
IsStrcat)), IsStrcat))),
*Arg->IgnoreParenImpCasts(), *Result.Context))) { *Arg->IgnoreParenImpCasts(), *Result.Context))) {
RemoveCallLeaveArgs(SubStrcatCall, CheckResult); RemoveCallLeaveArgs(SubStrcatCall, CheckResult);
return SubStrcatCall; return SubStrcatCall;
} }
return nullptr; return nullptr;
} }
StrCatCheckResult ProcessCall(const CallExpr* RootCall, bool IsAppend, StrCatCheckResult ProcessCall(const CallExpr* RootCall, bool IsAppend,
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/StrCatAppendCheck.cpp

Show All 39 Lines
// TODO: str += StrCat(...) // TODO: str += StrCat(...)
// str.append(StrCat(...)) // str.append(StrCat(...))
void StrCatAppendCheck::registerMatchers(MatchFinder *Finder) { void StrCatAppendCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
const auto StrCat = functionDecl(hasName("::absl::StrCat")); const auto StrCat = functionDecl(hasName("::absl::StrCat"));
// The arguments of absl::StrCat are implicitly converted to AlphaNum. This // The arguments of absl::StrCat are implicitly converted to AlphaNum. This
// matches to the arguments because of that behavior. // matches to the arguments because of that behavior.
const auto AlphaNum = IgnoringTemporaries(cxxConstructExpr( const auto AlphaNum = IgnoringTemporaries(cxxConstructExpr(
argumentCountIs(1), hasType(cxxRecordDecl(hasName("::absl::AlphaNum"))), argumentCountIs(1), hasType(cxxRecordDecl(hasName("::absl::AlphaNum"))),
hasArgument(0, ignoringImpCasts(declRefExpr(to(equalsBoundNode("LHS")), hasArgument(0, ignoringImpCasts(declRefExpr(to(equalsBoundNode("LHS")),
expr().bind("Arg0")))))); expr().bind("Arg0"))))));
const auto HasAnotherReferenceToLhs = const auto HasAnotherReferenceToLhs =
callExpr(hasAnyArgument(expr(hasDescendant(declRefExpr( callExpr(hasAnyArgument(expr(hasDescendant(declRefExpr(
to(equalsBoundNode("LHS")), unless(equalsBoundNode("Arg0"))))))); to(equalsBoundNode("LHS")), unless(equalsBoundNode("Arg0")))))));
// Now look for calls to operator= with an object on the LHS and a call to // Now look for calls to operator= with an object on the LHS and a call to
// StrCat on the RHS. The first argument of the StrCat call should be the same // StrCat on the RHS. The first argument of the StrCat call should be the same
// as the LHS. Ignore calls from template instantiations. // as the LHS. Ignore calls from template instantiations.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxOperatorCallExpr( cxxOperatorCallExpr(
unless(isInTemplateInstantiation()), hasOverloadedOperatorName("="), unless(isInTemplateInstantiation()), hasOverloadedOperatorName("="),
hasArgument(0, declRefExpr(to(decl().bind("LHS")))), hasArgument(0, declRefExpr(to(decl().bind("LHS")))),
hasArgument(1, IgnoringTemporaries( hasArgument(1, IgnoringTemporaries(
callExpr(callee(StrCat), hasArgument(0, AlphaNum), callExpr(callee(StrCat), hasArgument(0, AlphaNum),
unless(HasAnotherReferenceToLhs)) unless(HasAnotherReferenceToLhs))
.bind("Call")))) .bind("Call"))))
.bind("Op"), .bind("Op")),
this); this);
} }
void StrCatAppendCheck::check(const MatchFinder::MatchResult &Result) { void StrCatAppendCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Op = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("Op"); const auto *Op = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("Op");
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("Call"); const auto *Call = Result.Nodes.getNodeAs<CallExpr>("Call");
assert(Op != nullptr && Call != nullptr && "Matcher does not work as expected"); assert(Op != nullptr && Call != nullptr && "Matcher does not work as expected");
Show All 23 Lines

clang-tools-extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linesvoid UpgradeDurationConversionsCheck::registerMatchers(MatchFinder *Finder) {
// `absl::Nanoseconds(x)` // `absl::Nanoseconds(x)`
// `absl::Microseconds(x)` // `absl::Microseconds(x)`
// `absl::Milliseconds(x)` // `absl::Milliseconds(x)`
// `absl::Seconds(x)` // `absl::Seconds(x)`
// `absl::Minutes(x)` // `absl::Minutes(x)`
// `absl::Hours(x)` // `absl::Hours(x)`
// where `x` is not of a built-in type. // where `x` is not of a built-in type.
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
anyOf(hasCastKind(CK_UserDefinedConversion), anyOf(hasCastKind(CK_UserDefinedConversion),
has(implicitCastExpr(hasCastKind(CK_UserDefinedConversion)))), has(implicitCastExpr(hasCastKind(CK_UserDefinedConversion)))),
hasParent(callExpr( hasParent(callExpr(
callee(functionDecl(DurationFactoryFunction(), callee(functionDecl(DurationFactoryFunction(),
unless(hasParent(functionTemplateDecl())))), unless(hasParent(functionTemplateDecl())))),
hasArgument(0, expr().bind("arg"))))) hasArgument(0, expr().bind("arg")))))
.bind("OuterExpr"), .bind("OuterExpr")),
this); this);
} }
void UpgradeDurationConversionsCheck::check( void UpgradeDurationConversionsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const llvm::StringRef Message = const llvm::StringRef Message =
"implicit conversion to 'int64_t' is deprecated in this context; use an " "implicit conversion to 'int64_t' is deprecated in this context; use an "
"explicit cast instead"; "explicit cast instead";
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg"); const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
SourceLocation Loc = ArgExpr->getBeginLoc(); SourceLocation Loc = ArgExpr->getBeginLoc();
const auto *OuterExpr = Result.Nodes.getNodeAs<Expr>("OuterExpr"); const auto *OuterExpr = Result.Nodes.getNodeAs<Expr>("OuterExpr");
if (!match(isInTemplateInstantiation(), *OuterExpr, *Result.Context) if (!match(isInTemplateInstantiation(), *OuterExpr, *Result.Context)
.empty()) { .empty()) {
if (MatchedTemplateLocations.count(Loc.getRawEncoding()) == 0) { if (MatchedTemplateLocations.count(Loc.getRawEncoding()) == 0) {
Show All 34 Lines

clang-tools-extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
// The options are explained in AssertSideEffectCheck.h. // The options are explained in AssertSideEffectCheck.h.
void AssertSideEffectCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void AssertSideEffectCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "CheckFunctionCalls", CheckFunctionCalls); Options.store(Opts, "CheckFunctionCalls", CheckFunctionCalls);
Options.store(Opts, "AssertMacros", RawAssertList); Options.store(Opts, "AssertMacros", RawAssertList);
} }
void AssertSideEffectCheck::registerMatchers(MatchFinder *Finder) { void AssertSideEffectCheck::registerMatchers(MatchFinder *Finder) {
auto DescendantWithSideEffect = auto DescendantWithSideEffect =
hasDescendant(expr(hasSideEffect(CheckFunctionCalls))); traverse(ast_type_traits::TK_AsIs,
hasDescendant(expr(hasSideEffect(CheckFunctionCalls))));
auto ConditionWithSideEffect = hasCondition(DescendantWithSideEffect); auto ConditionWithSideEffect = hasCondition(DescendantWithSideEffect);
Finder->addMatcher( Finder->addMatcher(
stmt( stmt(
anyOf(conditionalOperator(ConditionWithSideEffect), anyOf(conditionalOperator(ConditionWithSideEffect),
ifStmt(ConditionWithSideEffect), ifStmt(ConditionWithSideEffect),
unaryOperator(hasOperatorName("!"), unaryOperator(hasOperatorName("!"),
hasUnaryOperand(unaryOperator( hasUnaryOperand(unaryOperator(
hasOperatorName("!"), hasOperatorName("!"),
Show All 30 Lines

clang-tools-extra/clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) { void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
// Look for ifs that have an implicit bool* to bool conversion in the // Look for ifs that have an implicit bool* to bool conversion in the
// condition. Filter negations. // condition. Filter negations.
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
ifStmt(hasCondition(findAll(implicitCastExpr( ifStmt(hasCondition(findAll(implicitCastExpr(
unless(hasParent(unaryOperator(hasOperatorName("!")))), unless(hasParent(unaryOperator(hasOperatorName("!")))),
hasSourceExpression( hasSourceExpression(
expr(hasType(pointerType(pointee(booleanType()))), expr(hasType(pointerType(pointee(booleanType()))),
ignoringParenImpCasts(declRefExpr().bind("expr")))), ignoringParenImpCasts(declRefExpr().bind("expr")))),
hasCastKind(CK_PointerToBoolean)))), hasCastKind(CK_PointerToBoolean)))),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("if"), .bind("if")),
this); this);
} }
void BoolPointerImplicitConversionCheck::check( void BoolPointerImplicitConversionCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
auto *If = Result.Nodes.getNodeAs<IfStmt>("if"); auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
auto *Var = Result.Nodes.getNodeAs<DeclRefExpr>("expr"); auto *Var = Result.Nodes.getNodeAs<DeclRefExpr>("expr");
Show All 36 Lines

clang-tools-extra/clang-tidy/bugprone/DanglingHandleCheck.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines Finder->addMatcher(
recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))), 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(
traverse(ast_type_traits::TK_AsIs,
varDecl( varDecl(
hasType(hasUnqualifiedDesugaredType( hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))), recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
unless(parmVarDecl()), 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(
traverse(ast_type_traits::TK_AsIs,
cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))), cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))),
hasOverloadedOperatorName("="), hasOverloadedOperatorName("="),
hasArgument(1, ConvertedHandle)) hasArgument(1, ConvertedHandle))
.bind("bad_stmt"), .bind("bad_stmt")),
this); this);
// Container insertions that will dangle. // Container insertions that will dangle.
Finder->addMatcher(makeContainerMatcher(IsAHandle).bind("bad_stmt"), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
makeContainerMatcher(IsAHandle).bind("bad_stmt")), this);
} }
void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) { void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
// Return a local. // Return a local.
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
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, handleFrom(IsAHandle,
declRefExpr(to(varDecl( 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(hasUnqualifiedDesugaredType( hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(recordDecl( recordType(hasDeclaration(recordDecl(
unless(IsAHandle)))))))))))))), 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(traverse(ast_type_traits::TK_AsIs,
returnStmt(has(exprWithCleanups(has(ignoringParenImpCasts(handleFrom( returnStmt(has(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
IsAHandle, handleFromTemporaryValue(IsAHandle))))))) IsAHandle, handleFromTemporaryValue(IsAHandle)))))))
.bind("bad_stmt"), .bind("bad_stmt")),
this); this);
} }
void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) { void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersForVariables(Finder); registerMatchersForVariables(Finder);
registerMatchersForReturn(Finder); registerMatchersForReturn(Finder);
} }
Show All 10 Lines

clang-tools-extra/clang-tidy/bugprone/InaccurateEraseCheck.cpp

Show All 30 Lines const auto EndCall =
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 = type(hasUnqualifiedDesugaredType( const auto DeclInStd = type(hasUnqualifiedDesugaredType(
tagType(hasDeclaration(decl(isInStdNamespace()))))); tagType(hasDeclaration(decl(isInStdNamespace())))));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
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")),
this); this);
} }
void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) { void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MemberCall = const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase");
const auto *EndExpr = const auto *EndExpr =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("end"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("end");
Show All 22 Lines

clang-tools-extra/clang-tidy/bugprone/IncorrectRoundingsCheck.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesvoid IncorrectRoundingsCheck::registerMatchers(MatchFinder *MatchFinder) {
// Match if either the LHS or RHS is a floating literal of 0.5 or a floating // Match if either the LHS or RHS is a floating literal of 0.5 or a floating
// literal of 0.5 and the other is of type double or vice versa. // literal of 0.5 and the other is of type double or vice versa.
auto OneSideHalf = anyOf(allOf(hasLHS(FloatOrCastHalf), hasRHS(FloatType)), auto OneSideHalf = anyOf(allOf(hasLHS(FloatOrCastHalf), hasRHS(FloatType)),
allOf(hasRHS(FloatOrCastHalf), hasLHS(FloatType))); allOf(hasRHS(FloatOrCastHalf), hasLHS(FloatType)));
// Find expressions of cast to int of the sum of a floating point expression // Find expressions of cast to int of the sum of a floating point expression
// and 0.5. // and 0.5.
MatchFinder->addMatcher( MatchFinder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
hasImplicitDestinationType(isInteger()), hasImplicitDestinationType(isInteger()),
ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf))) ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf)))
.bind("CastExpr"), .bind("CastExpr")),
this); this);
} }
void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) { void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr"); const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
diag(CastExpr->getBeginLoc(), diag(CastExpr->getBeginLoc(),
"casting (double + 0.5) to integer leads to incorrect rounding; " "casting (double + 0.5) to integer leads to incorrect rounding; "
"consider using lround (#include <cmath>) instead"); "consider using lround (#include <cmath>) instead");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/bugprone/IntegerDivisionCheck.cpp

Show All 28 Linesvoid IntegerDivisionCheck::registerMatchers(MatchFinder *Finder) {
const auto UnaryOperators = const auto UnaryOperators =
unaryOperator(anyOf(hasOperatorName("~"), hasOperatorName("!"))); unaryOperator(anyOf(hasOperatorName("~"), hasOperatorName("!")));
const auto Exceptions = const auto Exceptions =
anyOf(BinaryOperators, conditionalOperator(), binaryConditionalOperator(), anyOf(BinaryOperators, conditionalOperator(), binaryConditionalOperator(),
callExpr(IntType), explicitCastExpr(IntType), UnaryOperators); callExpr(IntType), explicitCastExpr(IntType), UnaryOperators);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
binaryOperator( binaryOperator(
hasOperatorName("/"), hasLHS(expr(IntType)), hasRHS(expr(IntType)), hasOperatorName("/"), hasLHS(expr(IntType)), hasRHS(expr(IntType)),
hasAncestor( hasAncestor(
castExpr(hasCastKind(CK_IntegralToFloating)).bind("FloatCast")), castExpr(hasCastKind(CK_IntegralToFloating)).bind("FloatCast")),
unless(hasAncestor( unless(hasAncestor(
expr(Exceptions, expr(Exceptions,
hasAncestor(castExpr(equalsBoundNode("FloatCast"))))))) hasAncestor(castExpr(equalsBoundNode("FloatCast")))))))
.bind("IntDiv"), .bind("IntDiv")),
this); this);
} }
void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) { void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) {
const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv"); const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv");
diag(IntDiv->getBeginLoc(), "result of integer division used in a floating " diag(IntDiv->getBeginLoc(), "result of integer division used in a floating "
"point context; possible loss of precision"); "point context; possible loss of precision");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines const auto Alloc0FuncPtr =
varDecl(hasType(isConstQualified()), varDecl(hasType(isConstQualified()),
hasInitializer(ignoringParenImpCasts( hasInitializer(ignoringParenImpCasts(
declRefExpr(hasDeclaration(Alloc0Func))))); declRefExpr(hasDeclaration(Alloc0Func)))));
const auto Alloc1FuncPtr = const auto Alloc1FuncPtr =
varDecl(hasType(isConstQualified()), varDecl(hasType(isConstQualified()),
hasInitializer(ignoringParenImpCasts( hasInitializer(ignoringParenImpCasts(
declRefExpr(hasDeclaration(Alloc1Func))))); declRefExpr(hasDeclaration(Alloc1Func)))));
Finder->addMatcher(callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
hasArgument(0, BadArg)) hasArgument(0, BadArg))
.bind("Alloc"), .bind("Alloc")),
this); this);
Finder->addMatcher(callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))),
hasArgument(1, BadArg)) hasArgument(1, BadArg))
.bind("Alloc"), .bind("Alloc")),
this); this);
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc"), this); cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc")), this);
} }
void MisplacedOperatorInStrlenInAllocCheck::check( void MisplacedOperatorInStrlenInAllocCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc"); const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc");
if (!Alloc) if (!Alloc)
Alloc = Result.Nodes.getNodeAs<CXXNewExpr>("Alloc"); Alloc = Result.Nodes.getNodeAs<CXXNewExpr>("Alloc");
assert(Alloc && "Matched node bound by 'Alloc' shoud be either 'CallExpr'" assert(Alloc && "Matched node bound by 'Alloc' shoud be either 'CallExpr'"
Show All 35 Lines

clang-tools-extra/clang-tidy/bugprone/MisplacedWideningCastCheck.cpp

Show All 35 Lines const auto Calc =
hasType(isInteger())) hasType(isInteger()))
.bind("Calc"); .bind("Calc");
const auto ExplicitCast = explicitCastExpr(hasDestinationType(isInteger()), const auto ExplicitCast = explicitCastExpr(hasDestinationType(isInteger()),
has(ignoringParenImpCasts(Calc))); has(ignoringParenImpCasts(Calc)));
const auto ImplicitCast = const auto ImplicitCast =
implicitCastExpr(hasImplicitDestinationType(isInteger()), implicitCastExpr(hasImplicitDestinationType(isInteger()),
has(ignoringParenImpCasts(Calc))); has(ignoringParenImpCasts(Calc)));
const auto Cast = expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast"); const auto Cast = traverse(ast_type_traits::TK_AsIs,
expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast"));
Finder->addMatcher(varDecl(hasInitializer(Cast)), this); Finder->addMatcher(varDecl(hasInitializer(Cast)), this);
Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this); Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this);
Finder->addMatcher(callExpr(hasAnyArgument(Cast)), this); Finder->addMatcher(callExpr(hasAnyArgument(Cast)), this);
Finder->addMatcher(binaryOperator(hasOperatorName("="), hasRHS(Cast)), this); Finder->addMatcher(binaryOperator(hasOperatorName("="), hasRHS(Cast)), this);
Finder->addMatcher( Finder->addMatcher(
binaryOperator(matchers::isComparisonOperator(), hasEitherOperand(Cast)), binaryOperator(matchers::isComparisonOperator(), hasEitherOperand(Cast)),
this); this);
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/ParentVirtualCallCheck.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines Text.erase(
Text, Text,
[](char C) { return std::isspace(static_cast<unsigned char>(C)); }), [](char C) { return std::isspace(static_cast<unsigned char>(C)); }),
Text.end()); Text.end());
return Text; return Text;
} }
void ParentVirtualCallCheck::registerMatchers(MatchFinder *Finder) { void ParentVirtualCallCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
cxxMemberCallExpr( cxxMemberCallExpr(
callee(memberExpr(hasDescendant(implicitCastExpr( callee(memberExpr(hasDescendant(implicitCastExpr(
hasImplicitDestinationType(pointsTo( hasImplicitDestinationType(pointsTo(
type(anything()).bind("castToType"))), type(anything()).bind("castToType"))),
hasSourceExpression(cxxThisExpr(hasType( hasSourceExpression(cxxThisExpr(hasType(
type(anything()).bind("thisType"))))))) type(anything()).bind("thisType")))))))
.bind("member")), .bind("member")),
callee(cxxMethodDecl(isVirtual()))), callee(cxxMethodDecl(isVirtual())))),
this); this);
} }
void ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) { void ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member"); const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
assert(Member); assert(Member);
if (!Member->getQualifier()) if (!Member->getQualifier())
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/SignedCharMisuseCheck.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesvoid SignedCharMisuseCheck::registerMatchers(MatchFinder *Finder) {
// of an assignment/declaration. // of an assignment/declaration.
const auto CastExpr = expr(anyOf(ImplicitCastExpr, CStyleCastExpr, const auto CastExpr = expr(anyOf(ImplicitCastExpr, CStyleCastExpr,
StaticCastExpr, FunctionalCastExpr)); StaticCastExpr, FunctionalCastExpr));
// Catch assignments with the suspicious type conversion. // Catch assignments with the suspicious type conversion.
const auto AssignmentOperatorExpr = expr(binaryOperator( const auto AssignmentOperatorExpr = expr(binaryOperator(
hasOperatorName("="), hasLHS(hasType(IntegerType)), hasRHS(CastExpr))); hasOperatorName("="), hasLHS(hasType(IntegerType)), hasRHS(CastExpr)));
Finder->addMatcher(AssignmentOperatorExpr, this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, AssignmentOperatorExpr), this);
// Catch declarations with the suspicious type conversion. // Catch declarations with the suspicious type conversion.
const auto Declaration = const auto Declaration =
varDecl(isDefinition(), hasType(IntegerType), hasInitializer(CastExpr)); varDecl(isDefinition(), hasType(IntegerType), hasInitializer(CastExpr));
Finder->addMatcher(Declaration, this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, Declaration), this);
} }
void SignedCharMisuseCheck::check(const MatchFinder::MatchResult &Result) { void SignedCharMisuseCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CastExpression = const auto *CastExpression =
Result.Nodes.getNodeAs<ImplicitCastExpr>("castExpression"); Result.Nodes.getNodeAs<ImplicitCastExpr>("castExpression");
const auto *IntegerType = Result.Nodes.getNodeAs<QualType>("integerType"); const auto *IntegerType = Result.Nodes.getNodeAs<QualType>("integerType");
assert(CastExpression); assert(CastExpression);
assert(IntegerType); assert(IntegerType);
Show All 20 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) { void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) {
const auto ConcatenatedStringLiteral = const auto ConcatenatedStringLiteral =
stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str"); stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str");
const auto StringsInitializerList = const auto StringsInitializerList =
initListExpr(hasType(constantArrayType()), initListExpr(hasType(constantArrayType()),
has(ignoringParenImpCasts(expr(ConcatenatedStringLiteral)))); has(ignoringParenImpCasts(expr(ConcatenatedStringLiteral))));
Finder->addMatcher(StringsInitializerList.bind("list"), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
StringsInitializerList.bind("list")), this);
} }
void SuspiciousMissingCommaCheck::check( void SuspiciousMissingCommaCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list"); const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
const auto *ConcatenatedLiteral = const auto *ConcatenatedLiteral =
Result.Nodes.getNodeAs<StringLiteral>("str"); Result.Nodes.getNodeAs<StringLiteral>("str");
assert(InitializerList && ConcatenatedLiteral); assert(InitializerList && ConcatenatedLiteral);
Show All 28 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines if (WarnOnLogicalNotComparison) {
Finder->addMatcher(unaryOperator(hasOperatorName("!"), Finder->addMatcher(unaryOperator(hasOperatorName("!"),
hasUnaryOperand(ignoringParenImpCasts( hasUnaryOperand(ignoringParenImpCasts(
StringCompareCallExpr))) StringCompareCallExpr)))
.bind("logical-not-comparison"), .bind("logical-not-comparison"),
this); this);
} }
// Detect suspicious cast to an inconsistant type (i.e. not integer type). // Detect suspicious cast to an inconsistant type (i.e. not integer type).
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr(unless(hasType(isInteger())), implicitCastExpr(unless(hasType(isInteger())),
hasSourceExpression(StringCompareCallExpr)) hasSourceExpression(StringCompareCallExpr))
.bind("invalid-conversion"), .bind("invalid-conversion")),
this); this);
// Detect suspicious operator with string compare function as operand. // Detect suspicious operator with string compare function as operand.
Finder->addMatcher( Finder->addMatcher(
binaryOperator( binaryOperator(
unless(anyOf(matchers::isComparisonOperator(), hasOperatorName("&&"), unless(anyOf(matchers::isComparisonOperator(), hasOperatorName("&&"),
hasOperatorName("||"), hasOperatorName("="))), hasOperatorName("||"), hasOperatorName("="))),
hasEitherOperand(StringCompareCallExpr)) hasEitherOperand(StringCompareCallExpr))
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
void TooSmallLoopVariableCheck::registerMatchers(MatchFinder *Finder) { void TooSmallLoopVariableCheck::registerMatchers(MatchFinder *Finder) {
StatementMatcher LoopVarMatcher = StatementMatcher LoopVarMatcher =
expr( expr(
ignoringParenImpCasts(declRefExpr(to(varDecl(hasType(isInteger())))))) ignoringParenImpCasts(declRefExpr(to(varDecl(hasType(isInteger()))))))
.bind(LoopVarName); .bind(LoopVarName);
// We need to catch only those comparisons which contain any integer cast. // We need to catch only those comparisons which contain any integer cast.
StatementMatcher LoopVarConversionMatcher = StatementMatcher LoopVarConversionMatcher =
traverse(ast_type_traits::TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(isInteger()), implicitCastExpr(hasImplicitDestinationType(isInteger()),
has(ignoringParenImpCasts(LoopVarMatcher))) has(ignoringParenImpCasts(LoopVarMatcher)))
.bind(LoopVarCastName); .bind(LoopVarCastName));
// We are interested in only those cases when the loop bound is a variable // We are interested in only those cases when the loop bound is a variable
// value (not const, enum, etc.). // value (not const, enum, etc.).
StatementMatcher LoopBoundMatcher = StatementMatcher LoopBoundMatcher =
expr(ignoringParenImpCasts(allOf(hasType(isInteger()), expr(ignoringParenImpCasts(allOf(hasType(isInteger()),
unless(integerLiteral()), unless(integerLiteral()),
unless(hasType(isConstQualified())), unless(hasType(isConstQualified())),
unless(hasType(enumType()))))) unless(hasType(enumType())))))
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/UndelegatedConstructorCheck.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesvoid UndelegatedConstructorCheck::registerMatchers(MatchFinder *Finder) {
// instantiations to reduce the number of duplicated warnings. // instantiations to reduce the number of duplicated warnings.
// //
// Only register the matchers for C++11; the functionality currently does not // Only register the matchers for C++11; 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().CPlusPlus11) if (!getLangOpts().CPlusPlus11)
return; return;
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
compoundStmt( compoundStmt(
hasParent( hasParent(
cxxConstructorDecl(ofClass(cxxRecordDecl().bind("parent")))), cxxConstructorDecl(ofClass(cxxRecordDecl().bind("parent")))),
forEach(ignoringTemporaryExpr( forEach(ignoringTemporaryExpr(
cxxConstructExpr(hasDeclaration(cxxConstructorDecl(ofClass( cxxConstructExpr(hasDeclaration(cxxConstructorDecl(ofClass(
cxxRecordDecl(baseOfBoundNode("parent")))))) cxxRecordDecl(baseOfBoundNode("parent"))))))
.bind("construct"))), .bind("construct"))),
unless(isInTemplateInstantiation())), unless(isInTemplateInstantiation()))),
this); this);
} }
void UndelegatedConstructorCheck::check( void UndelegatedConstructorCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct"); const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
diag(E->getBeginLoc(), "did you intend to call a delegated constructor? " diag(E->getBeginLoc(), "did you intend to call a delegated constructor? "
"A temporary object is created here instead"); "A temporary object is created here instead");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/bugprone/UnhandledSelfAssignmentCheck.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesvoid UnhandledSelfAssignmentCheck::registerMatchers(MatchFinder *Finder) {
// whether it is actually the parameter what we compare. // whether it is actually the parameter what we compare.
const auto HasNoSelfCheck = cxxMethodDecl(unless(hasDescendant( const auto HasNoSelfCheck = cxxMethodDecl(unless(hasDescendant(
binaryOperator(anyOf(hasOperatorName("=="), hasOperatorName("!=")), binaryOperator(anyOf(hasOperatorName("=="), hasOperatorName("!=")),
has(ignoringParenCasts(cxxThisExpr())))))); has(ignoringParenCasts(cxxThisExpr()))))));
// Both copy-and-swap and copy-and-move method creates a copy first and // Both copy-and-swap and copy-and-move method creates a copy first and
// assign it to 'this' with swap or move. // assign it to 'this' with swap or move.
// In the non-template case, we can search for the copy constructor call. // In the non-template case, we can search for the copy constructor call.
const auto HasNonTemplateSelfCopy = cxxMethodDecl( const auto HasNonTemplateSelfCopy = traverse(ast_type_traits::TK_AsIs,
cxxMethodDecl(
ofClass(cxxRecordDecl(unless(hasAncestor(classTemplateDecl())))), ofClass(cxxRecordDecl(unless(hasAncestor(classTemplateDecl())))),
hasDescendant(cxxConstructExpr(hasDeclaration(cxxConstructorDecl( hasDescendant(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), ofClass(equalsBoundNode("class"))))))); isCopyConstructor(),
ofClass(equalsBoundNode("class"))
))))
)
);
// In the template case, we need to handle two separate cases: 1) a local // In the template case, we need to handle two separate cases: 1) a local
// variable is created with the copy, 2) copy is created only as a temporary // variable is created with the copy, 2) copy is created only as a temporary
// object. // object.
const auto HasTemplateSelfCopy = cxxMethodDecl( const auto HasTemplateSelfCopy = cxxMethodDecl(
ofClass(cxxRecordDecl(hasAncestor(classTemplateDecl()))), ofClass(cxxRecordDecl(hasAncestor(classTemplateDecl()))),
anyOf(hasDescendant( anyOf(hasDescendant(
varDecl(hasType(cxxRecordDecl(equalsBoundNode("class"))), varDecl(hasType(cxxRecordDecl(equalsBoundNode("class"))),
Show All 26 Lines AdditionalMatcher = cxxMethodDecl(ofClass(cxxRecordDecl(
hasType(arrayType()))))))); hasType(arrayType())))))));
} }
Finder->addMatcher(cxxMethodDecl(ofClass(cxxRecordDecl().bind("class")), Finder->addMatcher(cxxMethodDecl(ofClass(cxxRecordDecl().bind("class")),
isCopyAssignmentOperator(), IsUserDefined, isCopyAssignmentOperator(), IsUserDefined,
HasReferenceParam, HasNoSelfCheck, HasReferenceParam, HasNoSelfCheck,
unless(HasNonTemplateSelfCopy), unless(HasNonTemplateSelfCopy),
unless(HasTemplateSelfCopy), unless(HasTemplateSelfCopy),
HasNoNestedSelfAssign, AdditionalMatcher) HasNoNestedSelfAssign, AdditionalMatcher )
.bind("copyAssignmentOperator"), .bind("copyAssignmentOperator"),
this); this);
} }
void UnhandledSelfAssignmentCheck::check( void UnhandledSelfAssignmentCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = const auto *MatchedDecl =
Result.Nodes.getNodeAs<CXXMethodDecl>("copyAssignmentOperator"); Result.Nodes.getNodeAs<CXXMethodDecl>("copyAssignmentOperator");
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"operator=() does not handle self-assignment properly"); "operator=() does not handle self-assignment properly");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/bugprone/UnusedRaiiCheck.cpp

Show All 30 Linesvoid UnusedRaiiCheck::registerMatchers(MatchFinder *Finder) {
// Look for temporaries that are constructed in-place and immediately // Look for temporaries that are constructed in-place and immediately
// destroyed. Look for temporaries created by a functional cast but not for // destroyed. Look for temporaries created by a functional cast but not for
// those returned from a call. // those returned from a call.
auto BindTemp = auto BindTemp =
cxxBindTemporaryExpr(unless(has(ignoringParenImpCasts(callExpr())))) cxxBindTemporaryExpr(unless(has(ignoringParenImpCasts(callExpr()))))
.bind("temp"); .bind("temp");
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
exprWithCleanups(unless(isInTemplateInstantiation()), exprWithCleanups(unless(isInTemplateInstantiation()),
hasParent(compoundStmt().bind("compound")), hasParent(compoundStmt().bind("compound")),
hasType(cxxRecordDecl(hasNonTrivialDestructor())), hasType(cxxRecordDecl(hasNonTrivialDestructor())),
anyOf(has(ignoringParenImpCasts(BindTemp)), anyOf(has(ignoringParenImpCasts(BindTemp)),
has(ignoringParenImpCasts(cxxFunctionalCastExpr( has(ignoringParenImpCasts(cxxFunctionalCastExpr(
has(ignoringParenImpCasts(BindTemp))))))) has(ignoringParenImpCasts(BindTemp)))))))
.bind("expr"), .bind("expr")),
this); this);
} }
void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) { void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<Expr>("expr"); const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
// We ignore code expanded from macros to reduce the number of false // We ignore code expanded from macros to reduce the number of false
// positives. // positives.
Show All 40 Lines

clang-tools-extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines auto addDeclRefs = [this, Block,
} }
} }
}; };
auto DeclRefMatcher = declRefExpr(hasDeclaration(equalsNode(MovedVariable)), auto DeclRefMatcher = declRefExpr(hasDeclaration(equalsNode(MovedVariable)),
unless(inDecltypeOrTemplateArg())) unless(inDecltypeOrTemplateArg()))
.bind("declref"); .bind("declref");
addDeclRefs(match(findAll(DeclRefMatcher), *S->getStmt(), *Context)); addDeclRefs(match(traverse(ast_type_traits::TK_AsIs,
findAll(DeclRefMatcher)), *S->getStmt(), *Context));
addDeclRefs(match( addDeclRefs(match(
findAll(cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("*"), findAll(cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("*"),
hasOverloadedOperatorName("->"), hasOverloadedOperatorName("->"),
hasOverloadedOperatorName("[]")), hasOverloadedOperatorName("[]")),
hasArgument(0, DeclRefMatcher)) hasArgument(0, DeclRefMatcher))
.bind("operator")), .bind("operator")),
*S->getStmt(), *Context)); *S->getStmt(), *Context));
} }
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines auto ReinitMatcher =
// Passing variable to a function as a non-const pointer. // Passing variable to a function as a non-const pointer.
callExpr(forEachArgumentWithParam( callExpr(forEachArgumentWithParam(
unaryOperator(hasOperatorName("&"), unaryOperator(hasOperatorName("&"),
hasUnaryOperand(DeclRefMatcher)), hasUnaryOperand(DeclRefMatcher)),
unless(parmVarDecl(hasType(pointsTo(isConstQualified())))))), unless(parmVarDecl(hasType(pointsTo(isConstQualified())))))),
// Passing variable to a function as a non-const lvalue reference // Passing variable to a function as a non-const lvalue reference
// (unless that function is std::move()). // (unless that function is std::move()).
callExpr(forEachArgumentWithParam( callExpr(forEachArgumentWithParam(
DeclRefMatcher, traverse(ast_type_traits::TK_AsIs, DeclRefMatcher),
unless(parmVarDecl(hasType( unless(parmVarDecl(hasType(
references(qualType(isConstQualified())))))), references(qualType(isConstQualified())))))),
unless(callee(functionDecl(hasName("::std::move"))))))) unless(callee(functionDecl(hasName("::std::move")))))))
.bind("reinit"); .bind("reinit");
Stmts->clear(); Stmts->clear();
DeclRefs->clear(); DeclRefs->clear();
for (const auto &Elem : *Block) { for (const auto &Elem : *Block) {
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines auto CallMoveMatcher =
callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1), callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1),
hasArgument(0, declRefExpr().bind("arg")), hasArgument(0, declRefExpr().bind("arg")),
anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")), anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")),
hasAncestor(functionDecl().bind("containing-func"))), hasAncestor(functionDecl().bind("containing-func"))),
unless(inDecltypeOrTemplateArg())) unless(inDecltypeOrTemplateArg()))
.bind("call-move"); .bind("call-move");
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
// To find the Stmt that we assume performs the actual move, we look for // To find the Stmt that we assume performs the actual move, we look for
// the direct ancestor of the std::move() that isn't one of the node // the direct ancestor of the std::move() that isn't one of the node
// types ignored by ignoringParenImpCasts(). // types ignored by ignoringParenImpCasts().
stmt(forEach(expr(ignoringParenImpCasts(CallMoveMatcher))), stmt(forEach(expr(ignoringParenImpCasts(CallMoveMatcher))),
// Don't allow an InitListExpr to be the moving call. An InitListExpr // Don't allow an InitListExpr to be the moving call. An InitListExpr
// has both a syntactic and a semantic form, and the parent-child // has both a syntactic and a semantic form, and the parent-child
// relationships are different between the two. This could cause an // relationships are different between the two. This could cause an
// InitListExpr to be analyzed as the moving call in addition to the // InitListExpr to be analyzed as the moving call in addition to the
// Expr that we actually want, resulting in two diagnostics with // Expr that we actually want, resulting in two diagnostics with
// different code locations for the same move. // different code locations for the same move.
unless(initListExpr()), unless(initListExpr()),
unless(expr(ignoringParenImpCasts(equalsBoundNode("call-move"))))) unless(expr(ignoringParenImpCasts(equalsBoundNode("call-move")))))
.bind("moving-call"), .bind("moving-call")),
this); this);
} }
void UseAfterMoveCheck::check(const MatchFinder::MatchResult &Result) { void UseAfterMoveCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ContainingLambda = const auto *ContainingLambda =
Result.Nodes.getNodeAs<LambdaExpr>("containing-lambda"); Result.Nodes.getNodeAs<LambdaExpr>("containing-lambda");
const auto *ContainingFunc = const auto *ContainingFunc =
Result.Nodes.getNodeAs<FunctionDecl>("containing-func"); Result.Nodes.getNodeAs<FunctionDecl>("containing-func");
const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move"); const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
const auto *MovingCall = Result.Nodes.getNodeAs<Expr>("moving-call"); const auto *MovingCall = Result.Nodes.getNodeAs<Expr>("moving-call");
const auto *Arg = Result.Nodes.getNodeAs<DeclRefExpr>("arg"); const auto *Arg = Result.Nodes.getNodeAs<DeclRefExpr>("arg");
Show All 25 Lines

clang-tools-extra/clang-tidy/cert/MutatingCopyCheck.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesvoid MutatingCopyCheck::registerMatchers(MatchFinder *Finder) {
const auto IsSelfMutatingMemberFunction = const auto IsSelfMutatingMemberFunction =
functionDecl(hasBody(hasDescendant(IsSelfMutatingAssignment))); functionDecl(hasBody(hasDescendant(IsSelfMutatingAssignment)));
const auto IsSourceMutatingMemberCall = const auto IsSourceMutatingMemberCall =
cxxMemberCallExpr(on(IsPartOfSource), cxxMemberCallExpr(on(IsPartOfSource),
callee(IsSelfMutatingMemberFunction)) callee(IsSelfMutatingMemberFunction))
.bind(MutatingCallName); .bind(MutatingCallName);
const auto MutatesSource = allOf( const auto MutatesSource = traverse(ast_type_traits::TK_AsIs, allOf(
hasParameter( hasParameter(
0, parmVarDecl(hasType(lValueReferenceType())).bind(SourceDeclName)), 0, parmVarDecl(hasType(lValueReferenceType())).bind(SourceDeclName)),
anyOf(forEachDescendant(IsSourceMutatingAssignment), anyOf(forEachDescendant(IsSourceMutatingAssignment),
forEachDescendant(IsSourceMutatingMemberCall))); forEachDescendant(IsSourceMutatingMemberCall))));
Finder->addMatcher(cxxConstructorDecl(isCopyConstructor(), MutatesSource), Finder->addMatcher(cxxConstructorDecl(isCopyConstructor(), MutatesSource),
this); this);
Finder->addMatcher(cxxMethodDecl(isCopyAssignmentOperator(), MutatesSource), Finder->addMatcher(cxxMethodDecl(isCopyAssignmentOperator(), MutatesSource),
this); this);
} }
Show All 12 Lines

clang-tools-extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesvoid ProperlySeededRandomGeneratorCheck::registerMatchers(MatchFinder *Finder) {
// std::mt19937 engine; // std::mt19937 engine;
// ^ // ^
// std::mt19937 engine(1); // std::mt19937 engine(1);
// ^ // ^
// const int x = 1; // const int x = 1;
// std::mt19937 engine(x); // std::mt19937 engine(x);
// ^ // ^
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor"), this); cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor")), this);
// srand(); // srand();
// ^ // ^
// const int x = 1; // const int x = 1;
// srand(x); // srand(x);
// ^ // ^
Finder->addMatcher( Finder->addMatcher(
callExpr(callee(functionDecl(hasAnyName("::srand", "::std::srand")))) callExpr(callee(functionDecl(hasAnyName("::srand", "::std::srand"))))
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cert/StaticObjectExceptionCheck.cpp

Show All 17 Lines
namespace cert { namespace cert {
void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) { void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
if ((!getLangOpts().CPlusPlus) || (!getLangOpts().CXXExceptions)) if ((!getLangOpts().CPlusPlus) || (!getLangOpts().CXXExceptions))
return; return;
// Match any static or thread_local variable declaration that has an // Match any static or thread_local variable declaration that has an
// initializer that can throw. // initializer that can throw.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
varDecl(anyOf(hasThreadStorageDuration(), hasStaticStorageDuration()), varDecl(anyOf(hasThreadStorageDuration(), hasStaticStorageDuration()),
unless(anyOf(isConstexpr(), hasType(cxxRecordDecl(isLambda())), unless(anyOf(isConstexpr(), hasType(cxxRecordDecl(isLambda())),
hasAncestor(functionDecl()))), hasAncestor(functionDecl()))),
anyOf(hasDescendant(cxxConstructExpr(hasDeclaration( anyOf(hasDescendant(cxxConstructExpr(hasDeclaration(
cxxConstructorDecl(unless(isNoThrow())).bind("func")))), cxxConstructorDecl(unless(isNoThrow())).bind("func")))),
hasDescendant(cxxNewExpr(hasDeclaration( hasDescendant(cxxNewExpr(hasDeclaration(
functionDecl(unless(isNoThrow())).bind("func")))), functionDecl(unless(isNoThrow())).bind("func")))),
hasDescendant(callExpr(hasDeclaration( hasDescendant(callExpr(hasDeclaration(
functionDecl(unless(isNoThrow())).bind("func")))))) functionDecl(unless(isNoThrow())).bind("func"))))))
.bind("var"), .bind("var")),
this); this);
} }
void StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) { void StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) {
const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var"); const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var");
const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
diag(VD->getLocation(), diag(VD->getLocation(),
Show All 16 Lines

clang-tools-extra/clang-tidy/cert/ThrownExceptionTypeCheck.cpp

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) { void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxThrowExpr(has(ignoringParenImpCasts( cxxThrowExpr(has(ignoringParenImpCasts(
cxxConstructExpr(hasDeclaration(cxxConstructorDecl( cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), unless(isNoThrow())))) isCopyConstructor(), unless(isNoThrow()))))
.bind("expr")))), .bind("expr"))))),
this); this);
} }
void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) { void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<Expr>("expr"); const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
diag(E->getExprLoc(), diag(E->getExprLoc(),
"thrown exception type is not nothrow copy constructible"); "thrown exception type is not nothrow copy constructible");
} }
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/InterfacesGlobalInitCheck.cpp

Show All 21 Lines const auto GlobalVarDecl =
hasDeclContext(anyOf(translationUnitDecl(), // Global scope. hasDeclContext(anyOf(translationUnitDecl(), // Global scope.
namespaceDecl(), // Namespace scope. namespaceDecl(), // Namespace scope.
recordDecl())), // Class scope. recordDecl())), // Class scope.
unless(isConstexpr())); unless(isConstexpr()));
const auto ReferencesUndefinedGlobalVar = declRefExpr(hasDeclaration( const auto ReferencesUndefinedGlobalVar = declRefExpr(hasDeclaration(
varDecl(GlobalVarDecl, unless(isDefinition())).bind("referencee"))); varDecl(GlobalVarDecl, unless(isDefinition())).bind("referencee")));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
varDecl(GlobalVarDecl, isDefinition(), varDecl(GlobalVarDecl, isDefinition(),
hasInitializer(expr(hasDescendant(ReferencesUndefinedGlobalVar)))) hasInitializer(expr(hasDescendant(ReferencesUndefinedGlobalVar))))
.bind("var"), .bind("var")),
this); this);
} }
void InterfacesGlobalInitCheck::check(const MatchFinder::MatchResult &Result) { void InterfacesGlobalInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *const Var = Result.Nodes.getNodeAs<VarDecl>("var"); const auto *const Var = Result.Nodes.getNodeAs<VarDecl>("var");
// For now assume that people who write macros know what they're doing. // For now assume that people who write macros know what they're doing.
if (Var->getLocation().isMacroID()) if (Var->getLocation().isMacroID())
return; return;
Show All 17 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

Show All 33 Linesvoid NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
// is not integral. // is not integral.
const auto IsCeilFloorCallExpr = expr(callExpr(callee(functionDecl( const auto IsCeilFloorCallExpr = expr(callExpr(callee(functionDecl(
hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor"))))); hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor")))));
// Casts: // Casts:
// i = 0.5; // i = 0.5;
// void f(int); f(0.5); // void f(int); f(0.5);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(builtinType()), implicitCastExpr(hasImplicitDestinationType(builtinType()),
hasSourceExpression(hasType(builtinType())), hasSourceExpression(hasType(builtinType())),
unless(hasSourceExpression(IsCeilFloorCallExpr)), unless(hasSourceExpression(IsCeilFloorCallExpr)),
unless(hasParent(castExpr())), unless(hasParent(castExpr())),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("cast"), .bind("cast")),
this); this);
// Binary operators: // Binary operators:
// i += 0.5; // i += 0.5;
Finder->addMatcher(binaryOperator(isAssignmentOperator(), Finder->addMatcher(
binaryOperator(isAssignmentOperator(),
hasLHS(expr(hasType(builtinType()))), hasLHS(expr(hasType(builtinType()))),
hasRHS(expr(hasType(builtinType()))), hasRHS(expr(hasType(builtinType()))),
unless(hasRHS(IsCeilFloorCallExpr)), unless(hasRHS(IsCeilFloorCallExpr)),
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
// The `=` case generates an implicit cast // The `=` case generates an implicit cast
// which is covered by the previous matcher. // which is covered by the previous matcher.
unless(hasOperatorName("="))) unless(hasOperatorName("=")))
.bind("binary_op"), .bind("binary_op"),
▲ Show 20 Lines • Show All 386 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines const auto CreatesOwner =
anyOf(cxxNewExpr(), anyOf(cxxNewExpr(),
callExpr(callee( callExpr(callee(
functionDecl(returns(qualType(hasDeclaration(OwnerDecl)))))), functionDecl(returns(qualType(hasDeclaration(OwnerDecl)))))),
CreatesLegacyOwner, LegacyOwnerCast); CreatesLegacyOwner, LegacyOwnerCast);
const auto ConsideredOwner = eachOf(IsOwnerType, CreatesOwner); const auto ConsideredOwner = eachOf(IsOwnerType, CreatesOwner);
// Find delete expressions that delete non-owners. // Find delete expressions that delete non-owners.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxDeleteExpr( cxxDeleteExpr(
hasDescendant( hasDescendant(
declRefExpr(unless(ConsideredOwner)).bind("deleted_variable"))) declRefExpr(unless(ConsideredOwner)).bind("deleted_variable")))
.bind("delete_expr"), .bind("delete_expr")),
this); this);
// Ignoring the implicit casts is vital because the legacy owners do not work // Ignoring the implicit casts is vital because the legacy owners do not work
// with the 'owner<>' annotation and therefore always implicitly cast to the // with the 'owner<>' annotation and therefore always implicitly cast to the
// legacy type (even 'void *'). // legacy type (even 'void *').
// //
// Furthermore, legacy owner functions are assumed to use raw pointers for // Furthermore, legacy owner functions are assumed to use raw pointers for
// resources. This check assumes that all pointer arguments of a legacy // resources. This check assumes that all pointer arguments of a legacy
// functions shall be 'gsl::owner<>'. // functions shall be 'gsl::owner<>'.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(callee(LegacyOwnerConsumers), callExpr(callee(LegacyOwnerConsumers),
hasAnyArgument(expr(unless(ignoringImpCasts(ConsideredOwner)), hasAnyArgument(expr(unless(ignoringImpCasts(ConsideredOwner)),
hasType(pointerType())))) hasType(pointerType()))))
.bind("legacy_consumer"), .bind("legacy_consumer")),
this); this);
// Matching assignment to owners, with the rhs not being an owner nor creating // Matching assignment to owners, with the rhs not being an owner nor creating
// one. // one.
Finder->addMatcher(binaryOperator(matchers::isAssignmentOperator(), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(matchers::isAssignmentOperator(),
hasLHS(IsOwnerType), hasLHS(IsOwnerType),
hasRHS(unless(ConsideredOwner))) hasRHS(unless(ConsideredOwner)))
.bind("owner_assignment"), .bind("owner_assignment")),
this); this);
// Matching initialization of owners with non-owners, nor creating owners. // Matching initialization of owners with non-owners, nor creating owners.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
namedDecl(varDecl(hasInitializer(unless(ConsideredOwner)), IsOwnerType) namedDecl(varDecl(hasInitializer(unless(ConsideredOwner)), IsOwnerType)
.bind("owner_initialization")), .bind("owner_initialization"))),
this); this);
const auto HasConstructorInitializerForOwner = const auto HasConstructorInitializerForOwner =
has(cxxConstructorDecl(forEachConstructorInitializer( has(cxxConstructorDecl(forEachConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
isMemberInitializer(), forField(IsOwnerType), isMemberInitializer(), forField(IsOwnerType),
withInitializer( withInitializer(
// Avoid templatesdeclaration with // Avoid templatesdeclaration with
// excluding parenListExpr. // excluding parenListExpr.
allOf(unless(ConsideredOwner), unless(parenListExpr())))) allOf(unless(ConsideredOwner), unless(parenListExpr()))))
.bind("owner_member_initializer")))); .bind("owner_member_initializer"))));
// Match class member initialization that expects owners, but does not get // Match class member initialization that expects owners, but does not get
// them. // them.
Finder->addMatcher(cxxRecordDecl(HasConstructorInitializerForOwner), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxRecordDecl(HasConstructorInitializerForOwner)), this);
// Matching on assignment operations where the RHS is a newly created owner, // Matching on assignment operations where the RHS is a newly created owner,
// but the LHS is not an owner. // but the LHS is not an owner.
Finder->addMatcher(binaryOperator(matchers::isAssignmentOperator(), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(matchers::isAssignmentOperator(),
hasLHS(unless(IsOwnerType)), hasLHS(unless(IsOwnerType)),
hasRHS(CreatesOwner)) hasRHS(CreatesOwner))
.bind("bad_owner_creation_assignment"), .bind("bad_owner_creation_assignment")),
this); this);
// Matching on initialization operations where the initial value is a newly // Matching on initialization operations where the initial value is a newly
// created owner, but the LHS is not an owner. // created owner, but the LHS is not an owner.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
namedDecl(varDecl(eachOf(allOf(hasInitializer(CreatesOwner), namedDecl(varDecl(eachOf(allOf(hasInitializer(CreatesOwner),
unless(IsOwnerType)), unless(IsOwnerType)),
allOf(hasInitializer(ConsideredOwner), allOf(hasInitializer(ConsideredOwner),
hasType(autoType().bind("deduced_type"))))) hasType(autoType().bind("deduced_type")))))
.bind("bad_owner_creation_variable")), .bind("bad_owner_creation_variable"))),
this); this);
// Match on all function calls that expect owners as arguments, but didn't // Match on all function calls that expect owners as arguments, but didn't
// get them. // get them.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(forEachArgumentWithParam( callExpr(forEachArgumentWithParam(
expr(unless(ConsideredOwner)).bind("expected_owner_argument"), expr(unless(ConsideredOwner)).bind("expected_owner_argument"),
parmVarDecl(IsOwnerType))), parmVarDecl(IsOwnerType)))),
this); this);
// Matching for function calls where one argument is a created owner, but the // Matching for function calls where one argument is a created owner, but the
// parameter type is not an owner. // parameter type is not an owner.
Finder->addMatcher(callExpr(forEachArgumentWithParam( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(forEachArgumentWithParam(
expr(CreatesOwner).bind("bad_owner_creation_argument"), expr(CreatesOwner).bind("bad_owner_creation_argument"),
parmVarDecl(unless(IsOwnerType)) parmVarDecl(unless(IsOwnerType))
.bind("bad_owner_creation_parameter"))), .bind("bad_owner_creation_parameter")))),
this); this);
// Matching on functions, that return an owner/resource, but don't declare // Matching on functions, that return an owner/resource, but don't declare
// their return type as owner. // their return type as owner.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
functionDecl(hasDescendant(returnStmt(hasReturnValue(ConsideredOwner)) functionDecl(hasDescendant(returnStmt(hasReturnValue(ConsideredOwner))
.bind("bad_owner_return")), .bind("bad_owner_return")),
unless(returns(qualType(hasDeclaration(OwnerDecl))))) unless(returns(qualType(hasDeclaration(OwnerDecl)))))
.bind("function_decl"), .bind("function_decl")),
this); this);
// Match on classes that have an owner as member, but don't declare a // Match on classes that have an owner as member, but don't declare a
// destructor to properly release the owner. // destructor to properly release the owner.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxRecordDecl( cxxRecordDecl(
has(fieldDecl(IsOwnerType).bind("undestructed_owner_member")), has(fieldDecl(IsOwnerType).bind("undestructed_owner_member")),
anyOf(unless(has(cxxDestructorDecl())), anyOf(unless(has(cxxDestructorDecl())),
has(cxxDestructorDecl(anyOf(isDefaulted(), isDeleted()))))) has(cxxDestructorDecl(anyOf(isDefaulted(), isDeleted())))))
.bind("non_destructor_class"), .bind("non_destructor_class")),
this); this);
} }
void OwningMemoryCheck::check(const MatchFinder::MatchResult &Result) { void OwningMemoryCheck::check(const MatchFinder::MatchResult &Result) {
const auto &Nodes = Result.Nodes; const auto &Nodes = Result.Nodes;
bool CheckExecuted = false; bool CheckExecuted = false;
CheckExecuted |= handleDeletion(Nodes); CheckExecuted |= handleDeletion(Nodes);
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) { void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
// The only allowed array to pointer decay // The only allowed array to pointer decay
// 1) just before array subscription // 1) just before array subscription
// 2) inside a range-for over an array // 2) inside a range-for over an array
// 3) if it converts a string literal to a pointer // 3) if it converts a string literal to a pointer
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
unless(hasParent(arraySubscriptExpr())), unless(hasParent(arraySubscriptExpr())),
unless(hasParentIgnoringImpCasts(explicitCastExpr())), unless(hasParentIgnoringImpCasts(explicitCastExpr())),
unless(isInsideOfRangeBeginEndStmt()), unless(isInsideOfRangeBeginEndStmt()),
unless(hasSourceExpression(ignoringParens(stringLiteral())))) unless(hasSourceExpression(ignoringParens(stringLiteral()))))
.bind("cast"), .bind("cast")),
this); this);
} }
void ProBoundsArrayToPointerDecayCheck::check( void ProBoundsArrayToPointerDecayCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast"); const auto *MatchedCast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast");
if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay) if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay)
return; return;
Show All 9 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesvoid SlicingCheck::registerMatchers(MatchFinder *Finder) {
const auto SlicesObjectInCtor = cxxConstructExpr( const auto SlicesObjectInCtor = cxxConstructExpr(
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
anyOf(isCopyConstructor(), isMoveConstructor()), OfBaseClass)), anyOf(isCopyConstructor(), isMoveConstructor()), OfBaseClass)),
hasArgument(0, HasTypeDerivedFromBaseDecl), hasArgument(0, HasTypeDerivedFromBaseDecl),
// We need to disable matching on the call to the base copy/move // We need to disable matching on the call to the base copy/move
// constructor in DerivedDecl's constructors. // constructor in DerivedDecl's constructors.
unless(IsWithinDerivedCtor)); unless(IsWithinDerivedCtor));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
expr(anyOf(SlicesObjectInAssignment, SlicesObjectInCtor)).bind("Call"), expr(anyOf(SlicesObjectInAssignment, SlicesObjectInCtor)).bind("Call")),
this); this);
} }
/// Warns on methods overridden in DerivedDecl with respect to BaseDecl. /// Warns on methods overridden in DerivedDecl with respect to BaseDecl.
/// FIXME: this warns on all overrides outside of the sliced path in case of /// FIXME: this warns on all overrides outside of the sliced path in case of
/// multiple inheritance. /// multiple inheritance.
void SlicingCheck::DiagnoseSlicedOverriddenMethods( void SlicingCheck::DiagnoseSlicedOverriddenMethods(
const Expr &Call, const CXXRecordDecl &DerivedDecl, const Expr &Call, const CXXRecordDecl &DerivedDecl,
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

Show All 27 Linesvoid StaticallyConstructedObjectsCheck::registerMatchers(MatchFinder *Finder) {
// Constructing global, non-trivial objects with static storage is // Constructing global, non-trivial objects with static storage is
// disallowed, unless the object is statically initialized with a constexpr // disallowed, unless the object is statically initialized with a constexpr
// constructor or has no explicit constructor. // constructor or has no explicit constructor.
// Constexpr requires C++11 or later. // Constexpr requires C++11 or later.
if (!getLangOpts().CPlusPlus11) if (!getLangOpts().CPlusPlus11)
return; return;
Finder->addMatcher(varDecl( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, varDecl(
// Match global, statically stored objects... // Match global, statically stored objects...
isGlobalStatic(), isGlobalStatic(),
// ... that have C++ constructors... // ... that have C++ constructors...
hasDescendant(cxxConstructExpr(unless(allOf( hasDescendant(cxxConstructExpr(unless(allOf(
// ... unless it is constexpr ... // ... unless it is constexpr ...
hasDeclaration(cxxConstructorDecl(isConstexpr())), hasDeclaration(cxxConstructorDecl(isConstexpr())),
// ... and is statically initialized. // ... and is statically initialized.
isConstantInitializer()))))) isConstantInitializer())))))
.bind("decl"), .bind("decl")),
this); this);
} }
void StaticallyConstructedObjectsCheck::check( void StaticallyConstructedObjectsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl"))
diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a " diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a "
"constexpr constructor instead"); "constexpr constructor instead");
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines auto CallExpression =
hasName("cast_or_null"), hasName("cast_or_null"),
hasName("dyn_cast"), hasName("dyn_cast"),
hasName("dyn_cast_or_null"))) hasName("dyn_cast_or_null")))
.bind("func")), .bind("func")),
hasArgument(0, anyOf(declRefExpr().bind("arg"), hasArgument(0, anyOf(declRefExpr().bind("arg"),
cxxMemberCallExpr().bind("arg")))))) cxxMemberCallExpr().bind("arg"))))))
.bind("rhs"); .bind("rhs");
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
stmt(anyOf(ifStmt(Any), whileStmt(Any), doStmt(Condition), stmt(anyOf(ifStmt(Any), whileStmt(Any), doStmt(Condition),
binaryOperator( binaryOperator(
allOf(unless(isExpansionInFileMatching( allOf(unless(isExpansionInFileMatching(
"llvm/include/llvm/Support/Casting.h")), "llvm/include/llvm/Support/Casting.h")),
hasOperatorName("&&"), hasOperatorName("&&"),
hasLHS(implicitCastExpr().bind("lhs")), hasLHS(implicitCastExpr().bind("lhs")),
hasRHS(anyOf(implicitCastExpr(has(CallExpression)), hasRHS(anyOf(implicitCastExpr(has(CallExpression)),
CallExpression)))) CallExpression))))
.bind("and"))), .bind("and")))),
this); this);
} }
void PreferIsaOrDynCastInConditionalsCheck::check( void PreferIsaOrDynCastInConditionalsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
if (const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("assign")) { if (const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("assign")) {
SourceLocation StartLoc = MatchedDecl->getCallee()->getExprLoc(); SourceLocation StartLoc = MatchedDecl->getCallee()->getExprLoc();
SourceLocation EndLoc = SourceLocation EndLoc =
StartLoc.getLocWithOffset(StringRef("cast").size() - 1); StartLoc.getLocWithOffset(StringRef("cast").size() - 1);
diag(MatchedDecl->getBeginLoc(), diag(MatchedDecl->getBeginLoc(),
"cast<> in conditional will assert rather than return a null pointer") "cast<> in conditional will assert rather than return a null pointer")
<< FixItHint::CreateReplacement(SourceRange(StartLoc, EndLoc), << FixItHint::CreateReplacement(SourceRange(StartLoc, EndLoc),
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/llvm/PreferRegisterOverUnsignedCheck.cpp

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_check { namespace llvm_check {
void PreferRegisterOverUnsignedCheck::registerMatchers(MatchFinder *Finder) { void PreferRegisterOverUnsignedCheck::registerMatchers(MatchFinder *Finder) {
auto RegisterClassMatch = hasType( auto RegisterClassMatch = hasType(
cxxRecordDecl(hasName("::llvm::Register")).bind("registerClassDecl")); cxxRecordDecl(hasName("::llvm::Register")).bind("registerClassDecl"));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
valueDecl(allOf( valueDecl(allOf(
hasType(qualType(isUnsignedInteger()).bind("varType")), hasType(qualType(isUnsignedInteger()).bind("varType")),
varDecl(hasInitializer(exprWithCleanups(has(implicitCastExpr(has( varDecl(hasInitializer(exprWithCleanups(has(implicitCastExpr(has(
cxxMemberCallExpr(allOf(on(RegisterClassMatch), cxxMemberCallExpr(allOf(on(RegisterClassMatch),
has(memberExpr(hasDeclaration( has(memberExpr(hasDeclaration(
cxxConversionDecl()))))))))))) cxxConversionDecl())))))))))))
.bind("var"))), .bind("var")))),
this); this);
} }
void PreferRegisterOverUnsignedCheck::check( void PreferRegisterOverUnsignedCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *VarType = Result.Nodes.getNodeAs<QualType>("varType"); const auto *VarType = Result.Nodes.getNodeAs<QualType>("varType");
const auto *UserVarDecl = Result.Nodes.getNodeAs<VarDecl>("var"); const auto *UserVarDecl = Result.Nodes.getNodeAs<VarDecl>("var");
Show All 26 Lines

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp

Show First 20 Lines • Show All 690 Lines • ▼ Show 20 Lines
void RedundantExpressionCheck::registerMatchers(MatchFinder *Finder) { void RedundantExpressionCheck::registerMatchers(MatchFinder *Finder) {
const auto AnyLiteralExpr = ignoringParenImpCasts( const auto AnyLiteralExpr = ignoringParenImpCasts(
anyOf(cxxBoolLiteral(), characterLiteral(), integerLiteral())); anyOf(cxxBoolLiteral(), characterLiteral(), integerLiteral()));
const auto BannedIntegerLiteral = const auto BannedIntegerLiteral =
integerLiteral(expandedByMacro(KnownBannedMacroNames)); integerLiteral(expandedByMacro(KnownBannedMacroNames));
// Binary with equivalent operands, like (X != 2 && X != 2). // Binary with equivalent operands, like (X != 2 && X != 2).
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(anyOf(hasOperatorName("-"), hasOperatorName("/"), binaryOperator(anyOf(hasOperatorName("-"), hasOperatorName("/"),
hasOperatorName("%"), hasOperatorName("|"), hasOperatorName("%"), hasOperatorName("|"),
hasOperatorName("&"), hasOperatorName("^"), hasOperatorName("&"), hasOperatorName("^"),
matchers::isComparisonOperator(), matchers::isComparisonOperator(),
hasOperatorName("&&"), hasOperatorName("||"), hasOperatorName("&&"), hasOperatorName("||"),
hasOperatorName("=")), hasOperatorName("=")),
operandsAreEquivalent(), operandsAreEquivalent(),
// Filter noisy false positives. // Filter noisy false positives.
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
unless(binaryOperatorIsInMacro()), unless(binaryOperatorIsInMacro()),
unless(hasType(realFloatingPointType())), unless(hasType(realFloatingPointType())),
unless(hasEitherOperand(hasType(realFloatingPointType()))), unless(hasEitherOperand(hasType(realFloatingPointType()))),
unless(hasLHS(AnyLiteralExpr)), unless(hasLHS(AnyLiteralExpr)),
unless(hasDescendant(BannedIntegerLiteral))) unless(hasDescendant(BannedIntegerLiteral)))
.bind("binary"), .bind("binary")),
this); this);
// Conditional (trenary) operator with equivalent operands, like (Y ? X : X). // Conditional (trenary) operator with equivalent operands, like (Y ? X : X).
Finder->addMatcher(conditionalOperator(expressionsAreEquivalent(), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
conditionalOperator(expressionsAreEquivalent(),
// Filter noisy false positives. // Filter noisy false positives.
unless(conditionalOperatorIsInMacro()), unless(conditionalOperatorIsInMacro()),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("cond"), .bind("cond")),
this); this);
// Overloaded operators with equivalent operands. // Overloaded operators with equivalent operands.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxOperatorCallExpr( cxxOperatorCallExpr(
anyOf( anyOf(
hasOverloadedOperatorName("-"), hasOverloadedOperatorName("/"), hasOverloadedOperatorName("-"), hasOverloadedOperatorName("/"),
hasOverloadedOperatorName("%"), hasOverloadedOperatorName("|"), hasOverloadedOperatorName("%"), hasOverloadedOperatorName("|"),
hasOverloadedOperatorName("&"), hasOverloadedOperatorName("^"), hasOverloadedOperatorName("&"), hasOverloadedOperatorName("^"),
hasOverloadedOperatorName("=="), hasOverloadedOperatorName("!="), hasOverloadedOperatorName("=="), hasOverloadedOperatorName("!="),
hasOverloadedOperatorName("<"), hasOverloadedOperatorName("<="), hasOverloadedOperatorName("<"), hasOverloadedOperatorName("<="),
hasOverloadedOperatorName(">"), hasOverloadedOperatorName(">="), hasOverloadedOperatorName(">"), hasOverloadedOperatorName(">="),
hasOverloadedOperatorName("&&"), hasOverloadedOperatorName("||"), hasOverloadedOperatorName("&&"), hasOverloadedOperatorName("||"),
hasOverloadedOperatorName("=")), hasOverloadedOperatorName("=")),
parametersAreEquivalent(), parametersAreEquivalent(),
// Filter noisy false positives. // Filter noisy false positives.
unless(isMacro()), unless(isInTemplateInstantiation())) unless(isMacro()), unless(isInTemplateInstantiation()))
.bind("call"), .bind("call")),
this); this);
// Match expressions like: !(1 | 2 | 3) // Match expressions like: !(1 | 2 | 3)
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
hasImplicitDestinationType(isInteger()), hasImplicitDestinationType(isInteger()),
has(unaryOperator( has(unaryOperator(
hasOperatorName("!"), hasOperatorName("!"),
hasUnaryOperand(ignoringParenImpCasts(binaryOperator( hasUnaryOperand(ignoringParenImpCasts(binaryOperator(
anyOf(hasOperatorName("|"), hasOperatorName("&")), anyOf(hasOperatorName("|"), hasOperatorName("&")),
hasLHS(anyOf(binaryOperator(anyOf(hasOperatorName("|"), hasLHS(anyOf(binaryOperator(anyOf(hasOperatorName("|"),
hasOperatorName("&"))), hasOperatorName("&"))),
integerLiteral())), integerLiteral())),
hasRHS(integerLiteral()))))) hasRHS(integerLiteral())))))
.bind("logical-bitwise-confusion"))), .bind("logical-bitwise-confusion")))),
this); this);
// Match expressions like: (X << 8) & 0xFF // Match expressions like: (X << 8) & 0xFF
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(hasOperatorName("&"), binaryOperator(hasOperatorName("&"),
hasEitherOperand(ignoringParenImpCasts(binaryOperator( hasEitherOperand(ignoringParenImpCasts(binaryOperator(
hasOperatorName("<<"), hasOperatorName("<<"),
hasRHS(ignoringParenImpCasts( hasRHS(ignoringParenImpCasts(
integerLiteral().bind("shift-const")))))), integerLiteral().bind("shift-const")))))),
hasEitherOperand(ignoringParenImpCasts( hasEitherOperand(ignoringParenImpCasts(
integerLiteral().bind("and-const")))) integerLiteral().bind("and-const"))))
.bind("left-right-shift-confusion"), .bind("left-right-shift-confusion")),
this); this);
// Match common expressions and apply more checks to find redundant // Match common expressions and apply more checks to find redundant
// sub-expressions. // sub-expressions.
// a) Expr <op> K1 == K2 // a) Expr <op> K1 == K2
// b) Expr <op> K1 == Expr // b) Expr <op> K1 == Expr
// c) Expr <op> K1 == Expr <op> K2 // c) Expr <op> K1 == Expr <op> K2
// see: 'checkArithmeticExpr' and 'checkBitwiseExpr' // see: 'checkArithmeticExpr' and 'checkBitwiseExpr'
const auto BinOpCstLeft = matchBinOpIntegerConstantExpr("lhs"); const auto BinOpCstLeft = matchBinOpIntegerConstantExpr("lhs");
const auto BinOpCstRight = matchBinOpIntegerConstantExpr("rhs"); const auto BinOpCstRight = matchBinOpIntegerConstantExpr("rhs");
const auto CstRight = matchIntegerConstantExpr("rhs"); const auto CstRight = matchIntegerConstantExpr("rhs");
const auto SymRight = matchSymbolicExpr("rhs"); const auto SymRight = matchSymbolicExpr("rhs");
// Match expressions like: x <op> 0xFF == 0xF00. // Match expressions like: x <op> 0xFF == 0xF00.
Finder->addMatcher(binaryOperator(isComparisonOperator(), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(isComparisonOperator(),
hasEitherOperand(BinOpCstLeft), hasEitherOperand(BinOpCstLeft),
hasEitherOperand(CstRight)) hasEitherOperand(CstRight))
.bind("binop-const-compare-to-const"), .bind("binop-const-compare-to-const")),
this); this);
// Match expressions like: x <op> 0xFF == x. // Match expressions like: x <op> 0xFF == x.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(isComparisonOperator(), binaryOperator(isComparisonOperator(),
anyOf(allOf(hasLHS(BinOpCstLeft), hasRHS(SymRight)), anyOf(allOf(hasLHS(BinOpCstLeft), hasRHS(SymRight)),
allOf(hasLHS(SymRight), hasRHS(BinOpCstLeft)))) allOf(hasLHS(SymRight), hasRHS(BinOpCstLeft))))
.bind("binop-const-compare-to-sym"), .bind("binop-const-compare-to-sym")),
this); this);
// Match expressions like: x <op> 10 == x <op> 12. // Match expressions like: x <op> 10 == x <op> 12.
Finder->addMatcher(binaryOperator(isComparisonOperator(), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(isComparisonOperator(),
hasLHS(BinOpCstLeft), hasRHS(BinOpCstRight), hasLHS(BinOpCstLeft), hasRHS(BinOpCstRight),
// Already reported as redundant. // Already reported as redundant.
unless(operandsAreEquivalent())) unless(operandsAreEquivalent()))
.bind("binop-const-compare-to-binop-const"), .bind("binop-const-compare-to-binop-const")),
this); this);
// Match relational expressions combined with logical operators and find // Match relational expressions combined with logical operators and find
// redundant sub-expressions. // redundant sub-expressions.
// see: 'checkRelationalExpr' // see: 'checkRelationalExpr'
// Match expressions like: x < 2 && x > 2. // Match expressions like: x < 2 && x > 2.
const auto ComparisonLeft = matchRelationalIntegerConstantExpr("lhs"); const auto ComparisonLeft = matchRelationalIntegerConstantExpr("lhs");
const auto ComparisonRight = matchRelationalIntegerConstantExpr("rhs"); const auto ComparisonRight = matchRelationalIntegerConstantExpr("rhs");
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(anyOf(hasOperatorName("||"), hasOperatorName("&&")), binaryOperator(anyOf(hasOperatorName("||"), hasOperatorName("&&")),
hasLHS(ComparisonLeft), hasRHS(ComparisonRight), hasLHS(ComparisonLeft), hasRHS(ComparisonRight),
// Already reported as redundant. // Already reported as redundant.
unless(operandsAreEquivalent())) unless(operandsAreEquivalent()))
.bind("comparisons-of-symbol-and-const"), .bind("comparisons-of-symbol-and-const")),
this); this);
} }
void RedundantExpressionCheck::checkArithmeticExpr( void RedundantExpressionCheck::checkArithmeticExpr(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
APSInt LhsValue, RhsValue; APSInt LhsValue, RhsValue;
const Expr *LhsSymbol = nullptr, *RhsSymbol = nullptr; const Expr *LhsSymbol = nullptr, *RhsSymbol = nullptr;
BinaryOperatorKind LhsOpcode, RhsOpcode; BinaryOperatorKind LhsOpcode, RhsOpcode;
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

Show First 20 Lines • Show All 480 Lines • ▼ Show 20 Lines
void LoopConvertCheck::registerMatchers(MatchFinder *Finder) { void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++. Because this checker is used for // Only register the matchers for C++. Because this checker is used for
// modernization, it is reasonable to run it on any C++ standard with the // modernization, it is reasonable to run it on any C++ standard with the
// assumption the user is trying to modernize their codebase. // assumption the user is trying to modernize their codebase.
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher(makeArrayLoopMatcher(), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
Finder->addMatcher(makeIteratorLoopMatcher(), this); makeArrayLoopMatcher()), this);
Finder->addMatcher(makePseudoArrayLoopMatcher(), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
makeIteratorLoopMatcher()), this);
Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
makePseudoArrayLoopMatcher()), this);
} }
/// Given the range of a single declaration, such as: /// Given the range of a single declaration, such as:
/// \code /// \code
/// unsigned &ThisIsADeclarationThatCanSpanSeveralLinesOfCode = /// unsigned &ThisIsADeclarationThatCanSpanSeveralLinesOfCode =
/// InitializationValues[I]; /// InitializationValues[I];
/// next_instruction; /// next_instruction;
/// \endcode /// \endcode
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Linesbool LoopConvertCheck::isConvertible(ASTContext *Context,
return true; return true;
} }
void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) { void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {
const BoundNodes &Nodes = Result.Nodes; const BoundNodes &Nodes = Result.Nodes;
Confidence ConfidenceLevel(Confidence::CL_Safe); Confidence ConfidenceLevel(Confidence::CL_Safe);
ASTContext *Context = Result.Context; ASTContext *Context = Result.Context;
TraversalKindScope raii(*Context, ast_type_traits::TK_AsIs);
const ForStmt *Loop; const ForStmt *Loop;
LoopFixerKind FixerKind; LoopFixerKind FixerKind;
RangeDescriptor Descriptor; RangeDescriptor Descriptor;
if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameArray))) { if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameArray))) {
FixerKind = LFK_Array; FixerKind = LFK_Array;
} else if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameIterator))) { } else if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameIterator))) {
FixerKind = LFK_Iterator; FixerKind = LFK_Iterator;
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines if (!isLanguageVersionSupported(getLangOpts()))
return; return;
// Calling make_smart_ptr from within a member function of a type with a // Calling make_smart_ptr from within a member function of a type with a
// private or protected constructor would be ill-formed. // private or protected constructor would be ill-formed.
auto CanCallCtor = unless(has(ignoringImpCasts( auto CanCallCtor = unless(has(ignoringImpCasts(
cxxConstructExpr(hasDeclaration(decl(unless(isPublic()))))))); cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
cxxBindTemporaryExpr(has(ignoringParenImpCasts( cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr( cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1), hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
hasArgument(0, hasArgument(0,
cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType( cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
equalsBoundNode(PointerType))))), equalsBoundNode(PointerType))))),
CanCallCtor) CanCallCtor)
.bind(NewExpression)), .bind(NewExpression)),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind(ConstructorCall)))), .bind(ConstructorCall))))),
this); this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
cxxMemberCallExpr( cxxMemberCallExpr(
thisPointerType(getSmartPointerTypeMatcher()), thisPointerType(getSmartPointerTypeMatcher()),
callee(cxxMethodDecl(hasName("reset"))), callee(cxxMethodDecl(hasName("reset"))),
hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)), hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind(ResetCall), .bind(ResetCall)),
this); this);
} }
void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) { void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
// 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other // 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
// pointer, 'make_smart_ptr' refers to 'std::make_shared' or // pointer, 'make_smart_ptr' refers to 'std::make_shared' or
// 'std::make_unique' or other function that creates smart_ptr. // 'std::make_unique' or other function that creates smart_ptr.
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
SourceManager &SM = *Result.SourceManager; SourceManager &SM = *Result.SourceManager;
const auto *Construct = const auto *Construct =
Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructorCall); Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructorCall);
const auto *Reset = Result.Nodes.getNodeAs<CXXMemberCallExpr>(ResetCall); const auto *Reset = Result.Nodes.getNodeAs<CXXMemberCallExpr>(ResetCall);
const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType); const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType);
const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression); const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression);
if (New->getNumPlacementArgs() != 0) if (New->getNumPlacementArgs() != 0)
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
void PassByValueCheck::registerMatchers(MatchFinder *Finder) { void PassByValueCheck::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;
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
forEachConstructorInitializer( forEachConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
unless(isBaseInitializer()), unless(isBaseInitializer()),
// Clang builds a CXXConstructExpr only when it knows which // Clang builds a CXXConstructExpr only when it knows which
// constructor will be called. In dependent contexts a // constructor will be called. In dependent contexts a
// ParenListExpr is generated instead of a CXXConstructExpr, // ParenListExpr is generated instead of a CXXConstructExpr,
// filtering out templates automatically for us. // filtering out templates automatically for us.
withInitializer(cxxConstructExpr( withInitializer(cxxConstructExpr(
has(ignoringParenImpCasts(declRefExpr(to( has(ignoringParenImpCasts(declRefExpr(to(
parmVarDecl( parmVarDecl(
hasType(qualType( hasType(qualType(
// Match only const-ref or a non-const value // Match only const-ref or a non-const value
// parameters. Rvalues and const-values // parameters. Rvalues and const-values
// shouldn't be modified. // shouldn't be modified.
ValuesOnly ? nonConstValueType() ValuesOnly ? nonConstValueType()
: anyOf(constRefType(), : anyOf(constRefType(),
nonConstValueType())))) nonConstValueType()))))
.bind("Param"))))), .bind("Param"))))),
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), unless(isDeleted()), isCopyConstructor(), unless(isDeleted()),
hasDeclContext( hasDeclContext(
cxxRecordDecl(isMoveConstructible()))))))) cxxRecordDecl(isMoveConstructible())))))))
.bind("Initializer"))) .bind("Initializer")))
.bind("Ctor"), .bind("Ctor")),
this); this);
} }
void PassByValueCheck::registerPPCallbacks(const SourceManager &SM, void PassByValueCheck::registerPPCallbacks(const SourceManager &SM,
Preprocessor *PP, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) { Preprocessor *ModuleExpanderPP) {
// Only register the preprocessor callbacks for C++; the functionality // Only register the preprocessor callbacks for C++; the functionality
// currently does not provide any benefit to other languages, despite being // currently does not provide any benefit to other languages, despite being
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Linesvoid ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
// std::auto_ptr<int> a; // std::auto_ptr<int> a;
// ^~~~~~~~~~~~~ // ^~~~~~~~~~~~~
// //
// typedef std::auto_ptr<int> int_ptr_t; // typedef std::auto_ptr<int> int_ptr_t;
// ^~~~~~~~~~~~~ // ^~~~~~~~~~~~~
// //
// std::auto_ptr<int> fn(std::auto_ptr<int>); // std::auto_ptr<int> fn(std::auto_ptr<int>);
// ^~~~~~~~~~~~~ ^~~~~~~~~~~~~ // ^~~~~~~~~~~~~ ^~~~~~~~~~~~~
Finder->addMatcher(typeLoc(loc(qualType(AutoPtrType, Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
typeLoc(loc(qualType(AutoPtrType,
// Skip elaboratedType() as the named // Skip elaboratedType() as the named
// type will match soon thereafter. // type will match soon thereafter.
unless(elaboratedType())))) unless(elaboratedType()))))
.bind(AutoPtrTokenId), .bind(AutoPtrTokenId)),
this); this);
// using std::auto_ptr; // using std::auto_ptr;
// ^~~~~~~~~~~~~~~~~~~ // ^~~~~~~~~~~~~~~~~~~
Finder->addMatcher(usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(namedDecl( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(namedDecl(
hasName("auto_ptr"), isFromStdNamespace())))) hasName("auto_ptr"), isFromStdNamespace()))))
.bind(AutoPtrTokenId), .bind(AutoPtrTokenId)),
this); this);
// Find ownership transfers via copy construction and assignment. // Find ownership transfers via copy construction and assignment.
// AutoPtrOwnershipTransferId is bound to the part that has to be wrapped // AutoPtrOwnershipTransferId is bound to the part that has to be wrapped
// into std::move(). // into std::move().
// std::auto_ptr<int> i, j; // std::auto_ptr<int> i, j;
// i = j; // i = j;
// ~~~~^ // ~~~~^
auto MovableArgumentMatcher = auto MovableArgumentMatcher =
expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId); expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId);
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxOperatorCallExpr(hasOverloadedOperatorName("="), cxxOperatorCallExpr(hasOverloadedOperatorName("="),
callee(cxxMethodDecl(ofClass(AutoPtrDecl))), callee(cxxMethodDecl(ofClass(AutoPtrDecl))),
hasArgument(1, MovableArgumentMatcher)), hasArgument(1, MovableArgumentMatcher))),
this); this);
Finder->addMatcher(cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
hasArgument(0, MovableArgumentMatcher)), cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
hasArgument(0, MovableArgumentMatcher))),
this); this);
} }
void ReplaceAutoPtrCheck::registerPPCallbacks(const SourceManager &SM, void ReplaceAutoPtrCheck::registerPPCallbacks(const SourceManager &SM,
Preprocessor *PP, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) { Preprocessor *ModuleExpanderPP) {
// Only register the preprocessor callbacks for C++; the functionality // Only register the preprocessor callbacks for C++; the functionality
// currently does not provide any benefit to other languages, despite being // currently does not provide any benefit to other languages, despite being
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp

Show All 27 Lines
void ReplaceRandomShuffleCheck::registerMatchers(MatchFinder *Finder) { void ReplaceRandomShuffleCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus11) if (!getLangOpts().CPlusPlus11)
return; return;
const auto Begin = hasArgument(0, expr()); const auto Begin = hasArgument(0, expr());
const auto End = hasArgument(1, expr()); const auto End = hasArgument(1, expr());
const auto RandomFunc = hasArgument(2, expr().bind("randomFunc")); const auto RandomFunc = hasArgument(2, expr().bind("randomFunc"));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
callExpr(anyOf(allOf(Begin, End, argumentCountIs(2)), callExpr(anyOf(allOf(Begin, End, argumentCountIs(2)),
allOf(Begin, End, RandomFunc, argumentCountIs(3))), allOf(Begin, End, RandomFunc, argumentCountIs(3))),
hasDeclaration(functionDecl(hasName("::std::random_shuffle"))), hasDeclaration(functionDecl(hasName("::std::random_shuffle"))),
has(implicitCastExpr(has(declRefExpr().bind("name"))))) has(implicitCastExpr(has(declRefExpr().bind("name")))))
.bind("match"), .bind("match")),
this); this);
} }
void ReplaceRandomShuffleCheck::registerPPCallbacks( void ReplaceRandomShuffleCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
IncludeInserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(), IncludeInserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
IncludeStyle); IncludeStyle);
PP->addPPCallbacks(IncludeInserter->CreatePPCallbacks()); PP->addPPCallbacks(IncludeInserter->CreatePPCallbacks());
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.cpp

Show All 28 Lines auto ConstructExpr =
unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())), unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())),
isListInitialization(), hasDescendant(initListExpr()), isListInitialization(), hasDescendant(initListExpr()),
isInTemplateInstantiation()))) isInTemplateInstantiation())))
.bind("ctor"); .bind("ctor");
auto CtorAsArgument = materializeTemporaryExpr(anyOf( auto CtorAsArgument = materializeTemporaryExpr(anyOf(
has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr))))); has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr)))));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
functionDecl(isDefinition(), // Declarations don't have return statements. functionDecl(isDefinition(), // Declarations don't have return statements.
returns(unless(anyOf(builtinType(), autoType()))), returns(unless(anyOf(builtinType(), autoType()))),
hasDescendant(returnStmt(hasReturnValue( hasDescendant(returnStmt(hasReturnValue(
has(cxxConstructExpr(has(CtorAsArgument))))))) has(cxxConstructExpr(has(CtorAsArgument)))))))
.bind("fn"), .bind("fn")),
this); this);
} }
void ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) { void ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedFunctionDecl = Result.Nodes.getNodeAs<FunctionDecl>("fn"); const auto *MatchedFunctionDecl = Result.Nodes.getNodeAs<FunctionDecl>("fn");
const auto *MatchedConstructExpr = const auto *MatchedConstructExpr =
Result.Nodes.getNodeAs<CXXConstructExpr>("ctor"); Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/ShrinkToFitCheck.cpp

Show All 34 Linesvoid ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {
const auto SwapParam = const auto SwapParam =
expr(anyOf(memberExpr(member(equalsBoundNode("ContainerDecl"))), expr(anyOf(memberExpr(member(equalsBoundNode("ContainerDecl"))),
declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl"))), declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl"))),
unaryOperator(has(ignoringParenImpCasts( unaryOperator(has(ignoringParenImpCasts(
memberExpr(member(equalsBoundNode("ContainerDecl")))))), memberExpr(member(equalsBoundNode("ContainerDecl")))))),
unaryOperator(has(ignoringParenImpCasts(declRefExpr( unaryOperator(has(ignoringParenImpCasts(declRefExpr(
hasDeclaration(equalsBoundNode("ContainerDecl")))))))); hasDeclaration(equalsBoundNode("ContainerDecl"))))))));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxMemberCallExpr( cxxMemberCallExpr(
on(hasType(hasCanonicalType(hasDeclaration(namedDecl( on(hasType(hasCanonicalType(hasDeclaration(namedDecl(
hasAnyName("std::basic_string", "std::deque", "std::vector")))))), hasAnyName("std::basic_string", "std::deque", "std::vector")))))),
callee(cxxMethodDecl(hasName("swap"))), callee(cxxMethodDecl(hasName("swap"))),
has(ignoringParenImpCasts(memberExpr(hasDescendant(CopyCtorCall)))), has(ignoringParenImpCasts(memberExpr(hasDescendant(CopyCtorCall)))),
hasArgument(0, SwapParam.bind("ContainerToShrink")), hasArgument(0, SwapParam.bind("ContainerToShrink")),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("CopyAndSwapTrick"), .bind("CopyAndSwapTrick")),
this); this);
} }
void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) { void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MemberCall = const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick");
const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink"); const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
FixItHint Hint; FixItHint Hint;
Show All 30 Lines

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

Show First 20 Lines • Show All 322 Lines • ▼ Show 20 Linesvoid UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MinTypeNameLength", MinTypeNameLength); Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0); Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);
} }
void UseAutoCheck::registerMatchers(MatchFinder *Finder) { void UseAutoCheck::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) {
Finder->addMatcher(makeCombinedMatcher(), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
makeCombinedMatcher()), this);
} }
} }
void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) { void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
for (const auto *Dec : D->decls()) { for (const auto *Dec : D->decls()) {
const auto *V = cast<VarDecl>(Dec); const auto *V = cast<VarDecl>(Dec);
const Expr *ExprInit = V->getInit(); const Expr *ExprInit = V->getInit();
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.cpp

Show All 21 LinesUseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name,
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) { void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
has(ignoringParenImpCasts(integerLiteral().bind("literal"))), has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasImplicitDestinationType(qualType(booleanType())), hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
anyOf(hasParent(explicitCastExpr().bind("cast")), anything())), anyOf(hasParent(explicitCastExpr().bind("cast")), anything()))),
this); this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
conditionalOperator( conditionalOperator(
hasParent(implicitCastExpr( hasParent(implicitCastExpr(
hasImplicitDestinationType(qualType(booleanType())), hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()))), unless(isInTemplateInstantiation()))),
eachOf(hasTrueExpression( eachOf(hasTrueExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))), ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasFalseExpression( hasFalseExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))))), ignoringParenImpCasts(
integerLiteral().bind("literal")))))),
this); this);
} }
void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) { void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("literal"); const auto *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("literal");
const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast"); const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
bool LiteralBooleanValue = Literal->getValue().getBoolValue(); bool LiteralBooleanValue = Literal->getValue().getBoolValue();
Show All 22 Lines

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines auto MakeTupleCtor = ignoringImplicit(cxxConstructExpr(
has(materializeTemporaryExpr(MakeTuple)), has(materializeTemporaryExpr(MakeTuple)),
hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName( hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
SmallVector<StringRef, 2>(TupleTypes.begin(), TupleTypes.end()))))))); SmallVector<StringRef, 2>(TupleTypes.begin(), TupleTypes.end())))))));
auto SoughtParam = materializeTemporaryExpr( auto SoughtParam = materializeTemporaryExpr(
anyOf(has(MakeTuple), has(MakeTupleCtor), anyOf(has(MakeTuple), has(MakeTupleCtor),
HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr)))); HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr))));
Finder->addMatcher(cxxMemberCallExpr(CallPushBack, has(SoughtParam), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxMemberCallExpr(CallPushBack, has(SoughtParam),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("call"), .bind("call")),
this); this);
} }
void UseEmplaceCheck::check(const MatchFinder::MatchResult &Result) { void UseEmplaceCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call"); const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor"); const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
const auto *MakeCall = Result.Nodes.getNodeAs<CallExpr>("make"); const auto *MakeCall = Result.Nodes.getNodeAs<CallExpr>("make");
assert((CtorCall || MakeCall) && "No push_back parameter matched"); assert((CtorCall || MakeCall) && "No push_back parameter matched");
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linesstatic bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
// Base classes and members that have to be copied. // Base classes and members that have to be copied.
auto BasesToInit = getAllDirectBases(Record); auto BasesToInit = getAllDirectBases(Record);
auto FieldsToInit = getAllNamedFields(Record); auto FieldsToInit = getAllNamedFields(Record);
// Ensure that all the bases are copied. // Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) { for (const auto *Base : BasesToInit) {
// The initialization of a base class should be a call to a copy // The initialization of a base class should be a call to a copy
// constructor of the base. // constructor of the base.
if (match( if (match(traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer( cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(), isBaseInitializer(),
withInitializer(cxxConstructExpr( withInitializer(cxxConstructExpr(
hasType(equalsNode(Base)), hasType(equalsNode(Base)),
hasDeclaration(cxxConstructorDecl(isCopyConstructor())), hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1), argumentCountIs(1),
hasArgument( hasArgument(
0, declRefExpr(to(varDecl(equalsNode(Param)))))))))), 0, declRefExpr(to(varDecl(equalsNode(Param))))))))))),
*Ctor, *Context) *Ctor, *Context)
.empty()) .empty())
return false; return false;
} }
// Ensure that all the members are copied. // Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) { for (const auto *Field : FieldsToInit) {
auto AccessToFieldInParam = accessToFieldInVar(Field, Param); auto AccessToFieldInParam = accessToFieldInVar(Field, Param);
// The initialization is a CXXConstructExpr for class types. // The initialization is a CXXConstructExpr for class types.
if (match( if (match(traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer( cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isMemberInitializer(), forField(equalsNode(Field)), isMemberInitializer(), forField(equalsNode(Field)),
withInitializer(anyOf( withInitializer(anyOf(
AccessToFieldInParam, AccessToFieldInParam,
initListExpr(has(AccessToFieldInParam)), initListExpr(has(AccessToFieldInParam)),
cxxConstructExpr( cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())), hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1), argumentCountIs(1),
hasArgument(0, AccessToFieldInParam))))))), hasArgument(0, AccessToFieldInParam)))))))),
*Ctor, *Context) *Ctor, *Context)
.empty()) .empty())
return false; return false;
} }
// Ensure that we don't do anything else, like initializing an indirect base. // Ensure that we don't do anything else, like initializing an indirect base.
return Ctor->getNumCtorInitializers() == return Ctor->getNumCtorInitializers() ==
BasesToInit.size() + FieldsToInit.size(); BasesToInit.size() + FieldsToInit.size();
Show All 12 Linesstatic bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
auto FieldsToInit = getAllNamedFields(Record); auto FieldsToInit = getAllNamedFields(Record);
const auto *Compound = cast<CompoundStmt>(Operator->getBody()); const auto *Compound = cast<CompoundStmt>(Operator->getBody());
// The assignment operator definition has to end with the following return // The assignment operator definition has to end with the following return
// statement: // statement:
// return *this; // return *this;
if (Compound->body_empty() || if (Compound->body_empty() ||
match(returnStmt(has(ignoringParenImpCasts(unaryOperator( match(traverse(ast_type_traits::TK_AsIs,
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))), returnStmt(has(ignoringParenImpCasts(unaryOperator(
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())))))),
*Compound->body_back(), *Context) *Compound->body_back(), *Context)
.empty()) .empty())
return false; return false;
// Ensure that all the bases are copied. // Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) { for (const auto *Base : BasesToInit) {
// Assignment operator of a base class: // Assignment operator of a base class:
// Base::operator=(Other); // Base::operator=(Other);
// //
// Clang translates this into: // Clang translates this into:
// ((Base*)this)->operator=((Base)Other); // ((Base*)this)->operator=((Base)Other);
// //
// So we are looking for a member call that fulfills: // So we are looking for a member call that fulfills:
if (match( if (match(traverse(ast_type_traits::TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr( compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(
// - The object is an implicit cast of 'this' to a pointer to // - The object is an implicit cast of 'this' to a pointer to
// a base class. // a base class.
onImplicitObjectArgument( onImplicitObjectArgument(
implicitCastExpr(hasImplicitDestinationType( implicitCastExpr(hasImplicitDestinationType(
pointsTo(type(equalsNode(Base)))), pointsTo(type(equalsNode(Base)))),
hasSourceExpression(cxxThisExpr()))), hasSourceExpression(cxxThisExpr()))),
// - The called method is the operator=. // - The called method is the operator=.
callee(cxxMethodDecl(isCopyAssignmentOperator())), callee(cxxMethodDecl(isCopyAssignmentOperator())),
// - The argument is (an implicit cast to a Base of) the // - The argument is (an implicit cast to a Base of) the
// argument taken by "Operator". // argument taken by "Operator".
argumentCountIs(1), argumentCountIs(1),
hasArgument(0, declRefExpr(to(varDecl(equalsNode(Param))))))))), hasArgument(0,
declRefExpr(to(varDecl(equalsNode(Param)))))))))),
*Compound, *Context) *Compound, *Context)
.empty()) .empty())
return false; return false;
} }
// Ensure that all the members are copied. // Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) { for (const auto *Field : FieldsToInit) {
// The assignment of data members: // The assignment of data members:
// Field = Other.Field; // Field = Other.Field;
// Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr // Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr
// otherwise. // otherwise.
auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()), auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
member(fieldDecl(equalsNode(Field)))); member(fieldDecl(equalsNode(Field))));
auto RHS = accessToFieldInVar(Field, Param); auto RHS = accessToFieldInVar(Field, Param);
if (match( if (match(traverse(ast_type_traits::TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(stmt(anyOf( compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)), binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)),
cxxOperatorCallExpr(hasOverloadedOperatorName("="), cxxOperatorCallExpr(hasOverloadedOperatorName("="),
argumentCountIs(2), hasArgument(0, LHS), argumentCountIs(2), hasArgument(0, LHS),
hasArgument(1, RHS))))))), hasArgument(1, RHS)))))))),
*Compound, *Context) *Compound, *Context)
.empty()) .empty())
return false; return false;
} }
// Ensure that we don't do anything else. // Ensure that we don't do anything else.
return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1; return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
} }
Show All 17 Linesvoid UseEqualsDefaultCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
} }
void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) { void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
// Destructor. // Destructor.
Finder->addMatcher(cxxDestructorDecl(isDefinition()).bind(SpecialFunction), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxDestructorDecl(isDefinition()).bind(SpecialFunction)),
this); this);
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
isDefinition(), isDefinition(),
anyOf( anyOf(
// Default constructor. // Default constructor.
allOf(unless(hasAnyConstructorInitializer(isWritten())), allOf(unless(hasAnyConstructorInitializer(isWritten())),
parameterCountIs(0)), parameterCountIs(0)),
// Copy constructor. // Copy constructor.
allOf(isCopyConstructor(), allOf(isCopyConstructor(),
// Discard constructors that can be used as a copy // Discard constructors that can be used as a copy
// constructor because all the other arguments have // constructor because all the other arguments have
// default values. // default values.
parameterCountIs(1)))) parameterCountIs(1))))
.bind(SpecialFunction), .bind(SpecialFunction)),
this); this);
// Copy-assignment operator. // Copy-assignment operator.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxMethodDecl(isDefinition(), isCopyAssignmentOperator(), cxxMethodDecl(isDefinition(), isCopyAssignmentOperator(),
// isCopyAssignmentOperator() allows the parameter to be // isCopyAssignmentOperator() allows the parameter to be
// passed by value, and in this case it cannot be // passed by value, and in this case it cannot be
// defaulted. // defaulted.
hasParameter(0, hasType(lValueReferenceType()))) hasParameter(0, hasType(lValueReferenceType())))
.bind(SpecialFunction), .bind(SpecialFunction)),
this); this);
} }
void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) { void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) {
std::string SpecialFunctionName; std::string SpecialFunctionName;
// Both CXXConstructorDecl and CXXDestructorDecl inherit from CXXMethodDecl. // Both CXXConstructorDecl and CXXDestructorDecl inherit from CXXMethodDecl.
const auto *SpecialFunctionDecl = const auto *SpecialFunctionDecl =
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

Show First 20 Lines • Show All 471 Lines • ▼ Show 20 Linesvoid UseNullptrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "NullMacros", NullMacrosStr); Options.store(Opts, "NullMacros", NullMacrosStr);
} }
void UseNullptrCheck::registerMatchers(MatchFinder *Finder) { void UseNullptrCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matcher for C++. Because this checker is used for // Only register the matcher for C++. Because this checker is used for
// modernization, it is reasonable to run it on any C++ standard with the // modernization, it is reasonable to run it on any C++ standard with the
// assumption the user is trying to modernize their codebase. // assumption the user is trying to modernize their codebase.
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
Finder->addMatcher(makeCastSequenceMatcher(), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
makeCastSequenceMatcher()), this);
} }
void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) { void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) {
const auto *NullCast = Result.Nodes.getNodeAs<CastExpr>(CastSequence); const auto *NullCast = Result.Nodes.getNodeAs<CastExpr>(CastSequence);
assert(NullCast && "Bad Callback. No node provided"); assert(NullCast && "Bad Callback. No node provided");
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
// Given an implicit null-ptr cast or an explicit cast with an implicit // Given an implicit null-ptr cast or an explicit cast with an implicit
// null-to-pointer cast within use CastSequenceVisitor to identify sequences // null-to-pointer cast within use CastSequenceVisitor to identify sequences
// of explicit casts that can be converted into 'nullptr'. // of explicit casts that can be converted into 'nullptr'.
CastSequenceVisitor(*Result.Context, NullMacros, *this) CastSequenceVisitor(*Result.Context, NullMacros, *this)
.TraverseStmt(const_cast<CastExpr *>(NullCast)); .TraverseStmt(const_cast<CastExpr *>(NullCast));
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp

Show All 37 Linesvoid ForRangeCopyCheck::registerMatchers(MatchFinder *Finder) {
// initialized through MaterializeTemporaryExpr which indicates a type // initialized through MaterializeTemporaryExpr which indicates a type
// conversion. // conversion.
auto LoopVar = varDecl( auto LoopVar = varDecl(
hasType(qualType( hasType(qualType(
unless(anyOf(hasCanonicalType(anyOf(referenceType(), pointerType())), unless(anyOf(hasCanonicalType(anyOf(referenceType(), pointerType())),
hasDeclaration(namedDecl( hasDeclaration(namedDecl(
matchers::matchesAnyListedName(AllowedTypes))))))), matchers::matchesAnyListedName(AllowedTypes))))))),
unless(hasInitializer(expr(hasDescendant(materializeTemporaryExpr()))))); unless(hasInitializer(expr(hasDescendant(materializeTemporaryExpr())))));
Finder->addMatcher(cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar"))) Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
.bind("forRange"), cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar")))
.bind("forRange")),
this); this);
} }
void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) { void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar"); const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar");
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
// Ignore code in macros since we can't place the fixes correctly. // Ignore code in macros since we can't place the fixes correctly.
if (Var->getBeginLoc().isMacroID()) if (Var->getBeginLoc().isMacroID())
return; return;
if (handleConstValueCopy(*Var, *Result.Context)) if (handleConstValueCopy(*Var, *Result.Context))
return; return;
const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange"); const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange");
handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context); handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context);
} }
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp

Show All 40 Linesvoid ImplicitConversionInLoopCheck::registerMatchers(MatchFinder *Finder) {
// type in the diagnostic message. We use both cxxOperatorCallExpr for user // type in the diagnostic message. We use both cxxOperatorCallExpr for user
// defined operator and unaryOperator when the iterator is a pointer, like // defined operator and unaryOperator when the iterator is a pointer, like
// for arrays or std::array. // for arrays or std::array.
// //
// Note that when the implicit conversion is done through a user defined // Note that when the implicit conversion is done through a user defined
// conversion operator, the node is a CXXMemberCallExpr, not a // conversion operator, the node is a CXXMemberCallExpr, not a
// CXXOperatorCallExpr, so it should not get caught by the // CXXOperatorCallExpr, so it should not get caught by the
// cxxOperatorCallExpr() matcher. // cxxOperatorCallExpr() matcher.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxForRangeStmt(hasLoopVariable( cxxForRangeStmt(hasLoopVariable(
varDecl( varDecl(
hasType(qualType(references(qualType(isConstQualified())))), hasType(qualType(references(qualType(isConstQualified())))),
hasInitializer( hasInitializer(
expr(anyOf(hasDescendant( expr(anyOf(hasDescendant(
cxxOperatorCallExpr().bind("operator-call")), cxxOperatorCallExpr().bind("operator-call")),
hasDescendant(unaryOperator(hasOperatorName("*")) hasDescendant(unaryOperator(hasOperatorName("*"))
.bind("operator-call")))) .bind("operator-call"))))
.bind("init"))) .bind("init")))
.bind("faulty-var"))), .bind("faulty-var")))),
this); this);
} }
void ImplicitConversionInLoopCheck::check( void ImplicitConversionInLoopCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *VD = Result.Nodes.getNodeAs<VarDecl>("faulty-var"); const auto *VD = Result.Nodes.getNodeAs<VarDecl>("faulty-var");
const auto *Init = Result.Nodes.getNodeAs<Expr>("init"); const auto *Init = Result.Nodes.getNodeAs<Expr>("init");
const auto *OperatorCall = const auto *OperatorCall =
Show All 36 Lines

clang-tools-extra/clang-tidy/performance/InefficientAlgorithmCheck.cpp

Show All 34 Linesvoid InefficientAlgorithmCheck::registerMatchers(MatchFinder *Finder) {
const auto Algorithms = const auto Algorithms =
hasAnyName("::std::find", "::std::count", "::std::equal_range", hasAnyName("::std::find", "::std::count", "::std::equal_range",
"::std::lower_bound", "::std::upper_bound"); "::std::lower_bound", "::std::upper_bound");
const auto ContainerMatcher = classTemplateSpecializationDecl(hasAnyName( const auto ContainerMatcher = classTemplateSpecializationDecl(hasAnyName(
"::std::set", "::std::map", "::std::multiset", "::std::multimap", "::std::set", "::std::map", "::std::multiset", "::std::multimap",
"::std::unordered_set", "::std::unordered_map", "::std::unordered_set", "::std::unordered_map",
"::std::unordered_multiset", "::std::unordered_multimap")); "::std::unordered_multiset", "::std::unordered_multimap"));
const auto Matcher = const auto Matcher = traverse(ast_type_traits::TK_AsIs,
callExpr( callExpr(
callee(functionDecl(Algorithms)), callee(functionDecl(Algorithms)),
hasArgument( hasArgument(
0, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr( 0, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
callee(cxxMethodDecl(hasName("begin"))), callee(cxxMethodDecl(hasName("begin"))),
on(declRefExpr( on(declRefExpr(
hasDeclaration(decl().bind("IneffContObj")), hasDeclaration(decl().bind("IneffContObj")),
anyOf(hasType(ContainerMatcher.bind("IneffCont")), anyOf(hasType(ContainerMatcher.bind("IneffCont")),
hasType(pointsTo( hasType(pointsTo(
ContainerMatcher.bind("IneffContPtr"))))) ContainerMatcher.bind("IneffContPtr")))))
.bind("IneffContExpr"))))))), .bind("IneffContExpr"))))))),
hasArgument( hasArgument(
1, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr( 1, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
callee(cxxMethodDecl(hasName("end"))), callee(cxxMethodDecl(hasName("end"))),
on(declRefExpr( on(declRefExpr(
hasDeclaration(equalsBoundNode("IneffContObj"))))))))), hasDeclaration(equalsBoundNode("IneffContObj"))))))))),
hasArgument(2, expr().bind("AlgParam")), hasArgument(2, expr().bind("AlgParam")),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("IneffAlg"); .bind("IneffAlg"));
Finder->addMatcher(Matcher, this); Finder->addMatcher(Matcher, this);
} }
void InefficientAlgorithmCheck::check(const MatchFinder::MatchResult &Result) { void InefficientAlgorithmCheck::check(const MatchFinder::MatchResult &Result) {
const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("IneffAlg"); const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("IneffAlg");
const auto *IneffCont = const auto *IneffCont =
Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("IneffCont"); Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("IneffCont");
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid MoveConstArgCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
auto MoveCallMatcher = auto MoveCallMatcher =
callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1), callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("call-move"); .bind("call-move");
Finder->addMatcher(MoveCallMatcher, this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
MoveCallMatcher), this);
auto ConstParamMatcher = forEachArgumentWithParam( auto ConstParamMatcher = forEachArgumentWithParam(
MoveCallMatcher, parmVarDecl(hasType(references(isConstQualified())))); MoveCallMatcher, parmVarDecl(hasType(references(isConstQualified()))));
Finder->addMatcher(callExpr(ConstParamMatcher).bind("receiving-expr"), this); Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
Finder->addMatcher(cxxConstructExpr(ConstParamMatcher).bind("receiving-expr"), callExpr(ConstParamMatcher).bind("receiving-expr")), this);
Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructExpr(ConstParamMatcher).bind("receiving-expr")),
this); this);
} }
void MoveConstArgCheck::check(const MatchFinder::MatchResult &Result) { void MoveConstArgCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move"); const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
const auto *ReceivingExpr = Result.Nodes.getNodeAs<Expr>("receiving-expr"); const auto *ReceivingExpr = Result.Nodes.getNodeAs<Expr>("receiving-expr");
const Expr *Arg = CallMove->getArg(0); const Expr *Arg = CallMove->getArg(0);
SourceManager &SM = Result.Context->getSourceManager(); SourceManager &SM = Result.Context->getSourceManager();
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp

Show All 26 Lines : ClangTidyCheck(Name, Context),
Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {} Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) { void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++11; the functionality currently does not // Only register the matchers for C++11; 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().CPlusPlus11) if (!getLangOpts().CPlusPlus11)
return; return;
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
unless(isImplicit()), isMoveConstructor(), unless(isImplicit()), isMoveConstructor(),
hasAnyConstructorInitializer( hasAnyConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
withInitializer(cxxConstructExpr(hasDeclaration( withInitializer(cxxConstructExpr(hasDeclaration(
cxxConstructorDecl(isCopyConstructor()).bind("ctor"))))) cxxConstructorDecl(isCopyConstructor()).bind("ctor")))))
.bind("move-init"))), .bind("move-init")))),
this); this);
} }
void MoveConstructorInitCheck::check(const MatchFinder::MatchResult &Result) { void MoveConstructorInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor"); const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
const auto *Initializer = const auto *Initializer =
Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init"); Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesvoid NoAutomaticMoveCheck::registerMatchers(MatchFinder *Finder) {
// `DstT::DstT(Src&&)`. // `DstT::DstT(Src&&)`.
const auto LValueRefCtor = cxxConstructorDecl( const auto LValueRefCtor = cxxConstructorDecl(
hasParameter(0, hasParameter(0,
hasType(lValueReferenceType(pointee(type().bind("SrcT"))))), hasType(lValueReferenceType(pointee(type().bind("SrcT"))))),
ofClass(cxxRecordDecl(hasMethod(cxxConstructorDecl( ofClass(cxxRecordDecl(hasMethod(cxxConstructorDecl(
hasParameter(0, hasType(rValueReferenceType( hasParameter(0, hasType(rValueReferenceType(
pointee(type(equalsBoundNode("SrcT"))))))))))); pointee(type(equalsBoundNode("SrcT")))))))))));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
returnStmt( returnStmt(
hasReturnValue(ignoringElidableConstructorCall(ignoringParenImpCasts( hasReturnValue(ignoringElidableConstructorCall(ignoringParenImpCasts(
cxxConstructExpr(hasDeclaration(LValueRefCtor), cxxConstructExpr(hasDeclaration(LValueRefCtor),
hasArgument(0, ignoringParenImpCasts(declRefExpr( hasArgument(0, ignoringParenImpCasts(declRefExpr(
to(ConstLocalVariable))))) to(ConstLocalVariable)))))
.bind("ctor_call"))))), .bind("ctor_call")))))),
this); this);
} }
void NoAutomaticMoveCheck::check(const MatchFinder::MatchResult &Result) { void NoAutomaticMoveCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("vardecl"); const auto *Var = Result.Nodes.getNodeAs<VarDecl>("vardecl");
const auto *CtorCall = Result.Nodes.getNodeAs<Expr>("ctor_call"); const auto *CtorCall = Result.Nodes.getNodeAs<Expr>("ctor_call");
diag(CtorCall->getExprLoc(), "constness of '%0' prevents automatic move") diag(CtorCall->getExprLoc(), "constness of '%0' prevents automatic move")
<< Var->getName(); << Var->getName();
Show All 10 Lines

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines return compoundStmt(
isCopyConstructor())), isCopyConstructor())),
hasArgument(0, CopyCtorArg)) hasArgument(0, CopyCtorArg))
.bind("ctorCall"))) .bind("ctorCall")))
.bind("newVarDecl"))) .bind("newVarDecl")))
.bind("declStmt"))) .bind("declStmt")))
.bind("blockStmt"); .bind("blockStmt");
}; };
Finder->addMatcher(localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall, Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
ConstRefReturningMethodCall)), localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall,
ConstRefReturningMethodCall))),
this); this);
Finder->addMatcher(localVarCopiedFrom(declRefExpr( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
to(varDecl(hasLocalStorage()).bind("oldVarDecl")))), localVarCopiedFrom(declRefExpr(
to(varDecl(hasLocalStorage()).bind("oldVarDecl"))))),
this); this);
} }
void UnnecessaryCopyInitialization::check( void UnnecessaryCopyInitialization::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *NewVar = Result.Nodes.getNodeAs<VarDecl>("newVarDecl"); const auto *NewVar = Result.Nodes.getNodeAs<VarDecl>("newVarDecl");
const auto *OldVar = Result.Nodes.getNodeAs<VarDecl>("oldVarDecl"); const auto *OldVar = Result.Nodes.getNodeAs<VarDecl>("oldVarDecl");
const auto *ObjectArg = Result.Nodes.getNodeAs<VarDecl>("objectArg"); const auto *ObjectArg = Result.Nodes.getNodeAs<VarDecl>("objectArg");
const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt"); const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt");
const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctorCall"); const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctorCall");
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
// Do not propose fixes if the DeclStmt has multiple VarDecls or in macros // Do not propose fixes if the DeclStmt has multiple VarDecls or in macros
// since we cannot place them correctly. // since we cannot place them correctly.
bool IssueFix = bool IssueFix =
Result.Nodes.getNodeAs<DeclStmt>("declStmt")->isSingleDecl() && Result.Nodes.getNodeAs<DeclStmt>("declStmt")->isSingleDecl() &&
!NewVar->getLocation().isMacroID(); !NewVar->getLocation().isMacroID();
// A constructor that looks like T(const T& t, bool arg = false) counts as a // A constructor that looks like T(const T& t, bool arg = false) counts as a
// copy only when it is called with default arguments for the arguments after // copy only when it is called with default arguments for the arguments after
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

Show All 36 Lines auto Matches = match(declRefExpr(to(functionDecl(equalsNode(&Function))),
unless(hasAncestor(callExpr()))), unless(hasAncestor(callExpr()))),
Context); Context);
return !Matches.empty(); return !Matches.empty();
} }
bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl, bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
ASTContext &Context) { ASTContext &Context) {
auto Matches = auto Matches =
match(decl(forEachDescendant(declRefExpr( match(traverse(ast_type_traits::TK_AsIs,
decl(forEachDescendant(declRefExpr(
equalsNode(&DeclRef), equalsNode(&DeclRef),
unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(), unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(),
whileStmt(), doStmt()))))))), whileStmt(), doStmt())))))))),
Decl, Context); Decl, Context);
return Matches.empty(); return Matches.empty();
} }
bool isExplicitTemplateSpecialization(const FunctionDecl &Function) { bool isExplicitTemplateSpecialization(const FunctionDecl &Function) {
if (const auto *SpecializationInfo = Function.getTemplateSpecializationInfo()) if (const auto *SpecializationInfo = Function.getTemplateSpecializationInfo())
if (SpecializationInfo->getTemplateSpecializationKind() == if (SpecializationInfo->getTemplateSpecializationKind() ==
TSK_ExplicitSpecialization) TSK_ExplicitSpecialization)
Show All 22 Lines if (!getLangOpts().CPlusPlus)
return; return;
const auto ExpensiveValueParamDecl = parmVarDecl( const auto ExpensiveValueParamDecl = parmVarDecl(
hasType(qualType( hasType(qualType(
hasCanonicalType(matchers::isExpensiveToCopy()), hasCanonicalType(matchers::isExpensiveToCopy()),
unless(anyOf(hasCanonicalType(referenceType()), unless(anyOf(hasCanonicalType(referenceType()),
hasDeclaration(namedDecl( hasDeclaration(namedDecl(
matchers::matchesAnyListedName(AllowedTypes))))))), matchers::matchesAnyListedName(AllowedTypes))))))),
decl().bind("param")); decl().bind("param"));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()), functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()),
unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))), unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))),
has(typeLoc(forEach(ExpensiveValueParamDecl))), has(typeLoc(forEach(ExpensiveValueParamDecl))),
unless(isInstantiated()), decl().bind("functionDecl")), unless(isInstantiated()), decl().bind("functionDecl"))),
this); this);
} }
void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) { void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param"); const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl"); const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
FunctionParmMutationAnalyzer &Analyzer = FunctionParmMutationAnalyzer &Analyzer =
MutationAnalyzers.try_emplace(Function, *Function, *Result.Context) MutationAnalyzers.try_emplace(Function, *Function, *Result.Context)
.first->second; .first->second;
if (Analyzer.isMutated(Param)) if (Analyzer.isMutated(Param))
return; return;
const bool IsConstQualified = const bool IsConstQualified =
Param->getType().getCanonicalType().isConstQualified(); Param->getType().getCanonicalType().isConstQualified();
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines const auto WrongUse = anyOf(
hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")), hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
anything()))), anything()))),
hasParent(explicitCastExpr(hasDestinationType(booleanType())))); hasParent(explicitCastExpr(hasDestinationType(booleanType()))));
Finder->addMatcher( Finder->addMatcher(
cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer), cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer),
hasType(pointsTo(ValidContainer)), hasType(pointsTo(ValidContainer)),
hasType(references(ValidContainer))))), hasType(references(ValidContainer))))),
callee(cxxMethodDecl(hasName("size"))), WrongUse, callee(cxxMethodDecl(hasName("size"))),
traverse(ast_type_traits::TK_AsIs,
cxxMemberCallExpr(WrongUse)),
unless(hasAncestor(cxxMethodDecl( unless(hasAncestor(cxxMethodDecl(
ofClass(equalsBoundNode("container")))))) ofClass(equalsBoundNode("container"))))))
.bind("SizeCallExpr"), .bind("SizeCallExpr"),
this); this);
// Empty constructor matcher. // Empty constructor matcher.
const auto DefaultConstructor = cxxConstructExpr( const auto DefaultConstructor = cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isDefaultConstructor()))); hasDeclaration(cxxConstructorDecl(isDefaultConstructor())));
Show All 11 Linesvoid ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
// Match the object being compared. // Match the object being compared.
const auto STLArg = const auto STLArg =
anyOf(unaryOperator( anyOf(unaryOperator(
hasOperatorName("*"), hasOperatorName("*"),
hasUnaryOperand( hasUnaryOperand(
expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))), expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))),
expr(hasType(ValidContainer)).bind("STLObject")); expr(hasType(ValidContainer)).bind("STLObject"));
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs,
cxxOperatorCallExpr( cxxOperatorCallExpr(
anyOf(hasOverloadedOperatorName("=="), anyOf(hasOverloadedOperatorName("=="),
hasOverloadedOperatorName("!=")), hasOverloadedOperatorName("!=")),
anyOf(allOf(hasArgument(0, WrongComparend), hasArgument(1, STLArg)), anyOf(allOf(hasArgument(0, WrongComparend), hasArgument(1, STLArg)),
allOf(hasArgument(0, STLArg), hasArgument(1, WrongComparend))), allOf(hasArgument(0, STLArg), hasArgument(1, WrongComparend))),
unless(hasAncestor( unless(hasAncestor(
cxxMethodDecl(ofClass(equalsBoundNode("container")))))) cxxMethodDecl(ofClass(equalsBoundNode("container"))))))
.bind("BinCmp"), .bind("BinCmp")),
this); this);
} }
void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) { void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MemberCall = const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("SizeCallExpr"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("SizeCallExpr");
const auto *BinCmp = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("BinCmp"); const auto *BinCmp = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("BinCmp");
const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("SizeBinaryOp"); const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("SizeBinaryOp");
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

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

Show All 33 Lines const auto PointerExpr = ignoringImpCasts(anyOf(
memberExpr(hasDeclaration(fieldDecl().bind("deletedMemberPointer"))))); memberExpr(hasDeclaration(fieldDecl().bind("deletedMemberPointer")))));
const auto PointerCondition = castExpr(hasCastKind(CK_PointerToBoolean), const auto PointerCondition = castExpr(hasCastKind(CK_PointerToBoolean),
hasSourceExpression(PointerExpr)); hasSourceExpression(PointerExpr));
const auto BinaryPointerCheckCondition = const auto BinaryPointerCheckCondition =
binaryOperator(hasEitherOperand(castExpr(hasCastKind(CK_NullToPointer))), binaryOperator(hasEitherOperand(castExpr(hasCastKind(CK_NullToPointer))),
hasEitherOperand(PointerExpr)); hasEitherOperand(PointerExpr));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
ifStmt(hasCondition(anyOf(PointerCondition, BinaryPointerCheckCondition)), ifStmt(hasCondition(anyOf(PointerCondition, BinaryPointerCheckCondition)),
hasThen(anyOf( hasThen(anyOf(
DeleteExpr, DeleteMemberExpr, DeleteExpr, DeleteMemberExpr,
compoundStmt(anyOf(has(DeleteExpr), has(DeleteMemberExpr)), compoundStmt(anyOf(has(DeleteExpr), has(DeleteMemberExpr)),
statementCountIs(1)) statementCountIs(1))
.bind("compound")))) .bind("compound"))))
.bind("ifWithDelete"), .bind("ifWithDelete")),
this); this);
} }
void DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) { void DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) {
const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete"); const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete");
const auto *Compound = Result.Nodes.getNodeAs<CompoundStmt>("compound"); const auto *Compound = Result.Nodes.getNodeAs<CompoundStmt>("compound");
auto Diag = diag( auto Diag = diag(
Show All 24 Lines

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

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Lines auto implicitCastFromBool = implicitCastExpr(
allOf(anyOf(hasCastKind(CK_NullToPointer), allOf(anyOf(hasCastKind(CK_NullToPointer),
hasCastKind(CK_NullToMemberPointer)), hasCastKind(CK_NullToMemberPointer)),
hasSourceExpression(cxxBoolLiteral()))), hasSourceExpression(cxxBoolLiteral()))),
hasSourceExpression(expr(hasType(booleanType()))), hasSourceExpression(expr(hasType(booleanType()))),
unless(exceptionCases)); unless(exceptionCases));
auto boolXor = auto boolXor =
binaryOperator(hasOperatorName("^"), hasLHS(implicitCastFromBool), binaryOperator(hasOperatorName("^"), hasLHS(implicitCastFromBool),
hasRHS(implicitCastFromBool)); hasRHS(implicitCastFromBool));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
anyOf(hasCastKind(CK_IntegralToBoolean), anyOf(hasCastKind(CK_IntegralToBoolean),
hasCastKind(CK_FloatingToBoolean), hasCastKind(CK_FloatingToBoolean),
hasCastKind(CK_PointerToBoolean), hasCastKind(CK_PointerToBoolean),
hasCastKind(CK_MemberPointerToBoolean)), hasCastKind(CK_MemberPointerToBoolean)),
// Exclude case of using if or while statements with variable // Exclude case of using if or while statements with variable
// declaration, e.g.: // declaration, e.g.:
// if (int var = functionCall()) {} // if (int var = functionCall()) {}
unless( unless(
hasParent(stmt(anyOf(ifStmt(), whileStmt()), has(declStmt())))), hasParent(stmt(anyOf(ifStmt(), whileStmt()), has(declStmt())))),
// Exclude cases common to implicit cast to and from bool. // Exclude cases common to implicit cast to and from bool.
unless(exceptionCases), unless(has(boolXor)), unless(exceptionCases), unless(has(boolXor)),
// Retrive also parent statement, to check if we need additional // Retrive also parent statement, to check if we need additional
// parens in replacement. // parens in replacement.
anyOf(hasParent(stmt().bind("parentStmt")), anything()), anyOf(hasParent(stmt().bind("parentStmt")), anything()),
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
unless(hasAncestor(functionTemplateDecl()))) unless(hasAncestor(functionTemplateDecl())))
.bind("implicitCastToBool"), .bind("implicitCastToBool")),
this); this);
auto boolComparison = binaryOperator( auto boolComparison = binaryOperator(
anyOf(hasOperatorName("=="), hasOperatorName("!=")), anyOf(hasOperatorName("=="), hasOperatorName("!=")),
hasLHS(implicitCastFromBool), hasRHS(implicitCastFromBool)); hasLHS(implicitCastFromBool), hasRHS(implicitCastFromBool));
auto boolOpAssignment = auto boolOpAssignment =
binaryOperator(anyOf(hasOperatorName("|="), hasOperatorName("&=")), binaryOperator(anyOf(hasOperatorName("|="), hasOperatorName("&=")),
hasLHS(expr(hasType(booleanType())))); hasLHS(expr(hasType(booleanType()))));
auto bitfieldAssignment = binaryOperator( auto bitfieldAssignment = binaryOperator(
hasLHS(memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1)))))); hasLHS(memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1))))));
auto bitfieldConstruct = cxxConstructorDecl(hasDescendant(cxxCtorInitializer( auto bitfieldConstruct = cxxConstructorDecl(hasDescendant(cxxCtorInitializer(
withInitializer(equalsBoundNode("implicitCastFromBool")), withInitializer(equalsBoundNode("implicitCastFromBool")),
forField(hasBitWidth(1))))); forField(hasBitWidth(1)))));
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr( implicitCastExpr(
implicitCastFromBool, implicitCastFromBool,
// Exclude comparisons of bools, as they are always cast to integers // Exclude comparisons of bools, as they are always cast to integers
// in such context: // in such context:
// bool_expr_a == bool_expr_b // bool_expr_a == bool_expr_b
// bool_expr_a != bool_expr_b // bool_expr_a != bool_expr_b
unless(hasParent(binaryOperator(anyOf( unless(hasParent(binaryOperator(anyOf(
boolComparison, boolXor, boolOpAssignment, bitfieldAssignment)))), boolComparison, boolXor, boolOpAssignment, bitfieldAssignment)))),
implicitCastExpr().bind("implicitCastFromBool"), implicitCastExpr().bind("implicitCastFromBool"),
unless(hasParent(bitfieldConstruct)), unless(hasParent(bitfieldConstruct)),
// Check also for nested casts, for example: bool -> int -> float. // Check also for nested casts, for example: bool -> int -> float.
anyOf(hasParent(implicitCastExpr().bind("furtherImplicitCast")), anyOf(hasParent(implicitCastExpr().bind("furtherImplicitCast")),
anything()), anything()),
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
unless(hasAncestor(functionTemplateDecl()))), unless(hasAncestor(functionTemplateDecl())))),
this); this);
} }
void ImplicitBoolConversionCheck::check( void ImplicitBoolConversionCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
if (const auto *CastToBool = if (const auto *CastToBool =
Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastToBool")) { Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastToBool")) {
const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt"); const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt");
return handleCastToBool(CastToBool, Parent, *Result.Context); return handleCastToBool(CastToBool, Parent, *Result.Context);
} }
if (const auto *CastFromBool = if (const auto *CastFromBool =
Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastFromBool")) { Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastFromBool")) {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
void MagicNumbersCheck::registerMatchers(MatchFinder *Finder) { void MagicNumbersCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(integerLiteral().bind("integer"), this); Finder->addMatcher(integerLiteral().bind("integer"), this);
if (!IgnoreAllFloatingPointValues) if (!IgnoreAllFloatingPointValues)
Finder->addMatcher(floatLiteral().bind("float"), this); Finder->addMatcher(floatLiteral().bind("float"), this);
} }
void MagicNumbersCheck::check(const MatchFinder::MatchResult &Result) { void MagicNumbersCheck::check(const MatchFinder::MatchResult &Result) {
TraversalKindScope raii(*Result.Context, ast_type_traits::TK_AsIs);
checkBoundMatch<IntegerLiteral>(Result, "integer"); checkBoundMatch<IntegerLiteral>(Result, "integer");
checkBoundMatch<FloatingLiteral>(Result, "float"); checkBoundMatch<FloatingLiteral>(Result, "float");
} }
bool MagicNumbersCheck::isConstant(const MatchFinder::MatchResult &Result, bool MagicNumbersCheck::isConstant(const MatchFinder::MatchResult &Result,
const Expr &ExprResult) const { const Expr &ExprResult) const {
return llvm::any_of( return llvm::any_of(
Result.Context->getParents(ExprResult), Result.Context->getParents(ExprResult),
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 LinesAST_MATCHER(CXXMethodDecl, usesThisAsConst) {
return UsageOfThis.Usage == Const; return UsageOfThis.Usage == Const;
} }
void MakeMemberFunctionConstCheck::registerMatchers(MatchFinder *Finder) { void MakeMemberFunctionConstCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxMethodDecl( cxxMethodDecl(
isDefinition(), isUserProvided(), isDefinition(), isUserProvided(),
unless(anyOf( unless(anyOf(
isExpansionInSystemHeader(), isVirtual(), isConst(), isStatic(), isExpansionInSystemHeader(), isVirtual(), isConst(), isStatic(),
hasTrivialBody(), cxxConstructorDecl(), cxxDestructorDecl(), hasTrivialBody(), cxxConstructorDecl(), cxxDestructorDecl(),
isTemplate(), isDependentContext(), isTemplate(), isDependentContext(),
ofClass(anyOf( ofClass(anyOf(
isLambda(), isLambda(),
hasAnyDependentBases()) // Method might become virtual hasAnyDependentBases()) // Method might become virtual
// depending on template base class. // depending on template base class.
), ),
isInsideMacroDefinition(), isInsideMacroDefinition(),
hasCanonicalDecl(isInsideMacroDefinition()))), hasCanonicalDecl(isInsideMacroDefinition()))),
usesThisAsConst()) usesThisAsConst())
.bind("x"), .bind("x")),
this); this);
} }
static SourceLocation getConstInsertionPoint(const CXXMethodDecl *M) { static SourceLocation getConstInsertionPoint(const CXXMethodDecl *M) {
TypeSourceInfo *TSI = M->getTypeSourceInfo(); TypeSourceInfo *TSI = M->getTypeSourceInfo();
if (!TSI) if (!TSI)
return {}; return {};
Show All 27 Lines

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

Show All 13 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
void MisplacedArrayIndexCheck::registerMatchers(MatchFinder *Finder) { void MisplacedArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(arraySubscriptExpr(hasLHS(hasType(isInteger())), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
arraySubscriptExpr(hasLHS(hasType(isInteger())),
hasRHS(hasType(isAnyPointer()))) hasRHS(hasType(isAnyPointer())))
.bind("expr"), .bind("expr")),
this); this);
} }
void MisplacedArrayIndexCheck::check(const MatchFinder::MatchResult &Result) { void MisplacedArrayIndexCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ArraySubscriptE = const auto *ArraySubscriptE =
Result.Nodes.getNodeAs<ArraySubscriptExpr>("expr"); Result.Nodes.getNodeAs<ArraySubscriptExpr>("expr");
auto Diag = diag(ArraySubscriptE->getBeginLoc(), "confusing array subscript " auto Diag = diag(ArraySubscriptE->getBeginLoc(), "confusing array subscript "
Show All 24 Lines

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

Show All 22 Linesvoid NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
// C++ constructor. // C++ constructor.
Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this); Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this);
// Track unused parameters, there is Wunused-parameter about unused // Track unused parameters, there is Wunused-parameter about unused
// parameters. // parameters.
Finder->addMatcher(declRefExpr().bind("Ref"), this); Finder->addMatcher(declRefExpr().bind("Ref"), this);
// Analyse parameter usage in function. // Analyse parameter usage in function.
Finder->addMatcher(stmt(anyOf(unaryOperator(anyOf(hasOperatorName("++"), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
stmt(anyOf(unaryOperator(anyOf(hasOperatorName("++"),
hasOperatorName("--"))), hasOperatorName("--"))),
binaryOperator(), callExpr(), returnStmt(), binaryOperator(), callExpr(), returnStmt(),
cxxConstructExpr())) cxxConstructExpr()))
.bind("Mark"), .bind("Mark")),
this); this);
Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this); Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this);
} }
void NonConstParameterCheck::check(const MatchFinder::MatchResult &Result) { void NonConstParameterCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Parm = Result.Nodes.getNodeAs<ParmVarDecl>("Parm")) { if (const auto *Parm = Result.Nodes.getNodeAs<ParmVarDecl>("Parm")) {
if (const DeclContext *D = Parm->getParentFunctionOrMethod()) { if (const DeclContext *D = Parm->getParentFunctionOrMethod()) {
if (const auto *M = dyn_cast<CXXMethodDecl>(D)) { if (const auto *M = dyn_cast<CXXMethodDecl>(D)) {
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

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

Show All 11 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
void RedundantFunctionPtrDereferenceCheck::registerMatchers(MatchFinder *Finder) { void RedundantFunctionPtrDereferenceCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(unaryOperator(hasOperatorName("*"), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
unaryOperator(hasOperatorName("*"),
has(implicitCastExpr( has(implicitCastExpr(
hasCastKind(CK_FunctionToPointerDecay)))) hasCastKind(CK_FunctionToPointerDecay))))
.bind("op"), .bind("op")),
this); this);
} }
void RedundantFunctionPtrDereferenceCheck::check(const MatchFinder::MatchResult &Result) { void RedundantFunctionPtrDereferenceCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Operator = Result.Nodes.getNodeAs<UnaryOperator>("op"); const auto *Operator = Result.Nodes.getNodeAs<UnaryOperator>("op");
diag(Operator->getOperatorLoc(), diag(Operator->getOperatorLoc(),
"redundant repeated dereference of function pointer") "redundant repeated dereference of function pointer")
<< FixItHint::CreateRemoval(Operator->getOperatorLoc()); << FixItHint::CreateRemoval(Operator->getOperatorLoc());
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

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

Show All 29 Lines if (!getLangOpts().CPlusPlus)
return; return;
auto Construct = auto Construct =
cxxConstructExpr( cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(hasParent( hasDeclaration(cxxConstructorDecl(hasParent(
cxxRecordDecl(unless(isTriviallyDefaultConstructible())))))) cxxRecordDecl(unless(isTriviallyDefaultConstructible()))))))
.bind("construct"); .bind("construct");
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
unless(isDelegatingConstructor()), unless(isDelegatingConstructor()),
ofClass(unless( ofClass(unless(
anyOf(isUnion(), ast_matchers::isTemplateInstantiation()))), anyOf(isUnion(), ast_matchers::isTemplateInstantiation()))),
forEachConstructorInitializer( forEachConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
isWritten(), withInitializer(ignoringImplicit(Construct)), isWritten(), withInitializer(ignoringImplicit(Construct)),
unless(forField(hasType(isConstQualified()))), unless(forField(hasType(isConstQualified()))),
unless(forField(hasParent(recordDecl(isUnion()))))) unless(forField(hasParent(recordDecl(isUnion())))))
.bind("init"))) .bind("init")))
.bind("constructor"), .bind("constructor")),
this); this);
} }
void RedundantMemberInitCheck::check(const MatchFinder::MatchResult &Result) { void RedundantMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Init = Result.Nodes.getNodeAs<CXXCtorInitializer>("init"); const auto *Init = Result.Nodes.getNodeAs<CXXCtorInitializer>("init");
const auto *Construct = Result.Nodes.getNodeAs<CXXConstructExpr>("construct"); const auto *Construct = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
const auto *ConstructorDecl = const auto *ConstructorDecl =
Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor"); Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor");
Show All 22 Lines

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

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Linesvoid RedundantStringCStrCheck::registerMatchers(
// Match a call to the string 'c_str()' method. // Match a call to the string 'c_str()' method.
const auto StringCStrCallExpr = const auto StringCStrCallExpr =
cxxMemberCallExpr(on(StringExpr.bind("arg")), cxxMemberCallExpr(on(StringExpr.bind("arg")),
callee(memberExpr().bind("member")), callee(memberExpr().bind("member")),
callee(cxxMethodDecl(hasAnyName("c_str", "data")))) callee(cxxMethodDecl(hasAnyName("c_str", "data"))))
.bind("call"); .bind("call");
// Detect redundant 'c_str()' calls through a string constructor. // Detect redundant 'c_str()' calls through a string constructor.
Finder->addMatcher(cxxConstructExpr(StringConstructorExpr, Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
hasArgument(0, StringCStrCallExpr)), cxxConstructExpr(StringConstructorExpr,
hasArgument(0, StringCStrCallExpr))),
this); this);
// Detect: 's == str.c_str()' -> 's == str' // Detect: 's == str.c_str()' -> 's == str'
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr( cxxOperatorCallExpr(
anyOf( anyOf(
hasOverloadedOperatorName("<"), hasOverloadedOperatorName(">"), hasOverloadedOperatorName("<"), hasOverloadedOperatorName(">"),
hasOverloadedOperatorName(">="), hasOverloadedOperatorName("<="), hasOverloadedOperatorName(">="), hasOverloadedOperatorName("<="),
Show All 40 Linesvoid RedundantStringCStrCheck::registerMatchers(
// Detect: 'dst.insert(pos, str.c_str())' -> 'dst.insert(pos, str)' // Detect: 'dst.insert(pos, str.c_str())' -> 'dst.insert(pos, str)'
Finder->addMatcher( Finder->addMatcher(
cxxMemberCallExpr(on(StringExpr), cxxMemberCallExpr(on(StringExpr),
callee(decl(cxxMethodDecl(hasName("insert")))), callee(decl(cxxMethodDecl(hasName("insert")))),
argumentCountIs(2), hasArgument(1, StringCStrCallExpr)), argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
this); this);
// Detect redundant 'c_str()' calls through a StringRef constructor. // Detect redundant 'c_str()' calls through a StringRef constructor.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructExpr( cxxConstructExpr(
// Implicit constructors of these classes are overloaded // Implicit constructors of these classes are overloaded
// wrt. string types and they internally make a StringRef // wrt. string types and they internally make a StringRef
// referring to the argument. Passing a string directly to // referring to the argument. Passing a string directly to
// them is preferred to passing a char pointer. // them is preferred to passing a char pointer.
hasDeclaration(cxxMethodDecl(hasAnyName( hasDeclaration(cxxMethodDecl(hasAnyName(
"::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))), "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
argumentCountIs(1), argumentCountIs(1),
// The only argument must have the form x.c_str() or p->c_str() // The only argument must have the form x.c_str() or p->c_str()
// where the method is string::c_str(). StringRef also has // where the method is string::c_str(). StringRef also has
// a constructor from string which is more efficient (avoids // a constructor from string which is more efficient (avoids
// strlen), so we can construct StringRef from the string // strlen), so we can construct StringRef from the string
// directly. // directly.
hasArgument(0, StringCStrCallExpr)), hasArgument(0, StringCStrCallExpr))),
this); this);
} }
void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) { void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call"); const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg"); const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member"); const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
bool Arrow = Member->isArrow(); bool Arrow = Member->isArrow();
Show All 16 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesvoid RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
const auto EmptyStringCtorExprWithTemporaries = const auto EmptyStringCtorExprWithTemporaries =
cxxConstructExpr(StringConstructorExpr, cxxConstructExpr(StringConstructorExpr,
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(traverse(ast_type_traits::TK_AsIs,
namedDecl( namedDecl(
varDecl( varDecl(
hasType(hasUnqualifiedDesugaredType(recordType( hasType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasStringTypeName))))), hasDeclaration(cxxRecordDecl(hasStringTypeName))))),
hasInitializer(expr(ignoringImplicit(anyOf( hasInitializer(expr(ignoringImplicit(anyOf(
EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries))))) EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries)))))
.bind("vardecl"), .bind("vardecl"),
unless(parmVarDecl())), unless(parmVarDecl()))),
this); this);
} }
void RedundantStringInitCheck::check(const MatchFinder::MatchResult &Result) { void RedundantStringInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *VDecl = Result.Nodes.getNodeAs<VarDecl>("vardecl"); const auto *VDecl = Result.Nodes.getNodeAs<VarDecl>("vardecl");
// VarDecl's getSourceRange() spans 'string foo = ""' or 'string bar("")'. // VarDecl's getSourceRange() spans 'string foo = ""' or 'string bar("")'.
// So start at getLocation() to span just 'foo = ""' or 'bar("")'. // So start at getLocation() to span just 'foo = ""' or 'bar("")'.
SourceRange ReplaceRange(VDecl->getLocation(), VDecl->getEndLoc()); SourceRange ReplaceRange(VDecl->getLocation(), VDecl->getEndLoc());
diag(VDecl->getLocation(), "redundant string initialization") diag(VDecl->getLocation(), "redundant string initialization")
<< FixItHint::CreateReplacement(ReplaceRange, VDecl->getName()); << FixItHint::CreateReplacement(ReplaceRange, VDecl->getName());
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

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

Show All 28 Linesvoid StringCompareCheck::registerMatchers(MatchFinder *Finder) {
const auto StrCompare = cxxMemberCallExpr( const auto StrCompare = cxxMemberCallExpr(
callee(cxxMethodDecl(hasName("compare"), callee(cxxMethodDecl(hasName("compare"),
ofClass(classTemplateSpecializationDecl( ofClass(classTemplateSpecializationDecl(
hasName("::std::basic_string"))))), hasName("::std::basic_string"))))),
hasArgument(0, expr().bind("str2")), argumentCountIs(1), hasArgument(0, expr().bind("str2")), argumentCountIs(1),
callee(memberExpr().bind("str1"))); callee(memberExpr().bind("str1")));
// First and second case: cast str.compare(str) to boolean. // First and second case: cast str.compare(str) to boolean.
Finder->addMatcher(implicitCastExpr(hasImplicitDestinationType(booleanType()), Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(booleanType()),
has(StrCompare)) has(StrCompare))
.bind("match1"), .bind("match1")),
this); this);
// Third and fourth case: str.compare(str) == 0 and str.compare(str) != 0. // Third and fourth case: str.compare(str) == 0 and str.compare(str) != 0.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
binaryOperator(anyOf(hasOperatorName("=="), hasOperatorName("!=")), binaryOperator(anyOf(hasOperatorName("=="), hasOperatorName("!=")),
hasEitherOperand(StrCompare.bind("compare")), hasEitherOperand(StrCompare.bind("compare")),
hasEitherOperand(integerLiteral(equals(0)).bind("zero"))) hasEitherOperand(integerLiteral(equals(0)).bind("zero")))
.bind("match2"), .bind("match2")),
this); this);
} }
void StringCompareCheck::check(const MatchFinder::MatchResult &Result) { void StringCompareCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) { if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) {
diag(Matched->getBeginLoc(), CompareMessage); diag(Matched->getBeginLoc(), CompareMessage);
return; return;
} }
Show All 26 Lines

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

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Lines Options.store(Opts, "NewSuffixes",
utils::options::serializeStringList(NewSuffixes)); utils::options::serializeStringList(NewSuffixes));
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
} }
void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) { void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
// Sadly, we can't check whether the literal has sufix or not. // Sadly, we can't check whether the literal has sufix or not.
// E.g. i32 suffix still results in 'BuiltinType::Kind::Int'. // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
// And such an info is not stored in the *Literal itself. // And such an info is not stored in the *Literal itself.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name), stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
floatLiteral().bind(FloatingLiteralCheck::Name)), floatLiteral().bind(FloatingLiteralCheck::Name)),
unless(anyOf(hasParent(userDefinedLiteral()), unless(anyOf(hasParent(userDefinedLiteral()),
hasAncestor(isImplicit()), hasAncestor(isImplicit()),
hasAncestor(substNonTypeTemplateParmExpr())))), hasAncestor(substNonTypeTemplateParmExpr()))))),
this); this);
} }
template <typename LiteralType> template <typename LiteralType>
bool UppercaseLiteralSuffixCheck::checkBoundMatch( bool UppercaseLiteralSuffixCheck::checkBoundMatch(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *Literal = const auto *Literal =
Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name); Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name);
Show All 29 Lines

clang-tools-extra/clang-tidy/utils/ExprSequence.cpp

Show All 22 Lines
// nodes cause ASTContext::getParent() to return multiple parents for certain // nodes cause ASTContext::getParent() to return multiple parents for certain
// nodes in their subtree because RecursiveASTVisitor visits both the syntactic // nodes in their subtree because RecursiveASTVisitor visits both the syntactic
// and semantic forms of InitListExpr, and the parent-child relationships are // and semantic forms of InitListExpr, and the parent-child relationships are
// different between the two forms. // different between the two forms.
static SmallVector<const Stmt *, 1> getParentStmts(const Stmt *S, static SmallVector<const Stmt *, 1> getParentStmts(const Stmt *S,
ASTContext *Context) { ASTContext *Context) {
SmallVector<const Stmt *, 1> Result; SmallVector<const Stmt *, 1> Result;
TraversalKindScope raii(*Context, ast_type_traits::TK_AsIs);
ASTContext::DynTypedNodeList Parents = Context->getParents(*S); ASTContext::DynTypedNodeList Parents = Context->getParents(*S);
SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(), SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(),
Parents.end()); Parents.end());
while (!NodesToProcess.empty()) { while (!NodesToProcess.empty()) {
ast_type_traits::DynTypedNode Node = NodesToProcess.back(); ast_type_traits::DynTypedNode Node = NodesToProcess.back();
NodesToProcess.pop_back(); NodesToProcess.pop_back();
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.cpp

Show All 22 Lines
AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<std::string>, Names) { AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<std::string>, Names) {
std::string QualifiedName = Node.getQualifiedNameAsString(); std::string QualifiedName = Node.getQualifiedNameAsString();
return llvm::any_of(Names, return llvm::any_of(Names,
[&](StringRef Name) { return QualifiedName == Name; }); [&](StringRef Name) { return QualifiedName == Name; });
} }
void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) { void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) {
// Matcher for default constructors. // Matcher for default constructors.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxTemporaryObjectExpr(hasDeclaration(cxxConstructorDecl(hasParent( cxxTemporaryObjectExpr(hasDeclaration(cxxConstructorDecl(hasParent(
cxxRecordDecl(matchesAnyName(Names)))))) cxxRecordDecl(matchesAnyName(Names))))))
.bind("temps"), .bind("temps")),
this); this);
// Matcher for user-defined constructors. // Matcher for user-defined constructors.
Finder->addMatcher( Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
cxxConstructExpr(hasParent(cxxFunctionalCastExpr()), cxxConstructExpr(hasParent(cxxFunctionalCastExpr()),
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
hasParent(cxxRecordDecl(matchesAnyName(Names)))))) hasParent(cxxRecordDecl(matchesAnyName(Names))))))
.bind("temps"), .bind("temps")),
this); this);
} }
void TemporaryObjectsCheck::check(const MatchFinder::MatchResult &Result) { void TemporaryObjectsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<CXXConstructExpr>("temps")) if (const auto *D = Result.Nodes.getNodeAs<CXXConstructExpr>("temps"))
diag(D->getLocation(), diag(D->getLocation(),
"creating a temporary object of type %q0 is prohibited") "creating a temporary object of type %q0 is prohibited")
<< D->getConstructor()->getParent(); << D->getConstructor()->getParent();
Show All 9 Lines