This is an archive of the discontinued LLVM Phabricator instance.

Differential D92994

Remove references to the ast_type_traits namespace
ClosedPublic

Authored by alexfh on Dec 9 2020, 7:45 PM.

Details

Reviewers
aaron.ballman
rnk
shafik
sammccall
Commits
rG027899dab6ac: Remove references to the ast_type_traits namespace
Summary

Follow up to cd62511496938e33c061c90796dd23a5288ff843 /
https://reviews.llvm.org/D74499

Diff Detail

Unit TestsFailed

TimeTest
80 msx64 windows > LLVM.CodeGen/XCore::threads.ll

Event Timeline

alexfh created this revision.Dec 9 2020, 7:45 PM
Herald added a reviewer: shafik. · View Herald TranscriptDec 9 2020, 7:45 PM
Herald added subscribers: usaxena95, kadircet, arphaman and 2 others. · View Herald Transcript
alexfh requested review of this revision.Dec 9 2020, 7:45 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 9 2020, 7:45 PM
Harbormaster completed remote builds in B81759: Diff 310749.Dec 9 2020, 9:54 PM
alexfh added a reviewer: sammccall.Dec 10 2020, 4:36 AM
aaron.ballman accepted this revision.Dec 10 2020, 5:13 AM

LGTM

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

It looks like some unrelated clang-format changes that should probably be separated out from this patch.

This revision is now accepted and ready to land.Dec 10 2020, 5:13 AM
alexfh marked an inline comment as done.Dec 10 2020, 3:54 PM
alexfh updated this revision to Diff 311046.Dec 10 2020, 3:56 PM

Removed unrelated whitespace changes.

This revision was landed with ongoing or failed builds.Dec 10 2020, 3:59 PM
Closed by commit rG027899dab6ac: Remove references to the ast_type_traits namespace (authored by alexfh). · Explain Why
This revision was automatically updated to reflect the committed changes.
alexfh added a commit: rG027899dab6ac: Remove references to the ast_type_traits namespace.
Harbormaster completed remote builds in B81928: Diff 311046.Dec 10 2020, 5:28 PM
alexfh mentioned this in rG4c5e0c7fd801: Remove references to the ast_type_traits namespace.Dec 11 2020, 3:41 AM

Revision Contents

PathSize
clang-tools-extra/
clang-query/
2 lines
3 lines
11 lines
4 lines
clang-tidy/
abseil/
4 lines
24 lines
2 lines
23 lines
bugprone/
3 lines
2 lines
14 lines
2 lines
2 lines
2 lines
16 lines
3 lines
2 lines
5 lines
2 lines
2 lines
5 lines
2 lines
2 lines
2 lines
9 lines
cert/
2 lines
2 lines
2 lines
2 lines
cppcoreguidelines/
12 lines
19 lines
25 lines
2 lines
9 lines
fuchsia/
4 lines
llvm/
2 lines
2 lines
misc/
64 lines
modernize/
15 lines
6 lines
2 lines
2 lines
2 lines
2 lines
4 lines
3 lines
4 lines
7 lines
10 lines
16 lines
objc/
2 lines
performance/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
readability/
2 lines
2 lines
6 lines
2 lines
2 lines
7 lines
2 lines
12 lines
2 lines
4 lines
8 lines
2 lines
utils/
7 lines
zircon/
2 lines
clangd/
4 lines
9 lines
16 lines
2 lines
1 line
refactor/
tweaks/
2 lines
2 lines
unittests/
clang-query/
8 lines
clang/
lib/
ASTMatchers/
3 lines
Dynamic/
2 lines
Analysis/
4 lines
Tooling/
Transformer/
2 lines
unittests/
AST/
15 lines
4 lines
3 lines
24 lines
ASTMatchers/
23 lines
107 lines
184 lines
Dynamic/
6 lines
Analysis/
2 lines
Tooling/
2 lines
5 lines
4 lines

Diff 310749

clang-tools-extra/clang-query/Query.h

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
template <> struct SetQueryKind<bool> { template <> struct SetQueryKind<bool> {
static const QueryKind value = QK_SetBool; static const QueryKind value = QK_SetBool;
}; };
template <> struct SetQueryKind<OutputKind> { template <> struct SetQueryKind<OutputKind> {
static const QueryKind value = QK_SetOutputKind; static const QueryKind value = QK_SetOutputKind;
}; };
template <> struct SetQueryKind<ast_type_traits::TraversalKind> { template <> struct SetQueryKind<TraversalKind> {
static const QueryKind value = QK_SetTraversalKind; static const QueryKind value = QK_SetTraversalKind;
}; };
/// Query for "set VAR VALUE". /// Query for "set VAR VALUE".
template <typename T> struct SetQuery : Query { template <typename T> struct SetQuery : Query {
SetQuery(T QuerySession::*Var, T Value) SetQuery(T QuerySession::*Var, T Value)
: Query(SetQueryKind<T>::value), Var(Var), Value(Value) {} : Query(SetQueryKind<T>::value), Var(Var), Value(Value) {}
bool run(llvm::raw_ostream &OS, QuerySession &QS) const override { bool run(llvm::raw_ostream &OS, QuerySession &QS) const override {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

clang-tools-extra/clang-query/QueryParser.h

Show All 37 Linesprivate:
QueryParser(StringRef Line, const QuerySession &QS) QueryParser(StringRef Line, const QuerySession &QS)
: Line(Line), CompletionPos(nullptr), QS(QS) {} : Line(Line), CompletionPos(nullptr), QS(QS) {}
StringRef lexWord(); StringRef lexWord();
template <typename T> struct LexOrCompleteWord; template <typename T> struct LexOrCompleteWord;
QueryRef parseSetBool(bool QuerySession::*Var); QueryRef parseSetBool(bool QuerySession::*Var);
QueryRef QueryRef parseSetTraversalKind(TraversalKind QuerySession::*Var);
parseSetTraversalKind(ast_type_traits::TraversalKind QuerySession::*Var);
template <typename QueryType> QueryRef parseSetOutputKind(); template <typename QueryType> QueryRef parseSetOutputKind();
QueryRef completeMatcherExpression(); QueryRef completeMatcherExpression();
QueryRef endQuery(QueryRef Q); QueryRef endQuery(QueryRef Q);
/// Parse [\p Begin,\p End). /// Parse [\p Begin,\p End).
/// ///
/// \return A reference to the parsed query object, which may be an /// \return A reference to the parsed query object, which may be an
Show All 15 Lines

clang-tools-extra/clang-query/QueryParser.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines case OK_Diag:
return new QueryType(&QuerySession::DiagOutput); return new QueryType(&QuerySession::DiagOutput);
case OK_Print: case OK_Print:
return new QueryType(&QuerySession::PrintOutput); return new QueryType(&QuerySession::PrintOutput);
} }
llvm_unreachable("Invalid output kind"); llvm_unreachable("Invalid output kind");
} }
QueryRef QueryParser::parseSetTraversalKind( QueryRef QueryParser::parseSetTraversalKind(TraversalKind QuerySession::*Var) {
ast_type_traits::TraversalKind QuerySession::*Var) {
StringRef ValStr; StringRef ValStr;
unsigned Value = unsigned Value =
LexOrCompleteWord<unsigned>(this, ValStr) LexOrCompleteWord<unsigned>(this, ValStr)
.Case("AsIs", ast_type_traits::TK_AsIs) .Case("AsIs", TK_AsIs)
.Case("IgnoreUnlessSpelledInSource", .Case("IgnoreUnlessSpelledInSource", TK_IgnoreUnlessSpelledInSource)
ast_type_traits::TK_IgnoreUnlessSpelledInSource)
.Default(~0u); .Default(~0u);
if (Value == ~0u) { if (Value == ~0u) {
return new InvalidQuery("expected traversal kind, got '" + ValStr + "'"); return new InvalidQuery("expected traversal kind, got '" + ValStr + "'");
} }
return new SetQuery<ast_type_traits::TraversalKind>( return new SetQuery<TraversalKind>(Var, static_cast<TraversalKind>(Value));
Var, static_cast<ast_type_traits::TraversalKind>(Value));
} }
QueryRef QueryParser::endQuery(QueryRef Q) { QueryRef QueryParser::endQuery(QueryRef Q) {
StringRef Extra = Line; StringRef Extra = Line;
StringRef ExtraTrimmed = Extra.drop_while( StringRef ExtraTrimmed = Extra.drop_while(
[](char c) { return StringRef(" \t\v\f\r").contains(c); }); [](char c) { return StringRef(" \t\v\f\r").contains(c); });
if ((!ExtraTrimmed.empty() && ExtraTrimmed[0] == '\n') || if ((!ExtraTrimmed.empty() && ExtraTrimmed[0] == '\n') ||
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

clang-tools-extra/clang-query/QuerySession.h

Show All 20 Lines
namespace query { namespace query {
/// Represents the state for a particular clang-query session. /// Represents the state for a particular clang-query session.
class QuerySession { class QuerySession {
public: public:
QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs) QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
: ASTs(ASTs), PrintOutput(false), DiagOutput(true), : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
DetailedASTOutput(false), BindRoot(true), PrintMatcher(false), DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
Terminate(false), TK(ast_type_traits::TK_AsIs) {} Terminate(false), TK(TK_AsIs) {}
llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs; llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
bool PrintOutput; bool PrintOutput;
bool DiagOutput; bool DiagOutput;
bool DetailedASTOutput; bool DetailedASTOutput;
bool BindRoot; bool BindRoot;
bool PrintMatcher; bool PrintMatcher;
bool Terminate; bool Terminate;
ast_type_traits::TraversalKind TK; TraversalKind TK;
llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues; llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
}; };
} // namespace query } // namespace query
} // namespace clang } // namespace clang
#endif #endif

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

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines auto ByAnyCharArg =
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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
callExpr(callee(functionDecl(hasName("::absl::StrSplit"))), 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, traverse(TK_AsIs,
callExpr(callee(functionDecl(hasName("::absl::MaxSplits"))), callExpr(callee(functionDecl(hasName("::absl::MaxSplits"))),
hasArgument(0, anyOf(ByAnyCharArg, hasArgument(0, anyOf(ByAnyCharArg,
ignoringParenCasts(SingleChar))), ignoringParenCasts(SingleChar))),
unless(isInTemplateInstantiation()))), unless(isInTemplateInstantiation()))),
this); this);
} }
void FasterStrsplitDelimiterCheck::check( void FasterStrsplitDelimiterCheck::check(
Show All 28 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(traverse(ast_type_traits::TK_AsIs, match(stmt(traverse(TK_AsIs,
anyOf(cxxConstructExpr(IsAlphanum, anyOf(cxxConstructExpr(IsAlphanum,
hasArgument(0, IsStrcat)), 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,
const MatchFinder::MatchResult& Result) { const MatchFinder::MatchResult& Result) {
StrCatCheckResult CheckResult; StrCatCheckResult CheckResult;
std::deque<const CallExpr*> CallsToProcess = {RootCall}; std::deque<const CallExpr*> CallsToProcess = {RootCall};
while (!CallsToProcess.empty()) { while (!CallsToProcess.empty()) {
++CheckResult.NumCalls; ++CheckResult.NumCalls;
const CallExpr* CallExpr = CallsToProcess.front(); const CallExpr* CallExpr = CallsToProcess.front();
CallsToProcess.pop_front(); CallsToProcess.pop_front();
int StartArg = CallExpr == RootCall && IsAppend; int StartArg = CallExpr == RootCall && IsAppend;
for (const auto *Arg : CallExpr->arguments()) { for (const auto *Arg : CallExpr->arguments()) {
if (StartArg-- > 0) if (StartArg-- > 0)
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

It looks like some unrelated clang-format changes that should probably be separated out from this patch.

aaron.ballman: It looks like some unrelated clang-format changes that should probably be separated out from…
continue; continue;
if (const clang::CallExpr* Sub = if (const clang::CallExpr *Sub =
ProcessArgument(Arg, Result, &CheckResult)) { ProcessArgument(Arg, Result, &CheckResult)) {
CallsToProcess.push_back(Sub); CallsToProcess.push_back(Sub);
} }
} }
} }
return CheckResult; return CheckResult;
} }
} // namespace } // namespace
void RedundantStrcatCallsCheck::check(const MatchFinder::MatchResult& Result) { void RedundantStrcatCallsCheck::check(const MatchFinder::MatchResult& Result) {
bool IsAppend; bool IsAppend;
const CallExpr* RootCall; const CallExpr* RootCall;
if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrCat"))) if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrCat")))
IsAppend = false; IsAppend = false;
else if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrAppend"))) else if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrAppend")))
IsAppend = true; IsAppend = true;
else else
return; return;
if (RootCall->getBeginLoc().isMacroID()) { if (RootCall->getBeginLoc().isMacroID()) {
// Ignore calls within macros. // Ignore calls within macros.
// In many cases the outer StrCat part of the macro and the inner StrCat is // In many cases the outer StrCat part of the macro and the inner StrCat is
// a macro argument. Removing the inner StrCat() converts one macro // a macro argument. Removing the inner StrCat() converts one macro
// argument into many. // argument into many.
return; return;
} }
const StrCatCheckResult CheckResult = const StrCatCheckResult CheckResult =
ProcessCall(RootCall, IsAppend, Result); ProcessCall(RootCall, IsAppend, Result);
if (CheckResult.NumCalls == 1) { if (CheckResult.NumCalls == 1) {
// Just one call, so nothing to fix. // Just one call, so nothing to fix.
return; return;
} }
diag(RootCall->getBeginLoc(), diag(RootCall->getBeginLoc(),
"multiple calls to 'absl::StrCat' can be flattened into a single call") "multiple calls to 'absl::StrCat' can be flattened into a single call")
<< CheckResult.Hints; << CheckResult.Hints;
} }
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesvoid StrCatAppendCheck::registerMatchers(MatchFinder *Finder) {
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, traverse(TK_AsIs,
cxxOperatorCallExpr( cxxOperatorCallExpr(
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
hasOverloadedOperatorName("="), hasOverloadedOperatorName("="),
hasArgument(0, declRefExpr(to(decl().bind("LHS")))), hasArgument(0, declRefExpr(to(decl().bind("LHS")))),
hasArgument( hasArgument(
1, IgnoringTemporaries( 1, IgnoringTemporaries(
callExpr(callee(StrCat), hasArgument(0, AlphaNum), callExpr(callee(StrCat), hasArgument(0, AlphaNum),
unless(HasAnotherReferenceToLhs)) unless(HasAnotherReferenceToLhs))
Show All 33 Lines

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

Show First 20 Lines • Show All 94 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( traverse(TK_AsIs, implicitCastExpr(
ast_type_traits::TK_AsIs, anyOf(hasCastKind(CK_UserDefinedConversion),
implicitCastExpr(anyOf(hasCastKind(CK_UserDefinedConversion),
has(implicitCastExpr( has(implicitCastExpr(
hasCastKind(CK_UserDefinedConversion)))), hasCastKind(CK_UserDefinedConversion)))),
hasParent(callExpr( hasParent(callExpr(
callee(functionDecl( callee(functionDecl(
DurationFactoryFunction(), 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); TraversalKindScope RAII(*Result.Context, 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()) {
Show All 35 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 =
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, hasDescendant(expr(hasSideEffect(CheckFunctionCalls))));
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 13 Lines
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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
ifStmt( ifStmt(
hasCondition(findAll(implicitCastExpr( hasCondition(findAll(implicitCastExpr(
unless(hasParent(unaryOperator(hasOperatorName("!")))), unless(hasParent(unaryOperator(hasOperatorName("!")))),
hasSourceExpression(expr( hasSourceExpression(expr(
hasType(pointerType(pointee(booleanType()))), hasType(pointerType(pointee(booleanType()))),
ignoringParenImpCasts(anyOf(declRefExpr().bind("expr"), ignoringParenImpCasts(anyOf(declRefExpr().bind("expr"),
memberExpr().bind("expr"))))), memberExpr().bind("expr"))))),
hasCastKind(CK_PointerToBoolean)))), hasCastKind(CK_PointerToBoolean)))),
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 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, traverse(TK_AsIs,
varDecl(hasType(hasUnqualifiedDesugaredType(recordType( varDecl(hasType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(IsAHandle))))), hasDeclaration(cxxRecordDecl(IsAHandle))))),
unless(parmVarDecl()), unless(parmVarDecl()),
hasInitializer(exprWithCleanups( hasInitializer(exprWithCleanups(
has(ignoringParenImpCasts(handleFrom( 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, traverse(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(traverse(ast_type_traits::TK_AsIs, Finder->addMatcher(
makeContainerMatcher(IsAHandle).bind("bad_stmt")), traverse(TK_AsIs, makeContainerMatcher(IsAHandle).bind("bad_stmt")),
this); this);
} }
void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) { void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
// Return a local. // Return a local.
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, 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( traverse(
ast_type_traits::TK_AsIs, 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);
Show All 13 Lines

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

Show All 27 Lines const auto EndCall =
.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( traverse(
ast_type_traits::TK_AsIs, 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(anyOf( hasArgument(0, has(ignoringImplicit(anyOf(
EndCall, has(ignoringImplicit(EndCall)))))), EndCall, has(ignoringImplicit(EndCall)))))),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("erase")), .bind("erase")),
this); this);
Show All 29 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, traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(isInteger()), implicitCastExpr(hasImplicitDestinationType(isInteger()),
ignoringParenCasts(binaryOperator( ignoringParenCasts(binaryOperator(
hasOperatorName("+"), OneSideHalf))) hasOperatorName("+"), OneSideHalf)))
.bind("CastExpr")), .bind("CastExpr")),
this); this);
} }
void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) { void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
Show All 9 Lines

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

Show All 24 Linesvoid IntegerDivisionCheck::registerMatchers(MatchFinder *Finder) {
const auto UnaryOperators = unaryOperator(hasAnyOperatorName("~", "!")); const auto UnaryOperators = unaryOperator(hasAnyOperatorName("~", "!"));
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, traverse(TK_AsIs,
binaryOperator( binaryOperator(
hasOperatorName("/"), hasLHS(expr(IntType)), hasOperatorName("/"), hasLHS(expr(IntType)),
hasRHS(expr(IntType)), hasRHS(expr(IntType)),
hasAncestor(castExpr(hasCastKind(CK_IntegralToFloating)) hasAncestor(castExpr(hasCastKind(CK_IntegralToFloating))
.bind("FloatCast")), .bind("FloatCast")),
unless(hasAncestor(expr( unless(hasAncestor(expr(
Exceptions, Exceptions,
hasAncestor(castExpr(equalsBoundNode("FloatCast"))))))) hasAncestor(castExpr(equalsBoundNode("FloatCast")))))))
Show All 13 Lines

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

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines const auto Alloc0FuncPtr =
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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
hasArgument(0, BadArg)) hasArgument(0, BadArg))
.bind("Alloc")), .bind("Alloc")),
this); this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))),
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, traverse(TK_AsIs,
cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc")), cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc")),
this); 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)
Show All 37 Lines

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

Show All 34 Lines const auto Calc =
.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 = const auto Cast =
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast"));
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(isComparisonOperator(), hasEitherOperand(Cast)), this); binaryOperator(isComparisonOperator(), hasEitherOperand(Cast)), this);
} }
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines Text.erase(
[](char C) { return llvm::isSpace(static_cast<unsigned char>(C)); }), [](char C) { return llvm::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( traverse(
ast_type_traits::TK_AsIs, 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())))),
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 LinesBindableMatcher<clang::Stmt> SignedCharMisuseCheck::charCastExpression(
const auto CStyleCastExpr = cStyleCastExpr(has(ImplicitCastExpr)); const auto CStyleCastExpr = cStyleCastExpr(has(ImplicitCastExpr));
const auto StaticCastExpr = cxxStaticCastExpr(has(ImplicitCastExpr)); const auto StaticCastExpr = cxxStaticCastExpr(has(ImplicitCastExpr));
const auto FunctionalCastExpr = cxxFunctionalCastExpr(has(ImplicitCastExpr)); const auto FunctionalCastExpr = cxxFunctionalCastExpr(has(ImplicitCastExpr));
// We catch any type of casts to an integer. We need to have these cast // We catch any type of casts to an integer. We need to have these cast
// expressions explicitly to catch only those casts which are direct children // expressions explicitly to catch only those casts which are direct children
// of the checked expressions. (e.g. assignment, declaration). // of the checked expressions. (e.g. assignment, declaration).
return traverse(ast_type_traits::TK_AsIs, return traverse(TK_AsIs, expr(anyOf(ImplicitCastExpr, CStyleCastExpr,
expr(anyOf(ImplicitCastExpr, CStyleCastExpr, StaticCastExpr, StaticCastExpr, FunctionalCastExpr)));
FunctionalCastExpr)));
} }
void SignedCharMisuseCheck::registerMatchers(MatchFinder *Finder) { void SignedCharMisuseCheck::registerMatchers(MatchFinder *Finder) {
const auto IntegerType = const auto IntegerType =
qualType(isInteger(), unless(isAnyCharacter()), unless(booleanType())) qualType(isInteger(), unless(isAnyCharacter()), unless(booleanType()))
.bind("integerType"); .bind("integerType");
const auto SignedCharCastExpr = const auto SignedCharCastExpr =
charCastExpression(true, IntegerType, "signedCastExpression"); charCastExpression(true, IntegerType, "signedCastExpression");
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

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

Show All 17 Lines
namespace { namespace {
bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx, bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
const StringLiteral *Lit) { const StringLiteral *Lit) {
// String literals surrounded by parentheses are assumed to be on purpose. // String literals surrounded by parentheses are assumed to be on purpose.
// i.e.: const char* Array[] = { ("a" "b" "c"), "d", [...] }; // i.e.: const char* Array[] = { ("a" "b" "c"), "d", [...] };
TraversalKindScope RAII(*Ctx, ast_type_traits::TK_AsIs); TraversalKindScope RAII(*Ctx, TK_AsIs);
auto Parents = Ctx->getParents(*Lit); auto Parents = Ctx->getParents(*Lit);
if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr) if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr)
return true; return true;
// Appropriately indented string literals are assumed to be on purpose. // Appropriately indented string literals are assumed to be on purpose.
// The following frequent indentation is accepted: // The following frequent indentation is accepted:
// const char* Array[] = { // const char* Array[] = {
// "first literal" // "first literal"
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines 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, traverse(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(unless(anyOf(isComparisonOperator(), hasOperatorName("&&"), binaryOperator(unless(anyOf(isComparisonOperator(), hasOperatorName("&&"),
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 51 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(
traverse(ast_type_traits::TK_AsIs, 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()),
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesvoid UndelegatedConstructorCheck::registerMatchers(MatchFinder *Finder) {
// We look for calls to constructors of the same type in constructors. To do // We look for calls to constructors of the same type in constructors. To do
// this we have to look through a variety of nodes that occur in the path, // this we have to look through a variety of nodes that occur in the path,
// depending on the type's destructor and the number of arguments on the // depending on the type's destructor and the number of arguments on the
// constructor call, this is handled by ignoringTemporaryExpr. Ignore template // constructor call, this is handled by ignoringTemporaryExpr. Ignore template
// instantiations to reduce the number of duplicated warnings. // instantiations to reduce the number of duplicated warnings.
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
compoundStmt(hasParent(cxxConstructorDecl( compoundStmt(hasParent(cxxConstructorDecl(
ofClass(cxxRecordDecl().bind("parent")))), ofClass(cxxRecordDecl().bind("parent")))),
forEach(ignoringTemporaryExpr( forEach(ignoringTemporaryExpr(
cxxConstructExpr( cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(ofClass( hasDeclaration(cxxConstructorDecl(ofClass(
cxxRecordDecl(baseOfBoundNode("parent")))))) cxxRecordDecl(baseOfBoundNode("parent"))))))
.bind("construct"))), .bind("construct"))),
unless(isInTemplateInstantiation()))), unless(isInTemplateInstantiation()))),
Show All 13 Lines

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines const auto HasNoSelfCheck = cxxMethodDecl(unless(anyOf(
hasAnyOverloadedOperatorName("==", "!="), argumentCountIs(2), hasAnyOverloadedOperatorName("==", "!="), argumentCountIs(2),
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 = cxxMethodDecl(
ofClass(cxxRecordDecl(unless(hasAncestor(classTemplateDecl())))), ofClass(cxxRecordDecl(unless(hasAncestor(classTemplateDecl())))),
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
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()))),
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show All 26 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 = cxxBindTemporaryExpr( auto BindTemp = cxxBindTemporaryExpr(
unless(has(ignoringParenImpCasts(callExpr()))), unless(has(ignoringParenImpCasts(callExpr()))),
unless(has(ignoringParenImpCasts(objcMessageExpr())))) unless(has(ignoringParenImpCasts(objcMessageExpr()))))
.bind("temp"); .bind("temp");
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
exprWithCleanups( exprWithCleanups(
unless(isInTemplateInstantiation()), 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")),
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 269 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( addDeclRefs(match(traverse(TK_AsIs, findAll(DeclRefMatcher)), *S->getStmt(),
match(traverse(ast_type_traits::TK_AsIs, findAll(DeclRefMatcher)), *Context));
*S->getStmt(), *Context));
addDeclRefs(match(findAll(cxxOperatorCallExpr( addDeclRefs(match(findAll(cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("*", "->", "[]"), hasAnyOverloadedOperatorName("*", "->", "[]"),
hasArgument(0, DeclRefMatcher)) hasArgument(0, DeclRefMatcher))
.bind("operator")), .bind("operator")),
*S->getStmt(), *Context)); *S->getStmt(), *Context));
} }
} }
▲ Show 20 Lines • Show All 48 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(
traverse(ast_type_traits::TK_AsIs, DeclRefMatcher), traverse(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 47 Lines • ▼ Show 20 Lines auto CallMoveMatcher =
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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
// To find the Stmt that we assume performs the actual move, we look // 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 // for the direct ancestor of the std::move() that isn't one of the
// node types ignored by ignoringParenImpCasts(). // node types ignored by ignoringParenImpCasts().
stmt( stmt(
forEach(expr(ignoringParenImpCasts(CallMoveMatcher))), forEach(expr(ignoringParenImpCasts(CallMoveMatcher))),
// Don't allow an InitListExpr to be the moving call. An // Don't allow an InitListExpr to be the moving call. An
// InitListExpr has both a syntactic and a semantic form, and the // InitListExpr has both a syntactic and a semantic form, and the
// parent-child relationships are different between the two. This // parent-child relationships are different between the two. This
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

Show All 24 Lines const auto MemberExprOrSourceObject = anyOf(
memberExpr(), memberExpr(),
declRefExpr(to(decl(equalsBoundNode(std::string(SourceDeclName)))))); declRefExpr(to(decl(equalsBoundNode(std::string(SourceDeclName))))));
const auto IsPartOfSource = const auto IsPartOfSource =
allOf(unless(hasDescendant(expr(unless(MemberExprOrSourceObject)))), allOf(unless(hasDescendant(expr(unless(MemberExprOrSourceObject)))),
MemberExprOrSourceObject); MemberExprOrSourceObject);
const auto IsSourceMutatingAssignment = traverse( const auto IsSourceMutatingAssignment = traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
expr(anyOf(binaryOperator(isAssignmentOperator(), hasLHS(IsPartOfSource)) expr(anyOf(binaryOperator(isAssignmentOperator(), hasLHS(IsPartOfSource))
.bind(MutatingOperatorName), .bind(MutatingOperatorName),
cxxOperatorCallExpr(isAssignmentOperator(), cxxOperatorCallExpr(isAssignmentOperator(),
hasArgument(0, IsPartOfSource)) hasArgument(0, IsPartOfSource))
.bind(MutatingOperatorName)))); .bind(MutatingOperatorName))));
const auto MemberExprOrSelf = anyOf(memberExpr(), cxxThisExpr()); const auto MemberExprOrSelf = anyOf(memberExpr(), cxxThisExpr());
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 56 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, traverse(TK_AsIs,
cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor")), cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor")),
this); this);
// srand(); // srand();
// ^ // ^
// const int x = 1; // const int x = 1;
// srand(x); // srand(x);
// ^ // ^
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show All 16 Lines
namespace tidy { namespace tidy {
namespace cert { namespace cert {
void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) { void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
// 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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
varDecl( varDecl(
anyOf(hasThreadStorageDuration(), hasStaticStorageDuration()), 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")))),
Show All 27 Lines

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

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) { void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, 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(traverse(ast_type_traits::TK_AsIs, Finder->addMatcher(
varDecl(GlobalVarDecl, isDefinition(), traverse(TK_AsIs, varDecl(GlobalVarDecl, isDefinition(),
hasInitializer(expr(hasDescendant( hasInitializer(expr(hasDescendant(
ReferencesUndefinedGlobalVar)))) 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;
const auto *const Referencee = Result.Nodes.getNodeAs<VarDecl>("referencee"); const auto *const Referencee = Result.Nodes.getNodeAs<VarDecl>("referencee");
Show All 16 Lines

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

Show All 40 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( traverse(TK_AsIs, implicitCastExpr(
ast_type_traits::TK_AsIs, hasImplicitDestinationType(
implicitCastExpr(hasImplicitDestinationType(
hasUnqualifiedDesugaredType(builtinType())), hasUnqualifiedDesugaredType(builtinType())),
hasSourceExpression(hasType( hasSourceExpression(hasType(
hasUnqualifiedDesugaredType(builtinType()))), hasUnqualifiedDesugaredType(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( Finder->addMatcher(
binaryOperator( binaryOperator(
isAssignmentOperator(), isAssignmentOperator(),
hasLHS(expr(hasType(hasUnqualifiedDesugaredType(builtinType())))), hasLHS(expr(hasType(hasUnqualifiedDesugaredType(builtinType())))),
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines const auto CreatesOwner =
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, traverse(TK_AsIs,
cxxDeleteExpr(hasDescendant(declRefExpr(unless(ConsideredOwner)) cxxDeleteExpr(hasDescendant(declRefExpr(unless(ConsideredOwner))
.bind("deleted_variable"))) .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, traverse(TK_AsIs, callExpr(callee(LegacyOwnerConsumers),
callExpr(callee(LegacyOwnerConsumers), hasAnyArgument(expr(
hasAnyArgument( unless(ignoringImpCasts(ConsideredOwner)),
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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
binaryOperator(isAssignmentOperator(), hasLHS(IsOwnerType), binaryOperator(isAssignmentOperator(), 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, traverse(TK_AsIs,
namedDecl( namedDecl(
varDecl(hasInitializer(unless(ConsideredOwner)), IsOwnerType) 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(traverse(ast_type_traits::TK_AsIs, Finder->addMatcher(
cxxRecordDecl(HasConstructorInitializerForOwner)), traverse(TK_AsIs, cxxRecordDecl(HasConstructorInitializerForOwner)),
this); 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(isAssignmentOperator(), Finder->addMatcher(binaryOperator(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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
namedDecl( namedDecl(
varDecl(eachOf(allOf(hasInitializer(CreatesOwner), 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);
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) { void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) {
// 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, traverse(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);
} }
Show All 15 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(TK_AsIs, expr(anyOf(SlicesObjectInAssignment,
traverse(ast_type_traits::TK_AsIs, SlicesObjectInCtor))
expr(anyOf(SlicesObjectInAssignment, SlicesObjectInCtor))
.bind("Call")), .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,
const CXXRecordDecl &BaseDecl) { const CXXRecordDecl &BaseDecl) {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

Show All 20 Lines
AST_MATCHER(VarDecl, isGlobalStatic) { AST_MATCHER(VarDecl, isGlobalStatic) {
return Node.getStorageDuration() == SD_Static && !Node.isLocalVarDecl(); return Node.getStorageDuration() == SD_Static && !Node.isLocalVarDecl();
} }
} // namespace } // namespace
void StaticallyConstructedObjectsCheck::registerMatchers(MatchFinder *Finder) { void 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.
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
varDecl( 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.
Show All 15 Lines

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines auto CallExpression =
allOf(callee(namedDecl(hasAnyName("isa", "cast", "cast_or_null", allOf(callee(namedDecl(hasAnyName("isa", "cast", "cast_or_null",
"dyn_cast", "dyn_cast_or_null")) "dyn_cast", "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, traverse(TK_AsIs,
stmt(anyOf( stmt(anyOf(
ifStmt(Any), whileStmt(Any), doStmt(Condition), 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)),
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show All 15 Lines
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, traverse(TK_AsIs,
valueDecl(allOf( valueDecl(allOf(
hasType(qualType(isUnsignedInteger()).bind("varType")), hasType(qualType(isUnsignedInteger()).bind("varType")),
varDecl(hasInitializer(exprWithCleanups( varDecl(hasInitializer(exprWithCleanups(
has(implicitCastExpr(has(cxxMemberCallExpr( has(implicitCastExpr(has(cxxMemberCallExpr(
allOf(on(RegisterClassMatch), allOf(on(RegisterClassMatch),
has(memberExpr(hasDeclaration( has(memberExpr(hasDeclaration(
cxxConversionDecl()))))))))))) cxxConversionDecl())))))))))))
.bind("var")))), .bind("var")))),
Show All 34 Lines

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

Show First 20 Lines • Show All 360 Lines • ▼ Show 20 Lines
} }
template <typename TExpr> template <typename TExpr>
static bool hasSameOperatorParent(const Expr *TheExpr, static bool hasSameOperatorParent(const Expr *TheExpr,
OverloadedOperatorKind OpKind, OverloadedOperatorKind OpKind,
ASTContext &Context) { ASTContext &Context) {
// IgnoreParenImpCasts logic in reverse: skip surrounding uninteresting nodes // IgnoreParenImpCasts logic in reverse: skip surrounding uninteresting nodes
const DynTypedNodeList Parents = Context.getParents(*TheExpr); const DynTypedNodeList Parents = Context.getParents(*TheExpr);
for (ast_type_traits::DynTypedNode DynParent : Parents) { for (DynTypedNode DynParent : Parents) {
if (const auto *Parent = DynParent.get<Expr>()) { if (const auto *Parent = DynParent.get<Expr>()) {
bool Skip = isa<ParenExpr>(Parent) || isa<ImplicitCastExpr>(Parent) || bool Skip = isa<ParenExpr>(Parent) || isa<ImplicitCastExpr>(Parent) ||
isa<FullExpr>(Parent) || isa<FullExpr>(Parent) ||
isa<MaterializeTemporaryExpr>(Parent); isa<MaterializeTemporaryExpr>(Parent);
if (Skip && hasSameOperatorParent<TExpr>(Parent, OpKind, Context)) if (Skip && hasSameOperatorParent<TExpr>(Parent, OpKind, Context))
return true; return true;
if (checkOpKind<TExpr>(Parent, OpKind)) if (checkOpKind<TExpr>(Parent, OpKind))
return true; return true;
Show All 37 Lines for (size_t I = 0; I < NumOperands; I++) {
for (size_t J = I + 1; J < NumOperands; J++) { for (size_t J = I + 1; J < NumOperands; J++) {
if (AllOperands[J]->HasSideEffects(Context)) if (AllOperands[J]->HasSideEffects(Context))
break; break;
if (areEquivalentExpr(AllOperands[I], AllOperands[J])) { if (areEquivalentExpr(AllOperands[I], AllOperands[J])) {
FoundDuplicates = true; FoundDuplicates = true;
Duplicates.set(J); Duplicates.set(J);
Builder->setBinding( Builder->setBinding(SmallString<11>(llvm::formatv("duplicate{0}", J)),
SmallString<11>(llvm::formatv("duplicate{0}", J)), DynTypedNode::create(*AllOperands[J]));
ast_type_traits::DynTypedNode::create(*AllOperands[J]));
} }
} }
if (FoundDuplicates) if (FoundDuplicates)
Builder->setBinding( Builder->setBinding(SmallString<11>(llvm::formatv("duplicate{0}", I)),
SmallString<11>(llvm::formatv("duplicate{0}", I)), DynTypedNode::create(*AllOperands[I]));
ast_type_traits::DynTypedNode::create(*AllOperands[I]));
} }
return Duplicates.any(); return Duplicates.any();
} }
AST_MATCHER(Expr, isIntegerConstantExpr) { AST_MATCHER(Expr, isIntegerConstantExpr) {
if (Node.isInstantiationDependent()) if (Node.isInstantiationDependent())
return false; return false;
▲ Show 20 Lines • Show All 391 Lines • ▼ Show 20 Linesvoid 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, traverse(TK_AsIs,
binaryOperator( binaryOperator(
anyOf(isComparisonOperator(), anyOf(isComparisonOperator(),
hasAnyOperatorName("-", "/", "%", "|", "&", "^", "&&", hasAnyOperatorName("-", "/", "%", "|", "&", "^", "&&",
"||", "=")), "||", "=")),
operandsAreEquivalent(), operandsAreEquivalent(),
// Filter noisy false positives. // Filter noisy false positives.
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
unless(binaryOperatorIsInMacro()), unless(binaryOperatorIsInMacro()),
Show All 14 Lines Finder->addMatcher(
unless(binaryOperatorIsInMacro()), unless(binaryOperatorIsInMacro()),
// TODO: if the banned macros are themselves duplicated // TODO: if the banned macros are themselves duplicated
unless(hasDescendant(BannedIntegerLiteral))) unless(hasDescendant(BannedIntegerLiteral)))
.bind("nested-duplicates"), .bind("nested-duplicates"),
this); this);
// Conditional (trenary) operator with equivalent operands, like (Y ? X : X). // Conditional (trenary) operator with equivalent operands, like (Y ? X : X).
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
conditionalOperator(expressionsAreEquivalent(), 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, traverse(TK_AsIs,
cxxOperatorCallExpr( cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("-", "/", "%", "|", "&", "^", hasAnyOverloadedOperatorName("-", "/", "%", "|", "&", "^",
"==", "!=", "<", "<=", ">", "==", "!=", "<", "<=", ">",
">=", "&&", "||", "="), ">=", "&&", "||", "="),
parametersAreEquivalent(), parametersAreEquivalent(),
// Filter noisy false positives. // Filter noisy false positives.
unless(isMacro()), unless(isInTemplateInstantiation())) unless(isMacro()), unless(isInTemplateInstantiation()))
.bind("call")), .bind("call")),
this); this);
// Overloaded operators with equivalent operands. // Overloaded operators with equivalent operands.
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr( cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("|", "&", "||", "&&", "^"), hasAnyOverloadedOperatorName("|", "&", "||", "&&", "^"),
nestedParametersAreEquivalent(), argumentCountIs(2), nestedParametersAreEquivalent(), argumentCountIs(2),
// Filter noisy false positives. // Filter noisy false positives.
unless(isMacro()), unless(isInTemplateInstantiation())) unless(isMacro()), unless(isInTemplateInstantiation()))
.bind("nested-duplicates"), .bind("nested-duplicates"),
this); this);
// Match expressions like: !(1 | 2 | 3) // Match expressions like: !(1 | 2 | 3)
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
implicitCastExpr( implicitCastExpr(
hasImplicitDestinationType(isInteger()), hasImplicitDestinationType(isInteger()),
has(unaryOperator( has(unaryOperator(
hasOperatorName("!"), hasOperatorName("!"),
hasUnaryOperand(ignoringParenImpCasts(binaryOperator( hasUnaryOperand(ignoringParenImpCasts(binaryOperator(
hasAnyOperatorName("|", "&"), hasAnyOperatorName("|", "&"),
hasLHS(anyOf( hasLHS(anyOf(
binaryOperator(hasAnyOperatorName("|", "&")), binaryOperator(hasAnyOperatorName("|", "&")),
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( traverse(TK_AsIs,
ast_type_traits::TK_AsIs,
binaryOperator( binaryOperator(
hasOperatorName("&"), hasOperatorName("&"),
hasOperands( hasOperands(ignoringParenImpCasts(binaryOperator(
ignoringParenImpCasts( hasOperatorName("<<"),
binaryOperator(hasOperatorName("<<"),
hasRHS(ignoringParenImpCasts( hasRHS(ignoringParenImpCasts(
integerLiteral().bind("shift-const"))))), integerLiteral().bind("shift-const"))))),
ignoringParenImpCasts(integerLiteral().bind("and-const")))) ignoringParenImpCasts(
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(traverse(ast_type_traits::TK_AsIs, Finder->addMatcher(
binaryOperator(isComparisonOperator(), traverse(TK_AsIs, binaryOperator(isComparisonOperator(),
hasOperands(BinOpCstLeft, hasOperands(BinOpCstLeft, CstRight))
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( traverse(
ast_type_traits::TK_AsIs, 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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
binaryOperator(isComparisonOperator(), hasLHS(BinOpCstLeft), binaryOperator(isComparisonOperator(), hasLHS(BinOpCstLeft),
hasRHS(BinOpCstRight), 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, traverse(TK_AsIs,
binaryOperator(hasAnyOperatorName("||", "&&"), binaryOperator(hasAnyOperatorName("||", "&&"),
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);
} }
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 523 Lines • ▼ Show 20 Lines
void LoopConvertCheck::registerPPCallbacks(const SourceManager &SM, void LoopConvertCheck::registerPPCallbacks(const SourceManager &SM,
Preprocessor *PP, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) { Preprocessor *ModuleExpanderPP) {
Inserter.registerPreprocessor(PP); Inserter.registerPreprocessor(PP);
} }
void LoopConvertCheck::registerMatchers(MatchFinder *Finder) { void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, makeArrayLoopMatcher()), Finder->addMatcher(traverse(TK_AsIs, makeArrayLoopMatcher()), this);
this); Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(false)), this);
Finder->addMatcher( Finder->addMatcher(traverse(TK_AsIs, makePseudoArrayLoopMatcher()), this);
traverse(ast_type_traits::TK_AsIs, makeIteratorLoopMatcher(false)), this);
Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, makePseudoArrayLoopMatcher()), this);
if (UseReverseRanges) if (UseReverseRanges)
Finder->addMatcher( Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(true)), this);
traverse(ast_type_traits::TK_AsIs, makeIteratorLoopMatcher(true)),
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 410 Lines • ▼ Show 20 Lines if (FixerKind == LFK_Array) {
// array variables. Consider loops over arrays that aren't just represented // array variables. Consider loops over arrays that aren't just represented
// by a variable to be risky conversions. // by a variable to be risky conversions.
if (!getReferencedVariable(ContainerExpr) && if (!getReferencedVariable(ContainerExpr) &&
!isDirectMemberExpr(ContainerExpr)) !isDirectMemberExpr(ContainerExpr))
ConfidenceLevel.lowerTo(Confidence::CL_Risky); ConfidenceLevel.lowerTo(Confidence::CL_Risky);
} }
// Find out which qualifiers we have to use in the loop range. // Find out which qualifiers we have to use in the loop range.
TraversalKindScope RAII(*Context, ast_type_traits::TK_AsIs); TraversalKindScope RAII(*Context, TK_AsIs);
const UsageResult &Usages = Finder.getUsages(); const UsageResult &Usages = Finder.getUsages();
determineRangeDescriptor(Context, Nodes, Loop, FixerKind, ContainerExpr, determineRangeDescriptor(Context, Nodes, Loop, FixerKind, ContainerExpr,
Usages, Descriptor); Usages, Descriptor);
// Ensure that we do not try to move an expression dependent on a local // Ensure that we do not try to move an expression dependent on a local
// variable declared inside the loop outside of it. // variable declared inside the loop outside of it.
// FIXME: Determine when the external dependency isn't an expression converted // FIXME: Determine when the external dependency isn't an expression converted
// by another loop. // by another loop.
Show All 36 Lines

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

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesvoid MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
// 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())))))));
auto IsPlacement = hasAnyPlacementArg(anything()); auto IsPlacement = hasAnyPlacementArg(anything());
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxBindTemporaryExpr(has(ignoringParenImpCasts( cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr( cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1), hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
hasArgument( hasArgument(
0, cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType( 0, cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
equalsBoundNode(PointerType))))), equalsBoundNode(PointerType))))),
CanCallCtor, unless(IsPlacement)) CanCallCtor, unless(IsPlacement))
.bind(NewExpression)), .bind(NewExpression)),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind(ConstructorCall))))), .bind(ConstructorCall))))),
this); this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
cxxMemberCallExpr( cxxMemberCallExpr(
thisPointerType(getSmartPointerTypeMatcher()), thisPointerType(getSmartPointerTypeMatcher()),
callee(cxxMethodDecl(hasName("reset"))), callee(cxxMethodDecl(hasName("reset"))),
hasArgument(0, cxxNewExpr(CanCallCtor, unless(IsPlacement)) hasArgument(0, cxxNewExpr(CanCallCtor, unless(IsPlacement))
.bind(NewExpression)), .bind(NewExpression)),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind(ResetCall)), .bind(ResetCall)),
this); this);
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Linesvoid MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
insertHeader(Diag, SM.getFileID(OperatorLoc)); insertHeader(Diag, SM.getFileID(OperatorLoc));
} }
bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag, bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
const CXXNewExpr *New, SourceManager &SM, const CXXNewExpr *New, SourceManager &SM,
ASTContext *Ctx) { ASTContext *Ctx) {
auto SkipParensParents = [&](const Expr *E) { auto SkipParensParents = [&](const Expr *E) {
TraversalKindScope RAII(*Ctx, ast_type_traits::TK_AsIs); TraversalKindScope RAII(*Ctx, TK_AsIs);
for (const Expr *OldE = nullptr; E != OldE;) { for (const Expr *OldE = nullptr; E != OldE;) {
OldE = E; OldE = E;
for (const auto &Node : Ctx->getParents(*E)) { for (const auto &Node : Ctx->getParents(*E)) {
if (const Expr *Parent = Node.get<ParenExpr>()) { if (const Expr *Parent = Node.get<ParenExpr>()) {
E = Parent; E = Parent;
break; break;
} }
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IncludeStyle", Inserter.getStyle()); Options.store(Opts, "IncludeStyle", Inserter.getStyle());
Options.store(Opts, "ValuesOnly", ValuesOnly); Options.store(Opts, "ValuesOnly", ValuesOnly);
} }
void PassByValueCheck::registerMatchers(MatchFinder *Finder) { void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
forEachConstructorInitializer( forEachConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
unless(isBaseInitializer()), unless(isBaseInitializer()),
// Clang builds a CXXConstructExpr only when it knows // Clang builds a CXXConstructExpr only when it knows
// which constructor will be called. In dependent contexts // which constructor will be called. In dependent contexts
// a ParenListExpr is generated instead of a // a ParenListExpr is generated instead of a
// CXXConstructExpr, filtering out templates automatically // CXXConstructExpr, filtering out templates automatically
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines auto MovableArgumentMatcher =
expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId); expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId);
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr(hasOverloadedOperatorName("="), cxxOperatorCallExpr(hasOverloadedOperatorName("="),
callee(cxxMethodDecl(ofClass(AutoPtrDecl))), callee(cxxMethodDecl(ofClass(AutoPtrDecl))),
hasArgument(1, MovableArgumentMatcher)), hasArgument(1, MovableArgumentMatcher)),
this); this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1), cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
hasArgument(0, MovableArgumentMatcher))), 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) {
▲ Show 20 Lines • Show All 55 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) {
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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
callExpr( callExpr(
anyOf(allOf(Begin, End, argumentCountIs(2)), 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);
} }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show All 25 Lines auto ConstructExpr =
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, traverse(TK_AsIs,
functionDecl( functionDecl(
isDefinition(), // Declarations don't have return statements. 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);
} }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show All 36 Lines const auto SwapParam =
unaryOperator(has(ignoringParenImpCasts(declRefExpr( unaryOperator(has(ignoringParenImpCasts(declRefExpr(
hasDeclaration(equalsBoundNode("ContainerDecl")))))))); hasDeclaration(equalsBoundNode("ContainerDecl"))))))));
Finder->addMatcher( Finder->addMatcher(
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(traverse( has(ignoringParenImpCasts(
ast_type_traits::TK_AsIs, hasDescendant(CopyCtorCall))))), memberExpr(traverse(TK_AsIs, 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 =
Show All 33 Lines

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

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines : ClangTidyCheck(Name, Context),
RemoveStars(Options.get("RemoveStars", false)) {} RemoveStars(Options.get("RemoveStars", false)) {}
void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MinTypeNameLength", MinTypeNameLength); Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
Options.store(Opts, "RemoveStars", RemoveStars); Options.store(Opts, "RemoveStars", RemoveStars);
} }
void UseAutoCheck::registerMatchers(MatchFinder *Finder) { void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, makeCombinedMatcher()), Finder->addMatcher(traverse(TK_AsIs, makeCombinedMatcher()), this);
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();
// Skip expressions with cleanups from the initializer expression. // Skip expressions with cleanups from the initializer expression.
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

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

Show All 23 Lines
void UseBoolLiteralsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void UseBoolLiteralsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
} }
void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) { void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, 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, traverse(TK_AsIs,
conditionalOperator( conditionalOperator(
hasParent(implicitCastExpr( hasParent(implicitCastExpr(
hasImplicitDestinationType(qualType(booleanType())), hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()))), unless(isInTemplateInstantiation()))),
eachOf(hasTrueExpression(ignoringParenImpCasts( eachOf(hasTrueExpression(ignoringParenImpCasts(
integerLiteral().bind("literal"))), integerLiteral().bind("literal"))),
hasFalseExpression(ignoringParenImpCasts( hasFalseExpression(ignoringParenImpCasts(
integerLiteral().bind("literal")))))), integerLiteral().bind("literal")))))),
Show All 30 Lines

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

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines auto MakeTupleCtor = ignoringImplicit(cxxConstructExpr(
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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxMemberCallExpr(CallPushBack, has(SoughtParam),
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 52 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linesstatic bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
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, traverse(TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
forEachConstructorInitializer(cxxCtorInitializer( forEachConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(), isBaseInitializer(),
withInitializer(cxxConstructExpr( withInitializer(cxxConstructExpr(
hasType(equalsNode(Base)), hasType(equalsNode(Base)),
hasDeclaration( hasDeclaration(
cxxConstructorDecl(isCopyConstructor())), cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1), argumentCountIs(1),
hasArgument(0, declRefExpr(to(varDecl( hasArgument(0, declRefExpr(to(varDecl(
equalsNode(Param))))))))))), 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(traverse( if (match(traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
forEachConstructorInitializer(cxxCtorInitializer( 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( hasDeclaration(
Show All 24 Linesstatic bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
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(traverse( match(traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
returnStmt(has(ignoringParenImpCasts(unaryOperator( returnStmt(has(ignoringParenImpCasts(unaryOperator(
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())))))), 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(traverse(ast_type_traits::TK_AsIs, if (match(traverse(TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr( compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(
// - The object is an implicit cast of 'this' to a // - The object is an implicit cast of 'this' to a
// pointer to // pointer to
// a base class. // a base class.
onImplicitObjectArgument(implicitCastExpr( onImplicitObjectArgument(implicitCastExpr(
hasImplicitDestinationType( hasImplicitDestinationType(
pointsTo(type(equalsNode(Base)))), pointsTo(type(equalsNode(Base)))),
hasSourceExpression(cxxThisExpr()))), hasSourceExpression(cxxThisExpr()))),
Show All 14 Lines 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, traverse(TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(stmt(anyOf( compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
binaryOperator(hasOperatorName("="), hasLHS(LHS), binaryOperator(hasOperatorName("="), hasLHS(LHS),
hasRHS(RHS)), hasRHS(RHS)),
cxxOperatorCallExpr( cxxOperatorCallExpr(
hasOverloadedOperatorName("="), argumentCountIs(2), hasOverloadedOperatorName("="), argumentCountIs(2),
hasArgument(0, LHS), hasArgument(1, RHS)))))))), hasArgument(0, LHS), hasArgument(1, RHS)))))))),
*Compound, *Context) *Compound, *Context)
.empty()) .empty())
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

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

Show All 36 Lines
/// can be replaced instead of just the inner-most implicit cast. /// can be replaced instead of just the inner-most implicit cast.
StatementMatcher makeCastSequenceMatcher() { StatementMatcher makeCastSequenceMatcher() {
StatementMatcher ImplicitCastToNull = implicitCastExpr( StatementMatcher ImplicitCastToNull = implicitCastExpr(
anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)), anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)),
unless(hasImplicitDestinationType(qualType(substTemplateTypeParmType()))), unless(hasImplicitDestinationType(qualType(substTemplateTypeParmType()))),
unless(hasSourceExpression(hasType(sugaredNullptrType())))); unless(hasSourceExpression(hasType(sugaredNullptrType()))));
return traverse( return traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
castExpr(anyOf(ImplicitCastToNull, castExpr(anyOf(ImplicitCastToNull,
explicitCastExpr(hasDescendant(ImplicitCastToNull))), explicitCastExpr(hasDescendant(ImplicitCastToNull))),
unless(hasAncestor(explicitCastExpr()))) unless(hasAncestor(explicitCastExpr())))
.bind(CastSequence)); .bind(CastSequence));
} }
bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc, bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc,
const SourceManager &SM) { const SourceManager &SM) {
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Lines bool allArgUsesValid(const CastExpr *CE) {
// Step 1: Get location of macro arg and location of the macro the arg was // Step 1: Get location of macro arg and location of the macro the arg was
// provided to. // provided to.
SourceLocation ArgLoc, MacroLoc; SourceLocation ArgLoc, MacroLoc;
if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc)) if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc))
return false; return false;
// Step 2: Find the first ancestor that doesn't expand from this macro. // Step 2: Find the first ancestor that doesn't expand from this macro.
ast_type_traits::DynTypedNode ContainingAncestor; DynTypedNode ContainingAncestor;
if (!findContainingAncestor( if (!findContainingAncestor(DynTypedNode::create<Stmt>(*CE), MacroLoc,
ast_type_traits::DynTypedNode::create<Stmt>(*CE), MacroLoc,
ContainingAncestor)) ContainingAncestor))
return false; return false;
// Step 3: // Step 3:
// Visit children of this containing parent looking for the least-descended // Visit children of this containing parent looking for the least-descended
// nodes of the containing parent which are macro arg expansions that expand // nodes of the containing parent which are macro arg expansions that expand
// from the given arg location. // from the given arg location.
// Visitor needs: arg loc. // Visitor needs: arg loc.
MacroArgUsageVisitor ArgUsageVisitor(SM.getFileLoc(CastLoc), SM); MacroArgUsageVisitor ArgUsageVisitor(SM.getFileLoc(CastLoc), SM);
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines bool expandsFrom(SourceLocation TestLoc, SourceLocation TestMacroLoc) {
llvm_unreachable("expandsFrom"); llvm_unreachable("expandsFrom");
} }
/// Given a starting point \c Start in the AST, find an ancestor that /// Given a starting point \c Start in the AST, find an ancestor that
/// doesn't expand from the macro called at file location \c MacroLoc. /// doesn't expand from the macro called at file location \c MacroLoc.
/// ///
/// \pre MacroLoc.isFileID() /// \pre MacroLoc.isFileID()
/// \returns true if such an ancestor was found, false otherwise. /// \returns true if such an ancestor was found, false otherwise.
bool findContainingAncestor(ast_type_traits::DynTypedNode Start, bool findContainingAncestor(DynTypedNode Start, SourceLocation MacroLoc,
SourceLocation MacroLoc, DynTypedNode &Result) {
ast_type_traits::DynTypedNode &Result) {
// Below we're only following the first parent back up the AST. This should // Below we're only following the first parent back up the AST. This should
// be fine since for the statements we care about there should only be one // be fine since for the statements we care about there should only be one
// parent, except for the case specified below. // parent, except for the case specified below.
assert(MacroLoc.isFileID()); assert(MacroLoc.isFileID());
while (true) { while (true) {
const auto &Parents = Context.getParents(Start); const auto &Parents = Context.getParents(Start);
if (Parents.empty()) if (Parents.empty())
return false; return false;
if (Parents.size() > 1) { if (Parents.size() > 1) {
// If there are more than one parents, don't do the replacement unless // If there are more than one parents, don't do the replacement unless
// they are InitListsExpr (semantic and syntactic form). In this case we // they are InitListsExpr (semantic and syntactic form). In this case we
// can choose any one here, and the ASTVisitor will take care of // can choose any one here, and the ASTVisitor will take care of
// traversing the right one. // traversing the right one.
for (const auto &Parent : Parents) { for (const auto &Parent : Parents) {
if (!Parent.get<InitListExpr>()) if (!Parent.get<InitListExpr>())
return false; return false;
} }
} }
const ast_type_traits::DynTypedNode &Parent = Parents[0]; const DynTypedNode &Parent = Parents[0];
SourceLocation Loc; SourceLocation Loc;
if (const auto *D = Parent.get<Decl>()) if (const auto *D = Parent.get<Decl>())
Loc = D->getBeginLoc(); Loc = D->getBeginLoc();
else if (const auto *S = Parent.get<Stmt>()) else if (const auto *S = Parent.get<Stmt>())
Loc = S->getBeginLoc(); Loc = S->getBeginLoc();
// TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip // TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/objc/NSInvocationArgumentLifetimeCheck.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 LinesfixItHintForVarDecl(const VarDecl *VD, const SourceManager &SM,
return FixItHint::CreateInsertion(Range.getBegin(), "__unsafe_unretained "); return FixItHint::CreateInsertion(Range.getBegin(), "__unsafe_unretained ");
} }
} // namespace } // namespace
void NSInvocationArgumentLifetimeCheck::registerMatchers(MatchFinder *Finder) { void NSInvocationArgumentLifetimeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
objcMessageExpr( objcMessageExpr(
hasReceiverType(asString("NSInvocation *")), hasReceiverType(asString("NSInvocation *")),
anyOf(hasSelector("getArgument:atIndex:"), anyOf(hasSelector("getArgument:atIndex:"),
hasSelector("getReturnValue:")), hasSelector("getReturnValue:")),
hasArgument( hasArgument(
0, 0,
anyOf(hasDescendant(memberExpr(isObjCManagedLifetime())), anyOf(hasDescendant(memberExpr(isObjCManagedLifetime())),
hasDescendant(objcIvarRefExpr(isObjCManagedLifetime())), hasDescendant(objcIvarRefExpr(isObjCManagedLifetime())),
Show All 36 Lines

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

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines auto IteratorReturnsValueType = cxxOperatorCallExpr(
hasOverloadedOperatorName("*"), hasOverloadedOperatorName("*"),
callee( callee(
cxxMethodDecl(returns(unless(hasCanonicalType(referenceType())))))); cxxMethodDecl(returns(unless(hasCanonicalType(referenceType()))))));
auto LoopVar = auto LoopVar =
varDecl(HasReferenceOrPointerTypeOrIsAllowed, varDecl(HasReferenceOrPointerTypeOrIsAllowed,
unless(hasInitializer(expr(hasDescendant(expr(anyOf( unless(hasInitializer(expr(hasDescendant(expr(anyOf(
materializeTemporaryExpr(), IteratorReturnsValueType))))))); materializeTemporaryExpr(), IteratorReturnsValueType)))))));
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar"))) cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar")))
.bind("forRange")), .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");
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid ImplicitConversionInLoopCheck::registerMatchers(MatchFinder *Finder) {
// 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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxForRangeStmt(hasLoopVariable( cxxForRangeStmt(hasLoopVariable(
varDecl( varDecl(
hasType(qualType(references(qualType(isConstQualified())))), hasType(qualType(references(qualType(isConstQualified())))),
hasInitializer( hasInitializer(
expr(anyOf( expr(anyOf(
hasDescendant( hasDescendant(
cxxOperatorCallExpr().bind("operator-call")), cxxOperatorCallExpr().bind("operator-call")),
hasDescendant(unaryOperator(hasOperatorName("*")) hasDescendant(unaryOperator(hasOperatorName("*"))
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

Show All 30 Lines 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 = traverse( const auto Matcher = traverse(
ast_type_traits::TK_AsIs, 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")),
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesvoid MoveConstArgCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(MoveCallMatcher, this); Finder->addMatcher(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(callExpr(ConstParamMatcher).bind("receiving-expr"), this);
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
cxxConstructExpr(ConstParamMatcher).bind("receiving-expr")), 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);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show All 22 Lines
MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name, MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
Inserter(Options.getLocalOrGlobal("IncludeStyle", Inserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM)) {} utils::IncludeSorter::IS_LLVM)) {}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) { void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
cxxConstructorDecl( cxxConstructorDecl(
unless(isImplicit()), isMoveConstructor(), unless(isImplicit()), isMoveConstructor(),
hasAnyConstructorInitializer( hasAnyConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
withInitializer(cxxConstructExpr(hasDeclaration( withInitializer(cxxConstructExpr(hasDeclaration(
cxxConstructorDecl(isCopyConstructor()) cxxConstructorDecl(isCopyConstructor())
.bind("ctor"))))) .bind("ctor")))))
.bind("move-init")))), .bind("move-init")))),
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

Show All 38 Linesvoid NoAutomaticMoveCheck::registerMatchers(MatchFinder *Finder) {
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, traverse(TK_AsIs,
returnStmt(hasReturnValue( returnStmt(hasReturnValue(
ignoringElidableConstructorCall(ignoringParenImpCasts( ignoringElidableConstructorCall(ignoringParenImpCasts(
cxxConstructExpr( cxxConstructExpr(
hasDeclaration(LValueRefCtor), hasDeclaration(LValueRefCtor),
hasArgument(0, ignoringParenImpCasts(declRefExpr( hasArgument(0, ignoringParenImpCasts(declRefExpr(
to(ConstLocalVariable))))) to(ConstLocalVariable)))))
.bind("ctor_call")))))), .bind("ctor_call")))))),
this); this);
Show All 17 Lines

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

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines return compoundStmt(
matchers::isExpensiveToCopy(), matchers::isExpensiveToCopy(),
unless(hasDeclaration(namedDecl( unless(hasDeclaration(namedDecl(
hasName("::std::function")))))), hasName("::std::function")))))),
unless(hasDeclaration(namedDecl( unless(hasDeclaration(namedDecl(
matchers::matchesAnyListedName( matchers::matchesAnyListedName(
AllowedTypes)))))), AllowedTypes)))))),
unless(isImplicit()), unless(isImplicit()),
hasInitializer(traverse( hasInitializer(traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxConstructExpr( cxxConstructExpr(
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
isCopyConstructor())), isCopyConstructor())),
hasArgument(0, CopyCtorArg)) hasArgument(0, CopyCtorArg))
.bind("ctorCall")))) .bind("ctorCall"))))
.bind("newVarDecl"))) .bind("newVarDecl")))
.bind("declStmt"))) .bind("declStmt")))
.bind("blockStmt"); .bind("blockStmt");
Show All 13 Linesvoid UnnecessaryCopyInitialization::check(
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");
const auto *InitFunctionCall = const auto *InitFunctionCall =
Result.Nodes.getNodeAs<CallExpr>("initFunctionCall"); Result.Nodes.getNodeAs<CallExpr>("initFunctionCall");
TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs); TraversalKindScope RAII(*Result.Context, 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
▲ Show 20 Lines • Show All 67 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 = match( auto Matches = match(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
decl(forEachDescendant(declRefExpr( 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();
} }
Show All 24 Lines 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( traverse(
ast_type_traits::TK_AsIs, 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); TraversalKindScope RAII(*Result.Context, 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 =
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

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

Show All 34 Lines const auto ValidContainer = qualType(hasUnqualifiedDesugaredType(
returns(qualType(isInteger(), unless(booleanType())))) returns(qualType(isInteger(), unless(booleanType()))))
.bind("size")), .bind("size")),
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(), has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("empty"), returns(booleanType())) hasName("empty"), returns(booleanType()))
.bind("empty"))) .bind("empty")))
.bind("container"))))))); .bind("container")))))));
const auto WrongUse = traverse( const auto WrongUse = traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
anyOf( anyOf(
hasParent(binaryOperator(isComparisonOperator(), hasParent(binaryOperator(isComparisonOperator(),
hasEitherOperand(ignoringImpCasts( hasEitherOperand(ignoringImpCasts(
anyOf(integerLiteral(equals(1)), anyOf(integerLiteral(equals(1)),
integerLiteral(equals(0)))))) integerLiteral(equals(0))))))
.bind("SizeBinaryOp")), .bind("SizeBinaryOp")),
hasParent(implicitCastExpr( hasParent(implicitCastExpr(
hasImplicitDestinationType(booleanType()), hasImplicitDestinationType(booleanType()),
▲ Show 20 Lines • Show All 177 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 = binaryOperator( const auto BinaryPointerCheckCondition = binaryOperator(
hasOperands(castExpr(hasCastKind(CK_NullToPointer)), PointerExpr)); hasOperands(castExpr(hasCastKind(CK_NullToPointer)), PointerExpr));
Finder->addMatcher( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
ifStmt(hasCondition( ifStmt(hasCondition(
anyOf(PointerCondition, BinaryPointerCheckCondition)), anyOf(PointerCondition, BinaryPointerCheckCondition)),
hasThen(anyOf(DeleteExpr, DeleteMemberExpr, hasThen(anyOf(DeleteExpr, DeleteMemberExpr,
compoundStmt(anyOf(has(DeleteExpr), compoundStmt(anyOf(has(DeleteExpr),
has(DeleteMemberExpr)), has(DeleteMemberExpr)),
statementCountIs(1)) statementCountIs(1))
.bind("compound")))) .bind("compound"))))
.bind("ifWithDelete")), .bind("ifWithDelete")),
Show All 32 Lines

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

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 LinesStringRef getEquivalentForBoolLiteral(const CXXBoolLiteralExpr *BoolLiteral,
return BoolLiteral->getValue() ? "1" : "0"; return BoolLiteral->getValue() ? "1" : "0";
} }
bool isCastAllowedInCondition(const ImplicitCastExpr *Cast, bool isCastAllowedInCondition(const ImplicitCastExpr *Cast,
ASTContext &Context) { ASTContext &Context) {
std::queue<const Stmt *> Q; std::queue<const Stmt *> Q;
Q.push(Cast); Q.push(Cast);
TraversalKindScope RAII(Context, ast_type_traits::TK_AsIs); TraversalKindScope RAII(Context, TK_AsIs);
while (!Q.empty()) { while (!Q.empty()) {
for (const auto &N : Context.getParents(*Q.front())) { for (const auto &N : Context.getParents(*Q.front())) {
const Stmt *S = N.get<Stmt>(); const Stmt *S = N.get<Stmt>();
if (!S) if (!S)
return false; return false;
if (isa<IfStmt>(S) || isa<ConditionalOperator>(S) || isa<ForStmt>(S) || if (isa<IfStmt>(S) || isa<ConditionalOperator>(S) || isa<ForStmt>(S) ||
isa<WhileStmt>(S) || isa<BinaryConditionalOperator>(S)) isa<WhileStmt>(S) || isa<BinaryConditionalOperator>(S))
Show All 37 Lines auto implicitCastFromBool = implicitCastExpr(
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, traverse(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()) {}
Show All 16 Lines auto boolOpAssignment = binaryOperator(hasAnyOperatorName("|=", "&="),
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( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
implicitCastExpr( implicitCastExpr(
implicitCastFromBool, implicitCastFromBool,
// Exclude comparisons of bools, as they are always cast to // Exclude comparisons of bools, as they are always cast to
// integers in such context: // integers 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( unless(hasParent(
binaryOperator(anyOf(boolComparison, boolXor, binaryOperator(anyOf(boolComparison, boolXor,
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 121 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); TraversalKindScope RAII(*Result.Context, 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(
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 LinesAST_MATCHER(CXXMethodDecl, usesThisAsConst) {
UsageOfThis.TraverseStmt(const_cast<Stmt *>(Node.getBody())); UsageOfThis.TraverseStmt(const_cast<Stmt *>(Node.getBody()));
return UsageOfThis.Usage == Const; return UsageOfThis.Usage == Const;
} }
void MakeMemberFunctionConstCheck::registerMatchers(MatchFinder *Finder) { void MakeMemberFunctionConstCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxMethodDecl( cxxMethodDecl(
isDefinition(), isUserProvided(), isDefinition(), isUserProvided(),
unless(anyOf( unless(anyOf(
isExpansionInSystemHeader(), isVirtual(), isConst(), isExpansionInSystemHeader(), isVirtual(), isConst(),
isStatic(), hasTrivialBody(), cxxConstructorDecl(), isStatic(), hasTrivialBody(), cxxConstructorDecl(),
cxxDestructorDecl(), isTemplate(), isDependentContext(), cxxDestructorDecl(), isTemplate(), isDependentContext(),
ofClass(anyOf(isLambda(), ofClass(anyOf(isLambda(),
hasAnyDependentBases()) // Method might become hasAnyDependentBases()) // Method might become
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 14 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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, arraySubscriptExpr(hasLHS(hasType(isInteger())),
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 23 Linesvoid NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")), stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
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);
} }
▲ Show 20 Lines • Show All 183 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(traverse(ast_type_traits::TK_AsIs, Finder->addMatcher(
unaryOperator(hasOperatorName("*"), traverse(TK_AsIs, unaryOperator(hasOperatorName("*"),
has(implicitCastExpr(hasCastKind( has(implicitCastExpr(hasCastKind(
CK_FunctionToPointerDecay)))) 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 28 Linesvoid RedundantMemberInitCheck::registerMatchers(MatchFinder *Finder) {
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( traverse(
ast_type_traits::TK_AsIs, 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()))),
Show All 34 Lines

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

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines const auto StringCStrCallExpr =
.bind("call"); .bind("call");
const auto HasRValueTempParent = const auto HasRValueTempParent =
hasParent(materializeTemporaryExpr(unless(isBoundToLValue()))); hasParent(materializeTemporaryExpr(unless(isBoundToLValue())));
// Detect redundant 'c_str()' calls through a string constructor. // Detect redundant 'c_str()' calls through a string constructor.
// If CxxConstructExpr is the part of some CallExpr we need to // If CxxConstructExpr is the part of some CallExpr we need to
// check that matched ParamDecl of the ancestor CallExpr is not rvalue. // check that matched ParamDecl of the ancestor CallExpr is not rvalue.
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxConstructExpr( cxxConstructExpr(
StringConstructorExpr, hasArgument(0, StringCStrCallExpr), StringConstructorExpr, hasArgument(0, StringCStrCallExpr),
unless(anyOf(HasRValueTempParent, hasParent(cxxBindTemporaryExpr( unless(anyOf(HasRValueTempParent, hasParent(cxxBindTemporaryExpr(
HasRValueTempParent)))))), HasRValueTempParent)))))),
this); this);
// Detect: 's == str.c_str()' -> 's == str' // Detect: 's == str.c_str()' -> 's == str'
Finder->addMatcher( Finder->addMatcher(
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines 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( traverse(
ast_type_traits::TK_AsIs, 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),
Show All 30 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines const auto EmptyStringCtorExpr = cxxConstructExpr(
hasArgument(0, ignoringParenImpCasts(stringLiteral(hasSize(0))))); hasArgument(0, ignoringParenImpCasts(stringLiteral(hasSize(0)))));
const auto EmptyStringCtorExprWithTemporaries = const auto EmptyStringCtorExprWithTemporaries =
cxxConstructExpr(StringConstructorExpr, cxxConstructExpr(StringConstructorExpr,
hasArgument(0, ignoringImplicit(EmptyStringCtorExpr))); hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)));
const auto StringType = hasType(hasUnqualifiedDesugaredType( const auto StringType = hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(hasStringTypeName))))); recordType(hasDeclaration(cxxRecordDecl(hasStringTypeName)))));
const auto EmptyStringInit = const auto EmptyStringInit = traverse(
traverse(ast_type_traits::TK_AsIs, expr(ignoringImplicit( TK_AsIs, expr(ignoringImplicit(anyOf(
anyOf(EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries)))); EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries))));
// 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, traverse(TK_AsIs,
namedDecl(varDecl(StringType, hasInitializer(EmptyStringInit)) namedDecl(varDecl(StringType, hasInitializer(EmptyStringInit))
.bind("vardecl"), .bind("vardecl"),
unless(parmVarDecl()))), unless(parmVarDecl()))),
this); this);
// Match a field declaration with an empty string literal as initializer. // Match a field declaration with an empty string literal as initializer.
Finder->addMatcher( Finder->addMatcher(
namedDecl(fieldDecl(StringType, hasInClassInitializer(EmptyStringInit)) namedDecl(fieldDecl(StringType, hasInClassInitializer(EmptyStringInit))
.bind("fieldDecl")), .bind("fieldDecl")),
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

Show All 26 Lines 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( Finder->addMatcher(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(booleanType()), 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(
binaryOperator(hasAnyOperatorName("==", "!="), binaryOperator(hasAnyOperatorName("==", "!="),
Show All 37 Lines

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

Show All 23 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); TraversalKindScope RAII(*Context, TK_AsIs);
DynTypedNodeList Parents = Context->getParents(*S); DynTypedNodeList Parents = Context->getParents(*S);
SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(), SmallVector<DynTypedNode, 1> NodesToProcess(Parents.begin(), Parents.end());
Parents.end());
while (!NodesToProcess.empty()) { while (!NodesToProcess.empty()) {
ast_type_traits::DynTypedNode Node = NodesToProcess.back(); DynTypedNode Node = NodesToProcess.back();
NodesToProcess.pop_back(); NodesToProcess.pop_back();
if (const auto *S = Node.get<Stmt>()) { if (const auto *S = Node.get<Stmt>()) {
Result.push_back(S); Result.push_back(S);
} else { } else {
Parents = Context->getParents(Node); Parents = Context->getParents(Node);
NodesToProcess.append(Parents.begin(), Parents.end()); NodesToProcess.append(Parents.begin(), Parents.end());
} }
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

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

Show All 30 Linesvoid TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
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, traverse(TK_AsIs,
cxxConstructExpr(hasParent(cxxFunctionalCastExpr()), cxxConstructExpr(hasParent(cxxFunctionalCastExpr()),
hasDeclaration(cxxConstructorDecl(hasParent( hasDeclaration(cxxConstructorDecl(hasParent(
cxxRecordDecl(matchesAnyName(Names)))))) cxxRecordDecl(matchesAnyName(Names))))))
.bind("temps")), .bind("temps")),
this); this);
} }
void TemporaryObjectsCheck::check(const MatchFinder::MatchResult &Result) { void TemporaryObjectsCheck::check(const MatchFinder::MatchResult &Result) {
Show All 13 Lines

clang-tools-extra/clangd/AST.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines if (index::generateUSRForMacro(MacroName, MI->getDefinitionLoc(), SM, USR))
return {}; return {};
return SymbolID(USR); return SymbolID(USR);
} }
// FIXME: This should be handled while printing underlying decls instead. // FIXME: This should be handled while printing underlying decls instead.
std::string printType(const QualType QT, const DeclContext &CurContext) { std::string printType(const QualType QT, const DeclContext &CurContext) {
std::string Result; std::string Result;
llvm::raw_string_ostream OS(Result); llvm::raw_string_ostream OS(Result);
auto Decls = explicitReferenceTargets( auto Decls =
ast_type_traits::DynTypedNode::create(QT), DeclRelation::Alias); explicitReferenceTargets(DynTypedNode::create(QT), DeclRelation::Alias);
if (!Decls.empty()) if (!Decls.empty())
OS << getQualification(CurContext.getParentASTContext(), &CurContext, OS << getQualification(CurContext.getParentASTContext(), &CurContext,
Decls.front(), Decls.front(),
/*VisibleNamespaces=*/llvm::ArrayRef<std::string>{}); /*VisibleNamespaces=*/llvm::ArrayRef<std::string>{});
PrintingPolicy PP(CurContext.getParentASTContext().getPrintingPolicy()); PrintingPolicy PP(CurContext.getParentASTContext().getPrintingPolicy());
PP.SuppressScope = true; PP.SuppressScope = true;
PP.SuppressTagKeyword = true; PP.SuppressTagKeyword = true;
QT.print(OS, PP); QT.print(OS, PP);
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

clang-tools-extra/clangd/FindTarget.h

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
/// / \ /// / \
/// RecordDecl S TypeAliasDecl T /// RecordDecl S TypeAliasDecl T
/// ///
/// Note that this function only returns NamedDecls. Generally other decls /// Note that this function only returns NamedDecls. Generally other decls
/// don't have references in this sense, just the node itself. /// don't have references in this sense, just the node itself.
/// If callers want to support such decls, they should cast the node directly. /// If callers want to support such decls, they should cast the node directly.
/// ///
/// FIXME: some AST nodes cannot be DynTypedNodes, these cannot be specified. /// FIXME: some AST nodes cannot be DynTypedNodes, these cannot be specified.
llvm::SmallVector<const NamedDecl *, 1> llvm::SmallVector<const NamedDecl *, 1> targetDecl(const DynTypedNode &,
targetDecl(const ast_type_traits::DynTypedNode &, DeclRelationSet Mask); DeclRelationSet Mask);
/// Similar to targetDecl(), however instead of applying a filter, all possible /// Similar to targetDecl(), however instead of applying a filter, all possible
/// decls are returned along with their DeclRelationSets. /// decls are returned along with their DeclRelationSets.
/// This is suitable for indexing, where everything is recorded and filtering /// This is suitable for indexing, where everything is recorded and filtering
/// is applied later. /// is applied later.
llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1> llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
allTargetDecls(const ast_type_traits::DynTypedNode &); allTargetDecls(const DynTypedNode &);
enum class DeclRelation : unsigned { enum class DeclRelation : unsigned {
// Template options apply when the declaration is an instantiated template. // Template options apply when the declaration is an instantiated template.
// e.g. [[vector<int>]] vec; // e.g. [[vector<int>]] vec;
/// This is the template instantiation that was referred to. /// This is the template instantiation that was referred to.
/// e.g. template<> class vector<int> (the implicit specialization) /// e.g. template<> class vector<int> (the implicit specialization)
TemplateInstantiation, TemplateInstantiation,
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
/// possible. However, can also return a template pattern if the specialization /// possible. However, can also return a template pattern if the specialization
/// cannot be picked, e.g. in dependent code or when there is no corresponding /// cannot be picked, e.g. in dependent code or when there is no corresponding
/// Decl for a template instantiation, e.g. for templated using decls: /// Decl for a template instantiation, e.g. for templated using decls:
/// template <class T> using Ptr = T*; /// template <class T> using Ptr = T*;
/// Ptr<int> x; /// Ptr<int> x;
/// ^~~ there is no Decl for 'Ptr<int>', so we return the template pattern. /// ^~~ there is no Decl for 'Ptr<int>', so we return the template pattern.
/// \p Mask should not contain TemplatePattern or TemplateInstantiation. /// \p Mask should not contain TemplatePattern or TemplateInstantiation.
llvm::SmallVector<const NamedDecl *, 1> llvm::SmallVector<const NamedDecl *, 1>
explicitReferenceTargets(ast_type_traits::DynTypedNode N, explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask);
DeclRelationSet Mask);
// Boring implementation details of bitfield. // Boring implementation details of bitfield.
class DeclRelationSet { class DeclRelationSet {
using Set = std::bitset<static_cast<unsigned>(DeclRelation::Underlying) + 1>; using Set = std::bitset<static_cast<unsigned>(DeclRelation::Underlying) + 1>;
Set S; Set S;
DeclRelationSet(Set S) : S(S) {} DeclRelationSet(Set S) : S(S) {}
Show All 40 Lines

clang-tools-extra/clangd/FindTarget.cpp

Show All 38 Lines
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <iterator> #include <iterator>
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace clang { namespace clang {
namespace clangd { namespace clangd {
namespace { namespace {
using ast_type_traits::DynTypedNode;
LLVM_ATTRIBUTE_UNUSED std::string LLVM_ATTRIBUTE_UNUSED std::string nodeToString(const DynTypedNode &N) {
nodeToString(const ast_type_traits::DynTypedNode &N) {
std::string S = std::string(N.getNodeKind().asStringRef()); std::string S = std::string(N.getNodeKind().asStringRef());
{ {
llvm::raw_string_ostream OS(S); llvm::raw_string_ostream OS(S);
OS << ": "; OS << ": ";
N.print(OS, PrintingPolicy(LangOptions())); N.print(OS, PrintingPolicy(LangOptions()));
} }
std::replace(S.begin(), S.end(), '\n', ' '); std::replace(S.begin(), S.end(), '\n', ' ');
return S; return S;
▲ Show 20 Lines • Show All 271 Lines • ▼ Show 20 Lines
private: private:
llvm::SmallDenseMap<const NamedDecl *, llvm::SmallDenseMap<const NamedDecl *,
std::pair<RelSet, /*InsertionOrder*/ size_t>> std::pair<RelSet, /*InsertionOrder*/ size_t>>
Decls; Decls;
RelSet Flags; RelSet Flags;
template <typename T> void debug(T &Node, RelSet Flags) { template <typename T> void debug(T &Node, RelSet Flags) {
dlog("visit [{0}] {1}", Flags, dlog("visit [{0}] {1}", Flags, nodeToString(DynTypedNode::create(Node)));
nodeToString(ast_type_traits::DynTypedNode::create(Node)));
} }
void report(const NamedDecl *D, RelSet Flags) { void report(const NamedDecl *D, RelSet Flags) {
dlog("--> [{0}] {1}", Flags, dlog("--> [{0}] {1}", Flags, nodeToString(DynTypedNode::create(*D)));
nodeToString(ast_type_traits::DynTypedNode::create(*D)));
auto It = Decls.try_emplace(D, std::make_pair(Flags, Decls.size())); auto It = Decls.try_emplace(D, std::make_pair(Flags, Decls.size()));
// If already exists, update the flags. // If already exists, update the flags.
if (!It.second) if (!It.second)
It.first->second.first |= Flags; It.first->second.first |= Flags;
} }
public: public:
llvm::SmallVector<std::pair<const NamedDecl *, RelSet>, 1> takeDecls() const { llvm::SmallVector<std::pair<const NamedDecl *, RelSet>, 1> takeDecls() const {
▲ Show 20 Lines • Show All 326 Lines • ▼ Show 20 Lines if (Arg.getKind() == TemplateArgument::Template ||
} }
} }
} }
}; };
} // namespace } // namespace
llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1> llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
allTargetDecls(const ast_type_traits::DynTypedNode &N) { allTargetDecls(const DynTypedNode &N) {
dlog("allTargetDecls({0})", nodeToString(N)); dlog("allTargetDecls({0})", nodeToString(N));
TargetFinder Finder; TargetFinder Finder;
DeclRelationSet Flags; DeclRelationSet Flags;
if (const Decl *D = N.get<Decl>()) if (const Decl *D = N.get<Decl>())
Finder.add(D, Flags); Finder.add(D, Flags);
else if (const Stmt *S = N.get<Stmt>()) else if (const Stmt *S = N.get<Stmt>())
Finder.add(S, Flags); Finder.add(S, Flags);
else if (const NestedNameSpecifierLoc *NNSL = N.get<NestedNameSpecifierLoc>()) else if (const NestedNameSpecifierLoc *NNSL = N.get<NestedNameSpecifierLoc>())
Finder.add(NNSL->getNestedNameSpecifier(), Flags); Finder.add(NNSL->getNestedNameSpecifier(), Flags);
else if (const NestedNameSpecifier *NNS = N.get<NestedNameSpecifier>()) else if (const NestedNameSpecifier *NNS = N.get<NestedNameSpecifier>())
Finder.add(NNS, Flags); Finder.add(NNS, Flags);
else if (const TypeLoc *TL = N.get<TypeLoc>()) else if (const TypeLoc *TL = N.get<TypeLoc>())
Finder.add(TL->getType(), Flags); Finder.add(TL->getType(), Flags);
else if (const QualType *QT = N.get<QualType>()) else if (const QualType *QT = N.get<QualType>())
Finder.add(*QT, Flags); Finder.add(*QT, Flags);
else if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>()) else if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>())
Finder.add(CCI, Flags); Finder.add(CCI, Flags);
else if (const TemplateArgumentLoc *TAL = N.get<TemplateArgumentLoc>()) else if (const TemplateArgumentLoc *TAL = N.get<TemplateArgumentLoc>())
Finder.add(TAL->getArgument(), Flags); Finder.add(TAL->getArgument(), Flags);
return Finder.takeDecls(); return Finder.takeDecls();
} }
llvm::SmallVector<const NamedDecl *, 1> llvm::SmallVector<const NamedDecl *, 1> targetDecl(const DynTypedNode &N,
targetDecl(const ast_type_traits::DynTypedNode &N, DeclRelationSet Mask) { DeclRelationSet Mask) {
llvm::SmallVector<const NamedDecl *, 1> Result; llvm::SmallVector<const NamedDecl *, 1> Result;
for (const auto &Entry : allTargetDecls(N)) { for (const auto &Entry : allTargetDecls(N)) {
if (!(Entry.second & ~Mask)) if (!(Entry.second & ~Mask))
Result.push_back(Entry.first); Result.push_back(Entry.first);
} }
return Result; return Result;
} }
▲ Show 20 Lines • Show All 513 Lines • Show Last 20 Lines

clang-tools-extra/clangd/Selection.h

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Linespublic:
// An AST node that is implicated in the selection. // An AST node that is implicated in the selection.
// (Either selected directly, or some descendant is selected). // (Either selected directly, or some descendant is selected).
struct Node { struct Node {
// The parent within the selection tree. nullptr for TranslationUnitDecl. // The parent within the selection tree. nullptr for TranslationUnitDecl.
Node *Parent; Node *Parent;
// Direct children within the selection tree. // Direct children within the selection tree.
llvm::SmallVector<const Node *, 8> Children; llvm::SmallVector<const Node *, 8> Children;
// The corresponding node from the full AST. // The corresponding node from the full AST.
ast_type_traits::DynTypedNode ASTNode; DynTypedNode ASTNode;
// The extent to which this node is covered by the selection. // The extent to which this node is covered by the selection.
Selection Selected; Selection Selected;
// Walk up the AST to get the DeclContext of this Node, // Walk up the AST to get the DeclContext of this Node,
// which is not the node itself. // which is not the node itself.
const DeclContext &getDeclContext() const; const DeclContext &getDeclContext() const;
// Printable node kind, like "CXXRecordDecl" or "AutoTypeLoc". // Printable node kind, like "CXXRecordDecl" or "AutoTypeLoc".
std::string kind() const; std::string kind() const;
// If this node is a wrapper with no syntax (e.g. implicit cast), return // If this node is a wrapper with no syntax (e.g. implicit cast), return
Show All 34 Lines

clang-tools-extra/clangd/Selection.cpp

Show All 29 Lines
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <algorithm> #include <algorithm>
#include <string> #include <string>
namespace clang { namespace clang {
namespace clangd { namespace clangd {
namespace { namespace {
using Node = SelectionTree::Node; using Node = SelectionTree::Node;
using ast_type_traits::DynTypedNode;
// Measure the fraction of selections that were enabled by recovery AST. // Measure the fraction of selections that were enabled by recovery AST.
void recordMetrics(const SelectionTree &S, const LangOptions &Lang) { void recordMetrics(const SelectionTree &S, const LangOptions &Lang) {
if (!trace::enabled()) if (!trace::enabled())
return; return;
const char *LanguageLabel = Lang.CPlusPlus ? "C++" : Lang.ObjC ? "ObjC" : "C"; const char *LanguageLabel = Lang.CPlusPlus ? "C++" : Lang.ObjC ? "ObjC" : "C";
static constexpr trace::Metric SelectionUsedRecovery( static constexpr trace::Metric SelectionUsedRecovery(
"selection_recovery", trace::Metric::Distribution, "language"); "selection_recovery", trace::Metric::Distribution, "language");
▲ Show 20 Lines • Show All 835 Lines • Show Last 20 Lines

clang-tools-extra/clangd/refactor/tweaks/DefineInline.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines if (!NextTok || !NextTok->is(tok::semi))
return llvm::None; return llvm::None;
return NextTok->getLocation(); return NextTok->getLocation();
} }
// Deduces the FunctionDecl from a selection. Requires either the function body // Deduces the FunctionDecl from a selection. Requires either the function body
// or the function decl to be selected. Returns null if none of the above // or the function decl to be selected. Returns null if none of the above
// criteria is met. // criteria is met.
const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) { const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode; const DynTypedNode &AstNode = SelNode->ASTNode;
if (const FunctionDecl *FD = AstNode.get<FunctionDecl>()) if (const FunctionDecl *FD = AstNode.get<FunctionDecl>())
return FD; return FD;
if (AstNode.get<CompoundStmt>() && if (AstNode.get<CompoundStmt>() &&
SelNode->Selected == SelectionTree::Complete) { SelNode->Selected == SelectionTree::Complete) {
if (const SelectionTree::Node *P = SelNode->Parent) if (const SelectionTree::Node *P = SelNode->Parent)
return P->ASTNode.get<FunctionDecl>(); return P->ASTNode.get<FunctionDecl>();
} }
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 426 Lines • Show Last 20 Lines

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// Deduces the FunctionDecl from a selection. Requires either the function body // Deduces the FunctionDecl from a selection. Requires either the function body
// or the function decl to be selected. Returns null if none of the above // or the function decl to be selected. Returns null if none of the above
// criteria is met. // criteria is met.
// FIXME: This is shared with define inline, move them to a common header once // FIXME: This is shared with define inline, move them to a common header once
// we have a place for such. // we have a place for such.
const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) { const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
if (!SelNode) if (!SelNode)
return nullptr; return nullptr;
const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode; const DynTypedNode &AstNode = SelNode->ASTNode;
if (const FunctionDecl *FD = AstNode.get<FunctionDecl>()) if (const FunctionDecl *FD = AstNode.get<FunctionDecl>())
return FD; return FD;
if (AstNode.get<CompoundStmt>() && if (AstNode.get<CompoundStmt>() &&
SelNode->Selected == SelectionTree::Complete) { SelNode->Selected == SelectionTree::Complete) {
if (const SelectionTree::Node *P = SelNode->Parent) if (const SelectionTree::Node *P = SelNode->Parent)
return P->ASTNode.get<FunctionDecl>(); return P->ASTNode.get<FunctionDecl>();
} }
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 400 Lines • Show Last 20 Lines

clang-tools-extra/unittests/clang-query/QueryParserTest.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines EXPECT_EQ("expected 'true' or 'false', got 'foo'",
cast<InvalidQuery>(Q)->ErrStr); cast<InvalidQuery>(Q)->ErrStr);
Q = parse("set bind-root true"); Q = parse("set bind-root true");
ASSERT_TRUE(isa<SetQuery<bool> >(Q)); ASSERT_TRUE(isa<SetQuery<bool> >(Q));
EXPECT_EQ(&QuerySession::BindRoot, cast<SetQuery<bool> >(Q)->Var); EXPECT_EQ(&QuerySession::BindRoot, cast<SetQuery<bool> >(Q)->Var);
EXPECT_EQ(true, cast<SetQuery<bool> >(Q)->Value); EXPECT_EQ(true, cast<SetQuery<bool> >(Q)->Value);
Q = parse("set traversal AsIs"); Q = parse("set traversal AsIs");
ASSERT_TRUE(isa<SetQuery<ast_type_traits::TraversalKind>>(Q)); ASSERT_TRUE(isa<SetQuery<TraversalKind>>(Q));
EXPECT_EQ(&QuerySession::TK, EXPECT_EQ(&QuerySession::TK, cast<SetQuery<TraversalKind>>(Q)->Var);
cast<SetQuery<ast_type_traits::TraversalKind>>(Q)->Var); EXPECT_EQ(TK_AsIs, cast<SetQuery<TraversalKind>>(Q)->Value);
EXPECT_EQ(ast_type_traits::TK_AsIs,
cast<SetQuery<ast_type_traits::TraversalKind>>(Q)->Value);
Q = parse("set traversal NotATraversal"); Q = parse("set traversal NotATraversal");
ASSERT_TRUE(isa<InvalidQuery>(Q)); ASSERT_TRUE(isa<InvalidQuery>(Q));
EXPECT_EQ("expected traversal kind, got 'NotATraversal'", EXPECT_EQ("expected traversal kind, got 'NotATraversal'",
cast<InvalidQuery>(Q)->ErrStr); cast<InvalidQuery>(Q)->ErrStr);
} }
TEST_F(QueryParserTest, Match) { TEST_F(QueryParserTest, Match) {
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

Show First 20 Lines • Show All 250 Lines • ▼ Show 20 Lines
DynTypedMatcher DynTypedMatcher
DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher, DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
ASTNodeKind RestrictKind) { ASTNodeKind RestrictKind) {
DynTypedMatcher Copy = InnerMatcher; DynTypedMatcher Copy = InnerMatcher;
Copy.RestrictKind = RestrictKind; Copy.RestrictKind = RestrictKind;
return Copy; return Copy;
} }
DynTypedMatcher DynTypedMatcher DynTypedMatcher::withTraversalKind(TraversalKind TK) {
DynTypedMatcher::withTraversalKind(ast_type_traits::TraversalKind TK) {
auto Copy = *this; auto Copy = *this;
Copy.Implementation = Copy.Implementation =
new DynTraversalMatcherImpl(TK, std::move(Copy.Implementation)); new DynTraversalMatcherImpl(TK, std::move(Copy.Implementation));
return Copy; return Copy;
} }
DynTypedMatcher DynTypedMatcher::trueMatcher(ASTNodeKind NodeKind) { DynTypedMatcher DynTypedMatcher::trueMatcher(ASTNodeKind NodeKind) {
// We only ever need one instance of TrueMatcherImpl, so we create a static // We only ever need one instance of TrueMatcherImpl, so we create a static
▲ Show 20 Lines • Show All 776 Lines • Show Last 20 Lines

clang/lib/ASTMatchers/Dynamic/Registry.cpp

Show All 25 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <set> #include <set>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
using namespace clang::ast_type_traits;
namespace clang { namespace clang {
namespace ast_matchers { namespace ast_matchers {
namespace dynamic { namespace dynamic {
namespace { namespace {
using internal::MatcherDescriptor; using internal::MatcherDescriptor;
▲ Show 20 Lines • Show All 677 Lines • Show Last 20 Lines

clang/lib/Analysis/ExprMutationAnalyzer.cpp

Show First 20 Lines • Show All 360 Lines • ▼ Show 20 Lines const auto AsNonConstRefReturn =
returnStmt(hasReturnValue(canResolveToExpr(equalsNode(Exp)))); returnStmt(hasReturnValue(canResolveToExpr(equalsNode(Exp))));
// It is used as a non-const-reference for initalizing a range-for loop. // It is used as a non-const-reference for initalizing a range-for loop.
const auto AsNonConstRefRangeInit = cxxForRangeStmt( const auto AsNonConstRefRangeInit = cxxForRangeStmt(
hasRangeInit(declRefExpr(allOf(canResolveToExpr(equalsNode(Exp)), hasRangeInit(declRefExpr(allOf(canResolveToExpr(equalsNode(Exp)),
hasType(nonConstReferenceType()))))); hasType(nonConstReferenceType())))));
const auto Matches = match( const auto Matches = match(
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand, findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand,
AsNonConstThis, AsAmpersandOperand, AsNonConstThis, AsAmpersandOperand,
AsPointerFromArrayDecay, AsOperatorArrowThis, AsPointerFromArrayDecay, AsOperatorArrowThis,
AsNonConstRefArg, AsLambdaRefCaptureInit, AsNonConstRefArg, AsLambdaRefCaptureInit,
AsNonConstRefReturn, AsNonConstRefRangeInit)) AsNonConstRefReturn, AsNonConstRefRangeInit))
.bind("stmt"))), .bind("stmt"))),
Stm, Context); Stm, Context);
return selectFirst<Stmt>("stmt", Matches); return selectFirst<Stmt>("stmt", Matches);
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) { const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
const auto NonConstRefParam = forEachArgumentWithParam( const auto NonConstRefParam = forEachArgumentWithParam(
canResolveToExpr(equalsNode(Exp)), canResolveToExpr(equalsNode(Exp)),
parmVarDecl(hasType(nonConstReferenceType())).bind("parm")); parmVarDecl(hasType(nonConstReferenceType())).bind("parm"));
const auto IsInstantiated = hasDeclaration(isInstantiated()); const auto IsInstantiated = hasDeclaration(isInstantiated());
const auto FuncDecl = hasDeclaration(functionDecl().bind("func")); const auto FuncDecl = hasDeclaration(functionDecl().bind("func"));
const auto Matches = match( const auto Matches = match(
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
findAll( findAll(
expr(anyOf(callExpr(NonConstRefParam, IsInstantiated, FuncDecl, expr(anyOf(callExpr(NonConstRefParam, IsInstantiated, FuncDecl,
unless(callee(namedDecl(hasAnyName( unless(callee(namedDecl(hasAnyName(
"::std::move", "::std::forward"))))), "::std::move", "::std::forward"))))),
cxxConstructExpr(NonConstRefParam, IsInstantiated, cxxConstructExpr(NonConstRefParam, IsInstantiated,
FuncDecl))) FuncDecl)))
.bind(NodeID<Expr>::value))), .bind(NodeID<Expr>::value))),
Stm, Context); Stm, Context);
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang/lib/Tooling/Transformer/RewriteRule.cpp

Show First 20 Lines • Show All 336 Lines • ▼ Show 20 Lines
// Binds each rule's matcher to a unique (and deterministic) tag based on // Binds each rule's matcher to a unique (and deterministic) tag based on
// `TagBase` and the id paired with the case. All of the returned matchers have // `TagBase` and the id paired with the case. All of the returned matchers have
// their traversal kind explicitly set, either based on a pre-set kind or to the // their traversal kind explicitly set, either based on a pre-set kind or to the
// provided `DefaultTraversalKind`. // provided `DefaultTraversalKind`.
static std::vector<DynTypedMatcher> taggedMatchers( static std::vector<DynTypedMatcher> taggedMatchers(
StringRef TagBase, StringRef TagBase,
const SmallVectorImpl<std::pair<size_t, RewriteRule::Case>> &Cases, const SmallVectorImpl<std::pair<size_t, RewriteRule::Case>> &Cases,
ast_type_traits::TraversalKind DefaultTraversalKind) { TraversalKind DefaultTraversalKind) {
std::vector<DynTypedMatcher> Matchers; std::vector<DynTypedMatcher> Matchers;
Matchers.reserve(Cases.size()); Matchers.reserve(Cases.size());
for (const auto &Case : Cases) { for (const auto &Case : Cases) {
std::string Tag = (TagBase + Twine(Case.first)).str(); std::string Tag = (TagBase + Twine(Case.first)).str();
// HACK: Many matchers are not bindable, so ensure that tryBind will work. // HACK: Many matchers are not bindable, so ensure that tryBind will work.
DynTypedMatcher BoundMatcher(Case.second.Matcher); DynTypedMatcher BoundMatcher(Case.second.Matcher);
BoundMatcher.setAllowBind(true); BoundMatcher.setAllowBind(true);
auto M = *BoundMatcher.tryBind(Tag); auto M = *BoundMatcher.tryBind(Tag);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

clang/unittests/AST/ASTImporterTest.cpp

Show First 20 Lines • Show All 391 Lines • ▼ Show 20 Lines testImport("void declToImport() { int b; switch (b) { case 1: break; } }",
switchStmt(has(compoundStmt(has(caseStmt()))))))); switchStmt(has(compoundStmt(has(caseStmt())))))));
} }
TEST_P(ImportExpr, ImportStmtExpr) { TEST_P(ImportExpr, ImportStmtExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }", "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
Lang_C99, "", Lang_C99, Verifier, Lang_C99, "", Lang_C99, Verifier,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
functionDecl(hasDescendant(varDecl( functionDecl(hasDescendant(varDecl(
hasName("C"), hasType(asString("int")), hasName("C"), hasType(asString("int")),
hasInitializer(stmtExpr( hasInitializer(stmtExpr(
hasAnySubstatement(declStmt(hasSingleDecl(varDecl( hasAnySubstatement(declStmt(hasSingleDecl(varDecl(
hasName("X"), hasType(asString("int")), hasName("X"), hasType(asString("int")),
hasInitializer(integerLiteral(equals(4))))))), hasInitializer(integerLiteral(equals(4))))))),
hasDescendant(implicitCastExpr())))))))); hasDescendant(implicitCastExpr()))))))));
} }
Show All 9 Lines testImport("void declToImport() { (void)(true ? 1 : -5); }", Lang_CXX03, "",
hasUnaryOperand(integerLiteral(equals(5))))))))); hasUnaryOperand(integerLiteral(equals(5)))))))));
} }
TEST_P(ImportExpr, ImportBinaryConditionalOperator) { TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"void declToImport() { (void)(1 ?: -5); }", Lang_CXX03, "", Lang_CXX03, "void declToImport() { (void)(1 ?: -5); }", Lang_CXX03, "", Lang_CXX03,
Verifier, Verifier,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
functionDecl(hasDescendant(binaryConditionalOperator( functionDecl(hasDescendant(binaryConditionalOperator(
hasCondition(implicitCastExpr( hasCondition(implicitCastExpr(
hasSourceExpression(opaqueValueExpr( hasSourceExpression(opaqueValueExpr(
hasSourceExpression(integerLiteral(equals(1))))), hasSourceExpression(integerLiteral(equals(1))))),
hasType(booleanType()))), hasType(booleanType()))),
hasTrueExpression(opaqueValueExpr( hasTrueExpression(opaqueValueExpr(
hasSourceExpression(integerLiteral(equals(1))))), hasSourceExpression(integerLiteral(equals(1))))),
hasFalseExpression(unaryOperator( hasFalseExpression(unaryOperator(
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
} }
TEST_P(ImportExpr, CXXTemporaryObjectExpr) { TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"struct C {};" "struct C {};"
"void declToImport() { C c = C(); }", "void declToImport() { C c = C(); }",
Lang_CXX03, "", Lang_CXX03, Verifier, Lang_CXX03, "", Lang_CXX03, Verifier,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr( functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr(
has(materializeTemporaryExpr(has(implicitCastExpr( has(materializeTemporaryExpr(has(implicitCastExpr(
has(cxxTemporaryObjectExpr())))))))))))); has(cxxTemporaryObjectExpr()))))))))))));
} }
TEST_P(ImportType, ImportAtomicType) { TEST_P(ImportType, ImportAtomicType) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
Show All 33 Lines
TEST_P(ImportType, ImportTypeAliasTemplate) { TEST_P(ImportType, ImportTypeAliasTemplate) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport( testImport(
"template <int K>" "template <int K>"
"struct dummy { static const int i = K; };" "struct dummy { static const int i = K; };"
"template <int K> using dummy2 = dummy<K>;" "template <int K> using dummy2 = dummy<K>;"
"int declToImport() { return dummy2<3>::i; }", "int declToImport() { return dummy2<3>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
functionDecl(hasDescendant(implicitCastExpr(has(declRefExpr()))), functionDecl(hasDescendant(implicitCastExpr(has(declRefExpr()))),
unless(hasAncestor( unless(hasAncestor(
translationUnitDecl(has(typeAliasDecl()))))))); translationUnitDecl(has(typeAliasDecl())))))));
} }
const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl> const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
varTemplateSpecializationDecl; varTemplateSpecializationDecl;
Show All 14 LinesTEST_P(ImportType, ImportPackExpansion) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
testImport("template <typename... Args>" testImport("template <typename... Args>"
"struct dummy {" "struct dummy {"
" dummy(Args... args) {}" " dummy(Args... args) {}"
" static const int i = 4;" " static const int i = 4;"
"};" "};"
"int declToImport() { return dummy<int>::i; }", "int declToImport() { return dummy<int>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, functionDecl(hasDescendant(returnStmt(has(
functionDecl(hasDescendant(returnStmt( implicitCastExpr(has(declRefExpr()))))))));
has(implicitCastExpr(has(declRefExpr()))))))));
} }
const internal::VariadicDynCastAllOfMatcher<Type, const internal::VariadicDynCastAllOfMatcher<Type,
DependentTemplateSpecializationType> DependentTemplateSpecializationType>
dependentTemplateSpecializationType; dependentTemplateSpecializationType;
TEST_P(ImportType, ImportDependentTemplateSpecialization) { TEST_P(ImportType, ImportDependentTemplateSpecialization) {
MatchVerifier<Decl> Verifier; MatchVerifier<Decl> Verifier;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 LinesTEST_P(ImportExpr, ImportCXXTypeidExpr) {
testImport( testImport(
"namespace std { class type_info {}; }" "namespace std { class type_info {}; }"
"void declToImport() {" "void declToImport() {"
" int x;" " int x;"
" auto a = typeid(int); auto b = typeid(x);" " auto a = typeid(int); auto b = typeid(x);"
"}", "}",
Lang_CXX11, "", Lang_CXX11, Verifier, Lang_CXX11, "", Lang_CXX11, Verifier,
traverse( traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
functionDecl( functionDecl(
hasDescendant(varDecl(hasName("a"), hasInitializer(hasDescendant( hasDescendant(varDecl(hasName("a"), hasInitializer(hasDescendant(
cxxTypeidExpr())))), cxxTypeidExpr())))),
hasDescendant(varDecl(hasName("b"), hasInitializer(hasDescendant( hasDescendant(varDecl(hasName("b"), hasInitializer(hasDescendant(
cxxTypeidExpr()))))))); cxxTypeidExpr())))))));
} }
TEST_P(ImportExpr, ImportTypeTraitExprValDep) { TEST_P(ImportExpr, ImportTypeTraitExprValDep) {
▲ Show 20 Lines • Show All 5,485 Lines • Show Last 20 Lines

clang/unittests/AST/ASTTypeTraitsTest.cpp

//===- unittest/AST/ASTTypeTraits.cpp - AST type traits unit tests ------===// //===- unittest/AST/ASTTypeTraits.cpp - AST type traits unit tests ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
#include "clang/AST/ASTTypeTraits.h" #include "clang/AST/ASTTypeTraits.h"
#include "MatchVerifier.h" #include "MatchVerifier.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace ast_type_traits { namespace {
TEST(ASTNodeKind, NoKind) { TEST(ASTNodeKind, NoKind) {
EXPECT_FALSE(ASTNodeKind().isBaseOf(ASTNodeKind())); EXPECT_FALSE(ASTNodeKind().isBaseOf(ASTNodeKind()));
EXPECT_FALSE(ASTNodeKind().isSame(ASTNodeKind())); EXPECT_FALSE(ASTNodeKind().isSame(ASTNodeKind()));
} }
template <typename T> static ASTNodeKind DNT() { template <typename T> static ASTNodeKind DNT() {
return ASTNodeKind::getFromNodeKind<T>(); return ASTNodeKind::getFromNodeKind<T>();
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
TEST(DynTypedNode, QualType) { TEST(DynTypedNode, QualType) {
QualType Q; QualType Q;
DynTypedNode Node = DynTypedNode::create(Q); DynTypedNode Node = DynTypedNode::create(Q);
EXPECT_TRUE(Node == Node); EXPECT_TRUE(Node == Node);
EXPECT_FALSE(Node < Node); EXPECT_FALSE(Node < Node);
} }
} // namespace ast_type_traits } // namespace
} // namespace clang } // namespace clang

clang/unittests/AST/SourceLocationTest.cpp

Show First 20 Lines • Show All 677 Lines • ▼ Show 20 Lines
TEST(ObjCMessageExpr, ParenExprRange) { TEST(ObjCMessageExpr, ParenExprRange) {
RangeVerifier<ParenExpr> Verifier; RangeVerifier<ParenExpr> Verifier;
Verifier.expectRange(5, 25, 5, 27); Verifier.expectRange(5, 25, 5, 27);
EXPECT_TRUE(Verifier.match("struct A { int a; };\n" EXPECT_TRUE(Verifier.match("struct A { int a; };\n"
"@interface B {}\n" "@interface B {}\n"
"+ (void) f1: (A)arg;\n" "+ (void) f1: (A)arg;\n"
"@end\n" "@end\n"
"void f2() { A a; [B f1: (a)]; }\n", "void f2() { A a; [B f1: (a)]; }\n",
traverse(ast_type_traits::TK_AsIs, parenExpr()), traverse(TK_AsIs, parenExpr()), Lang_OBJCXX));
Lang_OBJCXX));
} }
TEST(FunctionDecl, FunctionDeclWithThrowSpecification) { TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
RangeVerifier<FunctionDecl> Verifier; RangeVerifier<FunctionDecl> Verifier;
Verifier.expectRange(1, 1, 1, 16); Verifier.expectRange(1, 1, 1, 16);
EXPECT_TRUE(Verifier.match( EXPECT_TRUE(Verifier.match(
"void f() throw();\n", "void f() throw();\n",
functionDecl())); functionDecl()));
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

clang/unittests/AST/StmtPrinterTest.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 LinesTEST(StmtPrinter, TestFloatingPointLiteral) {
ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98, ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
"void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }", "void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }",
FunctionBodyMatcher("A"), FunctionBodyMatcher("A"),
"1.F , -1.F , 1. , -1. , 1.L , -1.L")); "1.F , -1.F , 1. , -1. , 1.L , -1.L"));
// Should be: with semicolon // Should be: with semicolon
} }
TEST(StmtPrinter, TestCXXConversionDeclImplicit) { TEST(StmtPrinter, TestCXXConversionDeclImplicit) {
ASSERT_TRUE( ASSERT_TRUE(PrintedStmtCXXMatches(
PrintedStmtCXXMatches(StdVer::CXX98, StdVer::CXX98,
"struct A {" "struct A {"
"operator void *();" "operator void *();"
"A operator&(A);" "A operator&(A);"
"};" "};"
"void bar(void *);" "void bar(void *);"
"void foo(A a, A b) {" "void foo(A a, A b) {"
" bar(a & b);" " bar(a & b);"
"}", "}",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxMemberCallExpr(anything()).bind("id")), "a & b"));
cxxMemberCallExpr(anything()).bind("id")),
"a & b"));
} }
TEST(StmtPrinter, TestCXXConversionDeclExplicit) { TEST(StmtPrinter, TestCXXConversionDeclExplicit) {
ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11, ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
"struct A {" "struct A {"
"operator void *();" "operator void *();"
"A operator&(A);" "A operator&(A);"
"};" "};"
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Lines DeclarationMatcher NamedNotRecord =
namedDecl(hasName("Foo"), unless(recordDecl())); namedDecl(hasName("Foo"), unless(recordDecl()));
EXPECT_TRUE(matches("void Foo(){}", NamedNotRecord)); EXPECT_TRUE(matches("void Foo(){}", NamedNotRecord));
EXPECT_TRUE(notMatches("struct Foo {};", NamedNotRecord)); EXPECT_TRUE(notMatches("struct Foo {};", NamedNotRecord));
} }
TEST_P(ASTMatchersTest, HasCastKind) { TEST_P(ASTMatchersTest, HasCastKind) {
EXPECT_TRUE( EXPECT_TRUE(
matches("char *p = 0;", matches("char *p = 0;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
varDecl(has(castExpr(hasCastKind(CK_NullToPointer))))))); varDecl(has(castExpr(hasCastKind(CK_NullToPointer)))))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"char *p = 0;", "char *p = 0;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
varDecl(has(castExpr(hasCastKind(CK_DerivedToBase))))))); varDecl(has(castExpr(hasCastKind(CK_DerivedToBase)))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches("char *p = 0;",
"char *p = 0;", traverse(TK_AsIs, varDecl(has(implicitCastExpr(
traverse(ast_type_traits::TK_AsIs, hasCastKind(CK_NullToPointer)))))));
varDecl(has(implicitCastExpr(hasCastKind(CK_NullToPointer)))))));
} }
TEST_P(ASTMatchersTest, HasDescendant) { TEST_P(ASTMatchersTest, HasDescendant) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
// FIXME: Add a test for `hasDescendant()` that does not depend on C++. // FIXME: Add a test for `hasDescendant()` that does not depend on C++.
return; return;
} }
▲ Show 20 Lines • Show All 1,248 Lines • ▼ Show 20 Lines
} }
TEST_P(ASTMatchersTest, HasArgument_CXXConstructorDecl) { TEST_P(ASTMatchersTest, HasArgument_CXXConstructorDecl) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
auto Constructor = traverse( auto Constructor = traverse(
ast_type_traits::TK_AsIs, TK_AsIs,
cxxConstructExpr(hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))))); cxxConstructExpr(hasArgument(0, declRefExpr(to(varDecl(hasName("y")))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"class X { public: X(int); }; void x() { int y; X x(y); }", Constructor)); "class X { public: X(int); }; void x() { int y; X x(y); }", Constructor));
EXPECT_TRUE( EXPECT_TRUE(
matches("class X { public: X(int); }; void x() { int y; X x = X(y); }", matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
Constructor)); Constructor));
EXPECT_TRUE( EXPECT_TRUE(
matches("class X { public: X(int); }; void x() { int y; X x = y; }", matches("class X { public: X(int); }; void x() { int y; X x = y; }",
Constructor)); Constructor));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"class X { public: X(int); }; void x() { int z; X x(z); }", Constructor)); "class X { public: X(int); }; void x() { int z; X x(z); }", Constructor));
StatementMatcher WrongIndex = StatementMatcher WrongIndex =
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxConstructExpr(hasArgument(
cxxConstructExpr( 42, declRefExpr(to(varDecl(hasName("y")))))));
hasArgument(42, declRefExpr(to(varDecl(hasName("y")))))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"class X { public: X(int); }; void x() { int y; X x(y); }", WrongIndex)); "class X { public: X(int); }; void x() { int y; X x(y); }", WrongIndex));
} }
TEST_P(ASTMatchersTest, ArgumentCountIs_CXXConstructExpr) { TEST_P(ASTMatchersTest, ArgumentCountIs_CXXConstructExpr) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
auto Constructor1Arg = auto Constructor1Arg =
traverse(ast_type_traits::TK_AsIs, cxxConstructExpr(argumentCountIs(1))); traverse(TK_AsIs, cxxConstructExpr(argumentCountIs(1)));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x(0); }", EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x(0); }",
Constructor1Arg)); Constructor1Arg));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = X(0); }", EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = X(0); }",
Constructor1Arg)); Constructor1Arg));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = 0; }", EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = 0; }",
Constructor1Arg)); Constructor1Arg));
EXPECT_TRUE( EXPECT_TRUE(
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
} }
TEST_P(ASTMatchersTest, IsListInitialization) { TEST_P(ASTMatchersTest, IsListInitialization) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
auto ConstructorListInit = auto ConstructorListInit =
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, varDecl(has(cxxConstructExpr(isListInitialization()))));
varDecl(has(cxxConstructExpr(isListInitialization()))));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x{0}; }", EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x{0}; }",
ConstructorListInit)); ConstructorListInit));
EXPECT_FALSE(matches("class X { public: X(int); }; void x() { X x(0); }", EXPECT_FALSE(matches("class X { public: X(int); }; void x() { X x(0); }",
ConstructorListInit)); ConstructorListInit));
} }
TEST_P(ASTMatchersTest, IsImplicit_CXXConstructorDecl) { TEST_P(ASTMatchersTest, IsImplicit_CXXConstructorDecl) {
▲ Show 20 Lines • Show All 2,248 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

Show First 20 Lines • Show All 470 Lines • ▼ Show 20 LinesTEST_P(ASTMatchersTest, CXXOperatorCallExpr) {
EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall)); EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
} }
TEST_P(ASTMatchersTest, ThisPointerType) { TEST_P(ASTMatchersTest, ThisPointerType) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
StatementMatcher MethodOnY = StatementMatcher MethodOnY = traverse(
traverse(ast_type_traits::TK_AsIs, TK_AsIs, cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y")))));
cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y")))));
EXPECT_TRUE(matches("class Y { public: void x(); }; void z() { Y y; y.x(); }", EXPECT_TRUE(matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
MethodOnY)); MethodOnY));
EXPECT_TRUE(matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }", EXPECT_TRUE(matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
MethodOnY)); MethodOnY));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"class Y { public: void x(); }; void z(Y *&y) { y->x(); }", MethodOnY)); "class Y { public: void x(); }; void z(Y *&y) { y->x(); }", MethodOnY));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
▲ Show 20 Lines • Show All 246 Lines • ▼ Show 20 LinesTEST_P(ASTMatchersTest, ParmVarDecl) {
EXPECT_TRUE(notMatches("void f();", parmVarDecl())); EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
} }
TEST_P(ASTMatchersTest, Matcher_ConstructorCall) { TEST_P(ASTMatchersTest, Matcher_ConstructorCall) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
StatementMatcher Constructor = StatementMatcher Constructor = traverse(TK_AsIs, cxxConstructExpr());
traverse(ast_type_traits::TK_AsIs, cxxConstructExpr());
EXPECT_TRUE( EXPECT_TRUE(
matches("class X { public: X(); }; void x() { X x; }", Constructor)); matches("class X { public: X(); }; void x() { X x; }", Constructor));
EXPECT_TRUE(matches("class X { public: X(); }; void x() { X x = X(); }", EXPECT_TRUE(matches("class X { public: X(); }; void x() { X x = X(); }",
Constructor)); Constructor));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = 0; }", EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x = 0; }",
Constructor)); Constructor));
EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor)); EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
Show All 17 Lines EXPECT_TRUE(
notMatches("struct X { int f () { int a; return a; } };", cxxThisExpr())); notMatches("struct X { int f () { int a; return a; } };", cxxThisExpr()));
} }
TEST_P(ASTMatchersTest, Matcher_BindTemporaryExpression) { TEST_P(ASTMatchersTest, Matcher_BindTemporaryExpression) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
StatementMatcher TempExpression = StatementMatcher TempExpression = traverse(TK_AsIs, cxxBindTemporaryExpr());
traverse(ast_type_traits::TK_AsIs, cxxBindTemporaryExpr());
StringRef ClassString = "class string { public: string(); ~string(); }; "; StringRef ClassString = "class string { public: string(); ~string(); }; ";
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
ClassString + "string GetStringByValue();" ClassString + "string GetStringByValue();"
"void FunctionTakesString(string s);" "void FunctionTakesString(string s);"
"void run() { FunctionTakesString(GetStringByValue()); }", "void run() { FunctionTakesString(GetStringByValue()); }",
TempExpression)); TempExpression));
Show All 16 Lines
} }
TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporaryCXX11CXX14) { TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporaryCXX11CXX14) {
if (GetParam().Language != Lang_CXX11 && GetParam().Language != Lang_CXX14) { if (GetParam().Language != Lang_CXX11 && GetParam().Language != Lang_CXX14) {
return; return;
} }
StatementMatcher TempExpression = StatementMatcher TempExpression =
traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr()); traverse(TK_AsIs, materializeTemporaryExpr());
EXPECT_TRUE(matches("class string { public: string(); }; " EXPECT_TRUE(matches("class string { public: string(); }; "
"string GetStringByValue();" "string GetStringByValue();"
"void FunctionTakesString(string s);" "void FunctionTakesString(string s);"
"void run() { FunctionTakesString(GetStringByValue()); }", "void run() { FunctionTakesString(GetStringByValue()); }",
TempExpression)); TempExpression));
} }
TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporary) { TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporary) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
StringRef ClassString = "class string { public: string(); int length(); }; "; StringRef ClassString = "class string { public: string(); int length(); }; ";
StatementMatcher TempExpression = StatementMatcher TempExpression =
traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr()); traverse(TK_AsIs, materializeTemporaryExpr());
EXPECT_TRUE(notMatches(ClassString + EXPECT_TRUE(notMatches(ClassString +
"string* GetStringPointer(); " "string* GetStringPointer(); "
"void FunctionTakesStringPtr(string* s);" "void FunctionTakesStringPtr(string* s);"
"void run() {" "void run() {"
" string* s = GetStringPointer();" " string* s = GetStringPointer();"
" FunctionTakesStringPtr(GetStringPointer());" " FunctionTakesStringPtr(GetStringPointer());"
" FunctionTakesStringPtr(s);" " FunctionTakesStringPtr(s);"
▲ Show 20 Lines • Show All 261 Lines • ▼ Show 20 Lines
} }
TEST_P(ASTMatchersTest, BinaryConditionalOperator) { TEST_P(ASTMatchersTest, BinaryConditionalOperator) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
// FIXME: This test should work in non-C++ language modes. // FIXME: This test should work in non-C++ language modes.
return; return;
} }
StatementMatcher AlwaysOne = StatementMatcher AlwaysOne = traverse(
traverse(ast_type_traits::TK_AsIs, TK_AsIs, binaryConditionalOperator(
binaryConditionalOperator(
hasCondition(implicitCastExpr(has(opaqueValueExpr( hasCondition(implicitCastExpr(has(opaqueValueExpr(
hasSourceExpression((integerLiteral(equals(1)))))))), hasSourceExpression((integerLiteral(equals(1)))))))),
hasFalseExpression(integerLiteral(equals(0))))); hasFalseExpression(integerLiteral(equals(0)))));
EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne)); EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne));
StatementMatcher FourNotFive = binaryConditionalOperator( StatementMatcher FourNotFive = binaryConditionalOperator(
hasTrueExpression( hasTrueExpression(
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 LinesTEST_P(ASTMatchersTest, CastExpr_MatchesExplicitCasts_CXX) {
} }
EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);", castExpr())); EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);", castExpr()));
EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr())); EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
EXPECT_TRUE(matches("char c = char(0);", castExpr())); EXPECT_TRUE(matches("char c = char(0);", castExpr()));
} }
TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) { TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) {
// This test creates an implicit cast from int to char. // This test creates an implicit cast from int to char.
EXPECT_TRUE( EXPECT_TRUE(matches("char c = 0;", traverse(TK_AsIs, castExpr())));
matches("char c = 0;", traverse(ast_type_traits::TK_AsIs, castExpr())));
// This test creates an implicit cast from lvalue to rvalue. // This test creates an implicit cast from lvalue to rvalue.
EXPECT_TRUE(matches("void f() { char c = 0, d = c; }", EXPECT_TRUE(matches("void f() { char c = 0, d = c; }",
traverse(ast_type_traits::TK_AsIs, castExpr()))); traverse(TK_AsIs, castExpr())));
} }
TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts) { TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts) {
if (GetParam().Language == Lang_C89 || GetParam().Language == Lang_C99) { if (GetParam().Language == Lang_C89 || GetParam().Language == Lang_C99) {
// This does have a cast in C // This does have a cast in C
EXPECT_TRUE(matches("char c = '0';", implicitCastExpr())); EXPECT_TRUE(matches("char c = '0';", implicitCastExpr()));
} else { } else {
EXPECT_TRUE(notMatches("char c = '0';", castExpr())); EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
"struct B { virtual ~B() {} }; struct D : B {};" "struct B { virtual ~B() {} }; struct D : B {};"
"B b;" "B b;"
"D* t = dynamic_cast<D*>(&b);", "D* t = dynamic_cast<D*>(&b);",
cStyleCastExpr())); cStyleCastExpr()));
} }
TEST_P(ASTMatchersTest, ImplicitCastExpr_MatchesSimpleCase) { TEST_P(ASTMatchersTest, ImplicitCastExpr_MatchesSimpleCase) {
// This test creates an implicit const cast. // This test creates an implicit const cast.
EXPECT_TRUE(matches("void f() { int x = 0; const int y = x; }", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("void f() { int x = 0; const int y = x; }",
varDecl(hasInitializer(implicitCastExpr()))))); traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
// This test creates an implicit cast from int to char. // This test creates an implicit cast from int to char.
EXPECT_TRUE(matches("char c = 0;", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("char c = 0;",
varDecl(hasInitializer(implicitCastExpr()))))); traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
// This test creates an implicit array-to-pointer cast. // This test creates an implicit array-to-pointer cast.
EXPECT_TRUE(matches("int arr[6]; int *p = arr;", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("int arr[6]; int *p = arr;",
varDecl(hasInitializer(implicitCastExpr()))))); traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
} }
TEST_P(ASTMatchersTest, ImplicitCastExpr_DoesNotMatchIncorrectly) { TEST_P(ASTMatchersTest, ImplicitCastExpr_DoesNotMatchIncorrectly) {
// This test verifies that implicitCastExpr() matches exactly when implicit // This test verifies that implicitCastExpr() matches exactly when implicit
// casts are present, and that it ignores explicit and paren casts. // casts are present, and that it ignores explicit and paren casts.
// These two test cases have no casts. // These two test cases have no casts.
EXPECT_TRUE( EXPECT_TRUE(
Show All 29 Lines
TEST_P(ASTMatchersTest, DeclStmt_MatchesVariableDeclarationStatements) { TEST_P(ASTMatchersTest, DeclStmt_MatchesVariableDeclarationStatements) {
EXPECT_TRUE(matches("void x() { int a; }", declStmt())); EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
} }
TEST_P(ASTMatchersTest, ExprWithCleanups_MatchesExprWithCleanups) { TEST_P(ASTMatchersTest, ExprWithCleanups_MatchesExprWithCleanups) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(matches("struct Foo { ~Foo(); };" EXPECT_TRUE(
matches("struct Foo { ~Foo(); };"
"const Foo f = Foo();", "const Foo f = Foo();",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, varDecl(hasInitializer(exprWithCleanups())))));
varDecl(hasInitializer(exprWithCleanups()))))); EXPECT_FALSE(
EXPECT_FALSE(matches("struct Foo { }; Foo a;" matches("struct Foo { }; Foo a;"
"const Foo f = a;", "const Foo f = a;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, varDecl(hasInitializer(exprWithCleanups())))));
varDecl(hasInitializer(exprWithCleanups())))));
} }
TEST_P(ASTMatchersTest, InitListExpr) { TEST_P(ASTMatchersTest, InitListExpr) {
EXPECT_TRUE(matches("int a[] = { 1, 2 };", EXPECT_TRUE(matches("int a[] = { 1, 2 };",
initListExpr(hasType(asString("int [2]"))))); initListExpr(hasType(asString("int [2]")))));
EXPECT_TRUE(matches("struct B { int x, y; }; struct B b = { 5, 6 };", EXPECT_TRUE(matches("struct B { int x, y; }; struct B b = { 5, 6 };",
initListExpr(hasType(recordDecl(hasName("B")))))); initListExpr(hasType(recordDecl(hasName("B"))))));
EXPECT_TRUE( EXPECT_TRUE(
Show All 18 LinesTEST_P(ASTMatchersTest,
StringRef code = "namespace std {" StringRef code = "namespace std {"
"template <typename> class initializer_list {" "template <typename> class initializer_list {"
" public: initializer_list() noexcept {}" " public: initializer_list() noexcept {}"
"};" "};"
"}" "}"
"struct A {" "struct A {"
" A(std::initializer_list<int>) {}" " A(std::initializer_list<int>) {}"
"};"; "};";
EXPECT_TRUE( EXPECT_TRUE(matches(
matches(code + "A a{0};", code + "A a{0};",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxConstructExpr(has(cxxStdInitializerListExpr()),
cxxConstructExpr(has(cxxStdInitializerListExpr()),
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
ofClass(hasName("A")))))))); ofClass(hasName("A"))))))));
EXPECT_TRUE( EXPECT_TRUE(matches(
matches(code + "A a = {0};", code + "A a = {0};",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxConstructExpr(has(cxxStdInitializerListExpr()),
cxxConstructExpr(has(cxxStdInitializerListExpr()),
hasDeclaration(cxxConstructorDecl( hasDeclaration(cxxConstructorDecl(
ofClass(hasName("A")))))))); ofClass(hasName("A"))))))));
EXPECT_TRUE(notMatches("int a[] = { 1, 2 };", cxxStdInitializerListExpr())); EXPECT_TRUE(notMatches("int a[] = { 1, 2 };", cxxStdInitializerListExpr()));
EXPECT_TRUE(notMatches("struct B { int x, y; }; B b = { 5, 6 };", EXPECT_TRUE(notMatches("struct B { int x, y; }; B b = { 5, 6 };",
cxxStdInitializerListExpr())); cxxStdInitializerListExpr()));
} }
TEST_P(ASTMatchersTest, UsingDecl_MatchesUsingDeclarations) { TEST_P(ASTMatchersTest, UsingDecl_MatchesUsingDeclarations) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }",
cxxCatchStmt(isCatchAll()))); cxxCatchStmt(isCatchAll())));
EXPECT_TRUE(matches("void foo() try {} catch(int X) { }", EXPECT_TRUE(matches("void foo() try {} catch(int X) { }",
varDecl(isExceptionVariable()))); varDecl(isExceptionVariable())));
EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }", EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }",
varDecl(isExceptionVariable()))); varDecl(isExceptionVariable())));
} }
TEST_P(ASTMatchersTest, ParenExpr_SimpleCases) { TEST_P(ASTMatchersTest, ParenExpr_SimpleCases) {
EXPECT_TRUE( EXPECT_TRUE(matches("int i = (3);", traverse(TK_AsIs, parenExpr())));
matches("int i = (3);", traverse(ast_type_traits::TK_AsIs, parenExpr()))); EXPECT_TRUE(matches("int i = (3 + 7);", traverse(TK_AsIs, parenExpr())));
EXPECT_TRUE(matches("int i = (3 + 7);", EXPECT_TRUE(notMatches("int i = 3;", traverse(TK_AsIs, parenExpr())));
traverse(ast_type_traits::TK_AsIs, parenExpr())));
EXPECT_TRUE(notMatches("int i = 3;",
traverse(ast_type_traits::TK_AsIs, parenExpr())));
EXPECT_TRUE(notMatches("int f() { return 1; }; void g() { int a = f(); }", EXPECT_TRUE(notMatches("int f() { return 1; }; void g() { int a = f(); }",
traverse(ast_type_traits::TK_AsIs, parenExpr()))); traverse(TK_AsIs, parenExpr())));
} }
TEST_P(ASTMatchersTest, IgnoringParens) { TEST_P(ASTMatchersTest, IgnoringParens) {
EXPECT_FALSE(matches( EXPECT_FALSE(matches("const char* str = (\"my-string\");",
"const char* str = (\"my-string\");", traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
traverse(ast_type_traits::TK_AsIs, stringLiteral())))));
implicitCastExpr(hasSourceExpression(stringLiteral()))))); EXPECT_TRUE(
EXPECT_TRUE(matches("const char* str = (\"my-string\");", matches("const char* str = (\"my-string\");",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
implicitCastExpr(hasSourceExpression(
ignoringParens(stringLiteral())))))); ignoringParens(stringLiteral()))))));
} }
TEST_P(ASTMatchersTest, QualType) { TEST_P(ASTMatchersTest, QualType) {
EXPECT_TRUE(matches("struct S {};", qualType().bind("loc"))); EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
} }
TEST_P(ASTMatchersTest, ConstantArrayType) { TEST_P(ASTMatchersTest, ConstantArrayType) {
EXPECT_TRUE(matches("int a[2];", constantArrayType())); EXPECT_TRUE(matches("int a[2];", constantArrayType()));
▲ Show 20 Lines • Show All 763 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 367 Lines • ▼ Show 20 Lines
TEST(Callee, MatchesDeclarations) { TEST(Callee, MatchesDeclarations) {
StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x")))); StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x"))));
EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX)); EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX)); EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
CallMethodX = CallMethodX = traverse(TK_AsIs, callExpr(callee(cxxConversionDecl())));
traverse(ast_type_traits::TK_AsIs, callExpr(callee(cxxConversionDecl())));
EXPECT_TRUE( EXPECT_TRUE(
matches("struct Y { operator int() const; }; int i = Y();", CallMethodX)); matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();", EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
CallMethodX)); CallMethodX));
} }
TEST(Callee, MatchesMemberExpressions) { TEST(Callee, MatchesMemberExpressions) {
EXPECT_TRUE(matches("class Y { void x() { this->x(); } };", EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 LinesTEST(Matcher, AnyArgument) {
EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY)); EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
EXPECT_TRUE(notMatches("struct Y { Y(int, int); };" EXPECT_TRUE(notMatches("struct Y { Y(int, int); };"
"void x() { int y; (void)Y(1, 2); }", "void x() { int y; (void)Y(1, 2); }",
CtorArgumentY)); CtorArgumentY));
EXPECT_TRUE(notMatches("template <class Y>" EXPECT_TRUE(notMatches("template <class Y>"
"void x() { int y; (void)Y(1, 2); }", "void x() { int y; (void)Y(1, 2); }",
UnresolvedCtorArgumentY)); UnresolvedCtorArgumentY));
StatementMatcher ImplicitCastedArgument = traverse( StatementMatcher ImplicitCastedArgument =
ast_type_traits::TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr()))); traverse(TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr())));
EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument)); EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
} }
TEST(Matcher, HasReceiver) { TEST(Matcher, HasReceiver) {
EXPECT_TRUE(matchesObjC( EXPECT_TRUE(matchesObjC(
"@interface NSString @end " "@interface NSString @end "
"void f(NSString *x) {" "void f(NSString *x) {"
"[x containsString];" "[x containsString];"
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 LinesTEST(MatcherCXXMemberCallExpr, OnImplicitObjectArgument) {
)cc"; )cc";
StringRef Snippet2 = R"cc( StringRef Snippet2 = R"cc(
struct Y { struct Y {
void m(); void m();
}; };
struct X : public Y {}; struct X : public Y {};
void z(X x) { x.m(); } void z(X x) { x.m(); }
)cc"; )cc";
auto MatchesY = traverse(ast_type_traits::TK_AsIs, auto MatchesY = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
cxxMemberCallExpr(onImplicitObjectArgument(
hasType(cxxRecordDecl(hasName("Y")))))); hasType(cxxRecordDecl(hasName("Y"))))));
EXPECT_TRUE(matches(Snippet1, MatchesY)); EXPECT_TRUE(matches(Snippet1, MatchesY));
EXPECT_TRUE(matches(Snippet2, MatchesY)); EXPECT_TRUE(matches(Snippet2, MatchesY));
auto MatchesX = traverse(ast_type_traits::TK_AsIs, auto MatchesX = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
cxxMemberCallExpr(onImplicitObjectArgument(
hasType(cxxRecordDecl(hasName("X")))))); hasType(cxxRecordDecl(hasName("X"))))));
EXPECT_TRUE(notMatches(Snippet2, MatchesX)); EXPECT_TRUE(notMatches(Snippet2, MatchesX));
// Parens are not ignored. // Parens are not ignored.
StringRef Snippet3 = R"cc( StringRef Snippet3 = R"cc(
struct Y { struct Y {
void m(); void m();
}; };
Y g(); Y g();
void z(Y y) { (g()).m(); } void z(Y y) { (g()).m(); }
)cc"; )cc";
auto MatchesCall = auto MatchesCall = traverse(
traverse(ast_type_traits::TK_AsIs, TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
EXPECT_TRUE(notMatches(Snippet3, MatchesCall)); EXPECT_TRUE(notMatches(Snippet3, MatchesCall));
} }
TEST(Matcher, HasObjectExpr) { TEST(Matcher, HasObjectExpr) {
StringRef Snippet1 = R"cc( StringRef Snippet1 = R"cc(
struct X { struct X {
int m; int m;
int f(X x) { return x.m; } int f(X x) { return x.m; }
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines EXPECT_TRUE(matchAndVerifyResultTrue(
"void f(int i, int j) { int y; f(y, y); }", CallExpr, "void f(int i, int j) { int y; f(y, y); }", CallExpr,
std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2))); std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
} }
TEST(ForEachArgumentWithParam, MatchesConstructExpr) { TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
StatementMatcher ArgumentY = StatementMatcher ArgumentY =
declRefExpr(to(varDecl(hasName("y")))).bind("arg"); declRefExpr(to(varDecl(hasName("y")))).bind("arg");
DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param"); DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
StatementMatcher ConstructExpr = StatementMatcher ConstructExpr = traverse(
traverse(ast_type_traits::TK_AsIs, TK_AsIs, cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));
cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));
EXPECT_TRUE(matchAndVerifyResultTrue( EXPECT_TRUE(matchAndVerifyResultTrue(
"struct C {" "struct C {"
" C(int i) {}" " C(int i) {}"
"};" "};"
"int y = 0;" "int y = 0;"
"C Obj(y);", "C Obj(y);",
ConstructExpr, ConstructExpr,
▲ Show 20 Lines • Show All 584 Lines • ▼ Show 20 LinesTEST(MatchBinaryOperator, HasLHSAndHasRHS) {
StatementMatcher OperatorTrueFalse = StatementMatcher OperatorTrueFalse =
binaryOperator(hasLHS(cxxBoolLiteral(equals(true))), binaryOperator(hasLHS(cxxBoolLiteral(equals(true))),
hasRHS(cxxBoolLiteral(equals(false)))); hasRHS(cxxBoolLiteral(equals(false))));
EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse)); EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse)); EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse)); EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
StatementMatcher OperatorIntPointer = StatementMatcher OperatorIntPointer = arraySubscriptExpr(
arraySubscriptExpr(hasLHS(hasType(isInteger())), hasLHS(hasType(isInteger())),
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, hasRHS(hasType(pointsTo(qualType())))));
hasRHS(hasType(pointsTo(qualType())))));
EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer)); EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer)); EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
} }
TEST(MatchBinaryOperator, HasEitherOperand) { TEST(MatchBinaryOperator, HasEitherOperand) {
StatementMatcher HasOperand = StatementMatcher HasOperand =
binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false)))); binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false))));
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches(
"int i[2]; void f() { 1[i] = 1; }", "int i[2]; void f() { 1[i] = 1; }",
arraySubscriptExpr(hasIndex(integerLiteral(equals(1)))))); arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"int i[2]; void f() { i[1] = 1; }", "int i[2]; void f() { i[1] = 1; }",
arraySubscriptExpr(hasIndex(integerLiteral(equals(0)))))); arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
} }
TEST(ArraySubscriptMatchers, MatchesArrayBase) { TEST(ArraySubscriptMatchers, MatchesArrayBase) {
EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 2; }", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("int i[2]; void f() { i[1] = 2; }",
arraySubscriptExpr(hasBase(implicitCastExpr( traverse(TK_AsIs, arraySubscriptExpr(hasBase(implicitCastExpr(
hasSourceExpression(declRefExpr()))))))); hasSourceExpression(declRefExpr())))))));
} }
TEST(Matcher, OfClass) { TEST(Matcher, OfClass) {
StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl( StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
ofClass(hasName("X"))))); ofClass(hasName("X")))));
EXPECT_TRUE( EXPECT_TRUE(
matches("class X { public: X(); }; void x(int) { X x; }", Constructor)); matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
cxxStaticCastExpr(hasDestinationType( cxxStaticCastExpr(hasDestinationType(
pointsTo(TypeMatcher(anything())))))); pointsTo(TypeMatcher(anything()))))));
} }
TEST(HasImplicitDestinationType, MatchesSimpleCase) { TEST(HasImplicitDestinationType, MatchesSimpleCase) {
// This test creates an implicit const cast. // This test creates an implicit const cast.
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"int x; const int i = x;", "int x; const int i = x;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(isInteger()))))); implicitCastExpr(hasImplicitDestinationType(isInteger())))));
// This test creates an implicit array-to-pointer cast. // This test creates an implicit array-to-pointer cast.
EXPECT_TRUE(matches("int arr[3]; int *p = arr;", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("int arr[3]; int *p = arr;",
implicitCastExpr(hasImplicitDestinationType( traverse(TK_AsIs, implicitCastExpr(hasImplicitDestinationType(
pointsTo(TypeMatcher(anything()))))))); pointsTo(TypeMatcher(anything())))))));
} }
TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) { TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
// This test creates an implicit cast from int to char. // This test creates an implicit cast from int to char.
EXPECT_TRUE(notMatches("char c = 0;", EXPECT_TRUE(notMatches("char c = 0;",
implicitCastExpr(hasImplicitDestinationType( implicitCastExpr(hasImplicitDestinationType(
unless(anything()))))); unless(anything())))));
// This test creates an implicit array-to-pointer cast. // This test creates an implicit array-to-pointer cast.
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
int main() int main()
{ {
SomeType i = something(); SomeType i = something();
} }
)"; )";
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
varDecl(hasName("i"), varDecl(hasName("i"),
hasInitializer(exprWithCleanups(has(cxxConstructExpr( hasInitializer(exprWithCleanups(has(cxxConstructExpr(
has(expr(ignoringImplicit(cxxConstructExpr(has( has(expr(ignoringImplicit(cxxConstructExpr(has(
expr(ignoringImplicit(callExpr()))))))))))))))); expr(ignoringImplicit(callExpr())))))))))))))));
} }
TEST(IgnoringImplicit, DoesNotMatchIncorrectly) { TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches("class C {}; C a = C();",
"class C {}; C a = C();", traverse(TK_AsIs, varDecl(has(cxxConstructExpr())))));
traverse(ast_type_traits::TK_AsIs, varDecl(has(cxxConstructExpr())))));
} }
TEST(Traversal, traverseMatcher) { TEST(Traversal, traverseMatcher) {
StringRef VarDeclCode = R"cpp( StringRef VarDeclCode = R"cpp(
void foo() void foo()
{ {
int i = 3.0; int i = 3.0;
▲ Show 20 Lines • Show All 1,193 Lines • ▼ Show 20 LinesTEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
// These tests verify that ignoringImplictCasts does not look through explicit // These tests verify that ignoringImplictCasts does not look through explicit
// casts or parentheses. // casts or parentheses.
EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);", EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
varDecl(hasInitializer(ignoringImpCasts( varDecl(hasInitializer(ignoringImpCasts(
integerLiteral()))))); integerLiteral())))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"int i = (0);", "int i = (0);",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs,
varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))))); varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))))));
EXPECT_TRUE(notMatches("float i = (float)0;", EXPECT_TRUE(notMatches("float i = (float)0;",
varDecl(hasInitializer(ignoringImpCasts( varDecl(hasInitializer(ignoringImpCasts(
integerLiteral()))))); integerLiteral())))));
EXPECT_TRUE(notMatches("float i = float(0);", EXPECT_TRUE(notMatches("float i = float(0);",
varDecl(hasInitializer(ignoringImpCasts( varDecl(hasInitializer(ignoringImpCasts(
integerLiteral()))))); integerLiteral())))));
} }
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines EXPECT_TRUE(notMatches("float y = (float)0;",
varDecl(hasInitializer(ignoringParenImpCasts( varDecl(hasInitializer(ignoringParenImpCasts(
integerLiteral()))))); integerLiteral())))));
EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);", EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
varDecl(hasInitializer(ignoringParenImpCasts( varDecl(hasInitializer(ignoringParenImpCasts(
integerLiteral()))))); integerLiteral())))));
} }
TEST(HasSourceExpression, MatchesImplicitCasts) { TEST(HasSourceExpression, MatchesImplicitCasts) {
EXPECT_TRUE(matches( EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
"class string {}; class URL { public: URL(string s); };"
"void r() {string a_string; URL url = a_string; }", "void r() {string a_string; URL url = a_string; }",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
implicitCastExpr(hasSourceExpression(cxxConstructExpr()))))); cxxConstructExpr())))));
} }
TEST(HasSourceExpression, MatchesExplicitCasts) { TEST(HasSourceExpression, MatchesExplicitCasts) {
EXPECT_TRUE(matches("float x = static_cast<float>(42);", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("float x = static_cast<float>(42);",
explicitCastExpr(hasSourceExpression( traverse(TK_AsIs, explicitCastExpr(hasSourceExpression(
hasDescendant(expr(integerLiteral()))))))); hasDescendant(expr(integerLiteral())))))));
} }
TEST(UsingDeclaration, MatchesSpecificTarget) { TEST(UsingDeclaration, MatchesSpecificTarget) {
EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;", EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
usingDecl(hasAnyUsingShadowDecl( usingDecl(hasAnyUsingShadowDecl(
hasTargetDecl(functionDecl()))))); hasTargetDecl(functionDecl())))));
EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;", EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
usingDecl(hasAnyUsingShadowDecl( usingDecl(hasAnyUsingShadowDecl(
Show All 37 Lines EXPECT_TRUE(notMatches("void x() { switch(42); }",
switchStmt(forEachSwitchCase(caseStmt())))); switchStmt(forEachSwitchCase(caseStmt()))));
EXPECT_TRUE(matches("void x() { switch(42) case 42:; }", EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
switchStmt(forEachSwitchCase(caseStmt())))); switchStmt(forEachSwitchCase(caseStmt()))));
EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
switchStmt(forEachSwitchCase(caseStmt())))); switchStmt(forEachSwitchCase(caseStmt()))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }", "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt())))))); ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
EXPECT_TRUE( EXPECT_TRUE(matches(
matches("void x() { switch(42) { case 1+1: case 4:; } }", "void x() { switch(42) { case 1+1: case 4:; } }",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
constantExpr(has(integerLiteral()))))))))); constantExpr(has(integerLiteral())))))))));
EXPECT_TRUE( EXPECT_TRUE(notMatches(
notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }", "void x() { switch(42) { case 1+1: case 2+2:; } }",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
constantExpr(has(integerLiteral()))))))))); constantExpr(has(integerLiteral())))))))));
EXPECT_TRUE( EXPECT_TRUE(notMatches(
notMatches("void x() { switch(42) { case 1 ... 2:; } }", "void x() { switch(42) { case 1 ... 2:; } }",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
constantExpr(has(integerLiteral()))))))))); constantExpr(has(integerLiteral())))))))));
EXPECT_TRUE(matchAndVerifyResultTrue( EXPECT_TRUE(matchAndVerifyResultTrue(
"void x() { switch (42) { case 1: case 2: case 3: default:; } }", "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
switchStmt(forEachSwitchCase(caseStmt().bind("x"))), switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3))); std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
} }
TEST(Declaration, HasExplicitSpecifier) { TEST(Declaration, HasExplicitSpecifier) {
EXPECT_TRUE(notMatches("void f();", EXPECT_TRUE(notMatches("void f();",
functionDecl(hasExplicitSpecifier(constantExpr())), functionDecl(hasExplicitSpecifier(constantExpr())),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
notMatches("template<bool b> struct S { explicit operator int(); };", notMatches("template<bool b> struct S { explicit operator int(); };",
cxxConversionDecl( cxxConversionDecl(
hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))), hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
notMatches("template<bool b> struct S { explicit(b) operator int(); };", notMatches("template<bool b> struct S { explicit(b) operator int(); };",
cxxConversionDecl( cxxConversionDecl(
hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))), hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("struct S { explicit(true) operator int(); };", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("struct S { explicit(true) operator int(); };",
cxxConversionDecl(hasExplicitSpecifier( traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("struct S { explicit(false) operator int(); };", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("struct S { explicit(false) operator int(); };",
cxxConversionDecl(hasExplicitSpecifier( traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(notMatches("template<bool b> struct S { explicit(b) S(int); };", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, notMatches("template<bool b> struct S { explicit(b) S(int); };",
cxxConstructorDecl(hasExplicitSpecifier( traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("struct S { explicit(true) S(int); };", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("struct S { explicit(true) S(int); };",
cxxConstructorDecl(hasExplicitSpecifier( traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("struct S { explicit(false) S(int); };", EXPECT_TRUE(
traverse(ast_type_traits::TK_AsIs, matches("struct S { explicit(false) S(int); };",
cxxConstructorDecl(hasExplicitSpecifier( traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
notMatches("template<typename T> struct S { S(int); };" notMatches("template<typename T> struct S { S(int); };"
"template<bool b = true> explicit(b) S(int) -> S<int>;", "template<bool b = true> explicit(b) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
cxxDeductionGuideDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("template<typename T> struct S { S(int); };" EXPECT_TRUE(
matches("template<typename T> struct S { S(int); };"
"explicit(true) S(int) -> S<int>;", "explicit(true) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
cxxDeductionGuideDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches("template<typename T> struct S { S(int); };" EXPECT_TRUE(
matches("template<typename T> struct S { S(int); };"
"explicit(false) S(int) -> S<int>;", "explicit(false) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
cxxDeductionGuideDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater())); langCxx20OrLater()));
} }
TEST(ForEachConstructorInitializer, MatchesInitializers) { TEST(ForEachConstructorInitializer, MatchesInitializers) {
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"struct X { X() : i(42), j(42) {} int i, j; };", "struct X { X() : i(42), j(42) {} int i, j; };",
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer())))); cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
} }
▲ Show 20 Lines • Show All 880 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp

Show First 20 Lines • Show All 501 Lines • ▼ Show 20 Lines Matcher<Decl> Value = constructMatcher(
"decl", constructMatcher("hasAttr", StringRef("attr::WarnUnused"))) "decl", constructMatcher("hasAttr", StringRef("attr::WarnUnused")))
.getTypedMatcher<Decl>(); .getTypedMatcher<Decl>();
EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value)); EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value));
EXPECT_FALSE(matches("struct X {};", Value)); EXPECT_FALSE(matches("struct X {};", Value));
} }
TEST_F(RegistryTest, ParenExpr) { TEST_F(RegistryTest, ParenExpr) {
Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>(); Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
EXPECT_TRUE( EXPECT_TRUE(matches("int i = (1);", traverse(TK_AsIs, Value)));
matches("int i = (1);", traverse(ast_type_traits::TK_AsIs, Value))); EXPECT_FALSE(matches("int i = 1;", traverse(TK_AsIs, Value)));
EXPECT_FALSE(
matches("int i = 1;", traverse(ast_type_traits::TK_AsIs, Value)));
} }
TEST_F(RegistryTest, EqualsMatcher) { TEST_F(RegistryTest, EqualsMatcher) {
Matcher<Stmt> BooleanStmt = constructMatcher( Matcher<Stmt> BooleanStmt = constructMatcher(
"cxxBoolLiteral", constructMatcher("equals", VariantValue(true))) "cxxBoolLiteral", constructMatcher("equals", VariantValue(true)))
.getTypedMatcher<Stmt>(); .getTypedMatcher<Stmt>();
EXPECT_TRUE(matches("bool x = true;", BooleanStmt)); EXPECT_TRUE(matches("bool x = true;", BooleanStmt));
EXPECT_FALSE(matches("bool x = false;", BooleanStmt)); EXPECT_FALSE(matches("bool x = false;", BooleanStmt));
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
StmtMatcher withEnclosingCompound(ExprMatcher Matcher) { StmtMatcher withEnclosingCompound(ExprMatcher Matcher) {
return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr"); return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr");
} }
bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) { bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
const auto *const S = selectFirst<Stmt>("stmt", Results); const auto *const S = selectFirst<Stmt>("stmt", Results);
const auto *const E = selectFirst<Expr>("expr", Results); const auto *const E = selectFirst<Expr>("expr", Results);
TraversalKindScope RAII(AST->getASTContext(), ast_type_traits::TK_AsIs); TraversalKindScope RAII(AST->getASTContext(), TK_AsIs);
return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E); return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
} }
SmallVector<std::string, 1> SmallVector<std::string, 1>
mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) { mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
const auto *const S = selectFirst<Stmt>("stmt", Results); const auto *const S = selectFirst<Stmt>("stmt", Results);
SmallVector<std::string, 1> Chain; SmallVector<std::string, 1> Chain;
ExprMutationAnalyzer Analyzer(*S, AST->getASTContext()); ExprMutationAnalyzer Analyzer(*S, AST->getASTContext());
▲ Show 20 Lines • Show All 1,399 Lines • Show Last 20 Lines

clang/unittests/Tooling/RangeSelectorTest.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template <typename M> TestMatch matchCode(StringRef Code, M Matcher) { template <typename M> TestMatch matchCode(StringRef Code, M Matcher) {
auto ASTUnit = tooling::buildASTFromCode(Code); auto ASTUnit = tooling::buildASTFromCode(Code);
assert(ASTUnit != nullptr && "AST construction failed"); assert(ASTUnit != nullptr && "AST construction failed");
ASTContext &Context = ASTUnit->getASTContext(); ASTContext &Context = ASTUnit->getASTContext();
assert(!Context.getDiagnostics().hasErrorOccurred() && "Compilation error"); assert(!Context.getDiagnostics().hasErrorOccurred() && "Compilation error");
TraversalKindScope RAII(Context, ast_type_traits::TK_AsIs); TraversalKindScope RAII(Context, TK_AsIs);
auto Matches = ast_matchers::match(Matcher, Context); auto Matches = ast_matchers::match(Matcher, Context);
// We expect a single, exact match. // We expect a single, exact match.
assert(Matches.size() != 0 && "no matches found"); assert(Matches.size() != 0 && "no matches found");
assert(Matches.size() == 1 && "too many matches"); assert(Matches.size() == 1 && "too many matches");
return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)}; return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)};
} }
▲ Show 20 Lines • Show All 691 Lines • Show Last 20 Lines

clang/unittests/Tooling/RefactoringCallbacksTest.cpp

Show All 16 Lines
using namespace ast_matchers; using namespace ast_matchers;
template <typename T> template <typename T>
void expectRewritten(const std::string &Code, const std::string &Expected, void expectRewritten(const std::string &Code, const std::string &Expected,
const T &AMatcher, RefactoringCallback &Callback) { const T &AMatcher, RefactoringCallback &Callback) {
std::map<std::string, Replacements> FileToReplace; std::map<std::string, Replacements> FileToReplace;
ASTMatchRefactorer Finder(FileToReplace); ASTMatchRefactorer Finder(FileToReplace);
Finder.addMatcher(traverse(ast_type_traits::TK_AsIs, AMatcher), &Callback); Finder.addMatcher(traverse(TK_AsIs, AMatcher), &Callback);
std::unique_ptr<tooling::FrontendActionFactory> Factory( std::unique_ptr<tooling::FrontendActionFactory> Factory(
tooling::newFrontendActionFactory(&Finder)); tooling::newFrontendActionFactory(&Finder));
ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code)) ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
<< "Parsing error in \"" << Code << "\""; << "Parsing error in \"" << Code << "\"";
RewriterTestContext Context; RewriterTestContext Context;
FileID ID = Context.createInMemoryFile("input.cc", Code); FileID ID = Context.createInMemoryFile("input.cc", Code);
EXPECT_TRUE(tooling::applyAllReplacements(FileToReplace["input.cc"], EXPECT_TRUE(tooling::applyAllReplacements(FileToReplace["input.cc"],
Context.Rewrite)); Context.Rewrite));
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
TEST(RefactoringCallbacksTest, TemplateUnknownDollar) { TEST(RefactoringCallbacksTest, TemplateUnknownDollar) {
auto Callback = ReplaceNodeWithTemplate::create("decl", auto Callback = ReplaceNodeWithTemplate::create("decl",
"string x = \"$<"); "string x = \"$<");
ExpectStringError("Invalid $ in replacement template near $<", ExpectStringError("Invalid $ in replacement template near $<",
Callback.takeError()); Callback.takeError());
} }
} // namespace tooling
} // end namespace ast_matchers
} // end namespace clang } // end namespace clang

clang/unittests/Tooling/StencilTest.cpp

Show First 20 Lines • Show All 332 Lines • ▼ Show 20 LinesTEST_F(StencilTest, AccessOpExplicitThis) {
StringRef Snippet = R"cc( StringRef Snippet = R"cc(
class C { class C {
public: public:
int x; int x;
int foo() { return this->x; } int foo() { return this->x; }
}; };
)cc"; )cc";
auto StmtMatch = matchStmt( auto StmtMatch = matchStmt(
Snippet, traverse(ast_type_traits::TK_AsIs, Snippet,
returnStmt(hasReturnValue(ignoringImplicit(memberExpr( traverse(TK_AsIs, returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
hasObjectExpression(expr().bind("obj")))))))); hasObjectExpression(expr().bind("obj"))))))));
ASSERT_TRUE(StmtMatch); ASSERT_TRUE(StmtMatch);
const Stencil Stencil = access("obj", "field"); const Stencil Stencil = access("obj", "field");
EXPECT_THAT_EXPECTED(Stencil->eval(StmtMatch->Result), EXPECT_THAT_EXPECTED(Stencil->eval(StmtMatch->Result),
HasValue("this->field")); HasValue("this->field"));
} }
TEST_F(StencilTest, AccessOpImplicitThis) { TEST_F(StencilTest, AccessOpImplicitThis) {
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines