This is an archive of the discontinued LLVM Phabricator instance.

Differential D82278

Fix traversal over CXXConstructExpr in Syntactic mode
ClosedPublic

Authored by steveire on Jun 21 2020, 7:18 AM.

Details

Reviewers
klimek
ymandel
aaron.ballman
rsmith
sammccall
Commits
rG52ff86d25598: [AST] Fix traversal over CXXConstructExpr in Syntactic mode
Summary

Skip over elidable nodes, and ensure that intermediate
CXXFunctionalCastExpr nodes are also skipped if they are semantic.

Diff Detail

Event Timeline

steveire created this revision.Jun 21 2020, 7:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 21 2020, 7:18 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
riccibruno added a subscriber: riccibruno.Jun 21 2020, 7:35 AM
Harbormaster failed remote builds in B61168: Diff 272309!Jun 21 2020, 8:28 AM
steveire added a reviewer: aaron.ballman.Jul 4 2020, 6:03 AM
aaron.ballman added reviewers: rsmith, sammccall.Jul 7 2020, 8:04 AM
aaron.ballman added inline comments.
clang-tools-extra/clang-tidy/bugprone/UnusedRaiiCheck.cpp
80

While I believe the change is necessary here, it's not obvious to me what "hints" tell me this behavior is correct for the given matchers. None of the matchers look like they're going to care about implicit nodes, so how am I to know that AsIs is correct or not as a reviewer? As it stands, I sort of feel like I have to take it on faith that this change is correct and it looks a little suspicious because the code using the matcher is creating a fix-it at what now may be the location of an implicit node.

clang/lib/AST/Expr.cpp
3001

Looks like the change introduced new curly braces for a single-line if.

clang/lib/AST/ParentMapContext.cpp
157

const auto *

ymandel added a comment.Jul 7 2020, 1:02 PM

Thanks for this fix!

clang/lib/AST/Expr.cpp
3001

Why is it necessary to check isElidable? I think the logic here is subtle (since the AST doesn't explicitly tag implicit expressions), so please add an explanatory comment.

clang/lib/AST/ParentMapContext.cpp
163

Same here. Please comment on the logic.

steveire updated this revision to Diff 300550.Oct 25 2020, 12:02 PM

Rebased

steveire marked 2 inline comments as done.Oct 25 2020, 12:06 PM
steveire added inline comments.
clang-tools-extra/clang-tidy/bugprone/UnusedRaiiCheck.cpp
80

I don't know if I was wrong about it being required before, or if it was required before, but the change to this file is not required now.

clang/lib/AST/Expr.cpp
3001

The ignoringElidableConstructorCall does it this way. I'm afraid I don't know more than that.

Harbormaster completed remote builds in B76330: Diff 300550.Oct 25 2020, 12:31 PM
steveire mentioned this in D80499: Remove obsolete ignore*() matcher uses.Oct 29 2020, 7:42 AM
ymandel added inline comments.Oct 29 2020, 8:27 AM
clang/lib/AST/Expr.cpp
2983

nit: just return SE?

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
968

is this necessary/desirable given that we reverted the default behavior? if so, should we update other tests (at least, others involving this matcher) as well?

steveire updated this revision to Diff 301636.Oct 29 2020, 8:40 AM

Update

steveire marked 2 inline comments as done.Oct 29 2020, 8:40 AM
Harbormaster completed remote builds in B76920: Diff 301636.Oct 29 2020, 9:16 AM
ymandel accepted this revision.Oct 29 2020, 9:35 AM
This revision is now accepted and ready to land.Oct 29 2020, 9:35 AM
aaron.ballman accepted this revision.Oct 29 2020, 12:20 PM

LGTM!

This revision was landed with ongoing or failed builds.Oct 30 2020, 5:15 AM
Closed by commit rG52ff86d25598: [AST] Fix traversal over CXXConstructExpr in Syntactic mode (authored by • stephenkelly). · Explain Why
This revision was automatically updated to reflect the committed changes.
• stephenkelly added a commit: rG52ff86d25598: [AST] Fix traversal over CXXConstructExpr in Syntactic mode.

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
bugprone/
24 lines
3 lines
clang/
lib/
AST/
9 lines
7 lines
unittests/
AST/
169 lines
ASTMatchers/
2 lines
109 lines

Diff 272309

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

Show All 15 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) { void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) {
auto CtorInitializerList = auto CtorInitializerList =
cxxConstructorDecl(hasAnyConstructorInitializer(anything())); cxxConstructorDecl(hasAnyConstructorInitializer(anything()));
Finder->addMatcher( Finder->addMatcher(
traverse(
TK_AsIs,
expr(anyOf(cxxFunctionalCastExpr(), cxxBindTemporaryExpr(), expr(anyOf(cxxFunctionalCastExpr(), cxxBindTemporaryExpr(),
cxxTemporaryObjectExpr()), cxxTemporaryObjectExpr()),
hasType(cxxRecordDecl( hasType(cxxRecordDecl(
isSameOrDerivedFrom(matchesName("[Ee]xception|EXCEPTION")))), isSameOrDerivedFrom(matchesName("[Ee]xception|EXCEPTION")))),
unless(anyOf(hasAncestor(stmt( unless(anyOf(hasAncestor(stmt(anyOf(cxxThrowExpr(), callExpr(),
anyOf(cxxThrowExpr(), callExpr(), returnStmt()))), returnStmt()))),
hasAncestor(varDecl()), hasAncestor(varDecl()),
allOf(hasAncestor(CtorInitializerList), allOf(hasAncestor(CtorInitializerList),
unless(hasAncestor(cxxCatchStmt())))))) unless(hasAncestor(cxxCatchStmt()))))))
.bind("temporary-exception-not-thrown"), .bind("temporary-exception-not-thrown")),
this); this);
} }
void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) { void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) {
const auto *TemporaryExpr = const auto *TemporaryExpr =
Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown"); Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but " diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but "
"not thrown; did you mean 'throw %0'?") "not thrown; did you mean 'throw %0'?")
<< TemporaryExpr->getType().getBaseTypeIdentifier()->getName(); << TemporaryExpr->getType().getBaseTypeIdentifier()->getName();
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (TOE->getNumArgs() == 0) {
Replacement); Replacement);
return; return;
} }
// Otherwise just suggest adding a name. To find the place to insert the name // Otherwise just suggest adding a name. To find the place to insert the name
// find the first TypeLoc in the children of E, which always points to the // find the first TypeLoc in the children of E, which always points to the
// written type. // written type.
auto Matches = auto Matches =
match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context); match(traverse(TK_AsIs, expr(hasDescendant(typeLoc().bind("t")))), *E,
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

While I believe the change is necessary here, it's not obvious to me what "hints" tell me this behavior is correct for the given matchers. None of the matchers look like they're going to care about implicit nodes, so how am I to know that AsIs is correct or not as a reviewer? As it stands, I sort of feel like I have to take it on faith that this change is correct and it looks a little suspicious because the code using the matcher is creating a fix-it at what now may be the location of an implicit node.

aaron.ballman: While I believe the change is necessary here, it's not obvious to me what "hints" tell me this…
steveireAuthorUnsubmitted
Done
ReplyInline Actions

I don't know if I was wrong about it being required before, or if it was required before, but the change to this file is not required now.

steveire: I don't know if I was wrong about it being required before, or if it was required before, but…
*Result.Context);
const auto *TL = selectFirst<TypeLoc>("t", Matches); const auto *TL = selectFirst<TypeLoc>("t", Matches);
D << FixItHint::CreateInsertion( D << FixItHint::CreateInsertion(
Lexer::getLocForEndOfToken(TL->getEndLoc(), 0, *Result.SourceManager, Lexer::getLocForEndOfToken(TL->getEndLoc(), 0, *Result.SourceManager,
getLangOpts()), getLangOpts()),
Replacement); Replacement);
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang/lib/AST/Expr.cpp

Show First 20 Lines • Show All 2,974 Lines • ▼ Show 20 LinesExpr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
}); });
} }
Expr *Expr::IgnoreUnlessSpelledInSource() { Expr *Expr::IgnoreUnlessSpelledInSource() {
Expr *E = this; Expr *E = this;
Expr *LastE = nullptr; Expr *LastE = nullptr;
while (E != LastE) { while (E != LastE) {
LastE = E; LastE = E;
ymandelUnsubmitted
Done
ReplyInline Actions

nit: just return SE?

ymandel: nit: just `return SE`?
E = IgnoreExprNodes(E, IgnoreImplicitSingleStep, E = IgnoreExprNodes(E, IgnoreImplicitSingleStep,
IgnoreImpCastsExtraSingleStep, IgnoreImpCastsExtraSingleStep,
IgnoreParensOnlySingleStep); IgnoreParensOnlySingleStep);
auto SR = E->getSourceRange(); auto SR = E->getSourceRange();
if (auto *Cast = dyn_cast<CXXFunctionalCastExpr>(E)) {
auto *SE = Cast->getSubExpr();
if (SE->getSourceRange() == SR)
return Cast->getSubExpr();
}
if (auto *C = dyn_cast<CXXConstructExpr>(E)) { if (auto *C = dyn_cast<CXXConstructExpr>(E)) {
auto NumArgs = C->getNumArgs(); auto NumArgs = C->getNumArgs();
if (NumArgs == 1 || if (NumArgs == 1 ||
(NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) { (NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) {
Expr *A = C->getArg(0); Expr *A = C->getArg(0);
if (A->getSourceRange() == SR || !isa<CXXTemporaryObjectExpr>(C)) if (A->getSourceRange() == SR || C->isElidable()) {
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Looks like the change introduced new curly braces for a single-line if.

aaron.ballman: Looks like the change introduced new curly braces for a single-line if.
ymandelUnsubmitted
Not Done
ReplyInline Actions

Why is it necessary to check isElidable? I think the logic here is subtle (since the AST doesn't explicitly tag implicit expressions), so please add an explanatory comment.

ymandel: Why is it necessary to check isElidable? I think the logic here is subtle (since the AST…
steveireAuthorUnsubmitted
Done
ReplyInline Actions

The ignoringElidableConstructorCall does it this way. I'm afraid I don't know more than that.

steveire: The `ignoringElidableConstructorCall` does it this way. I'm afraid I don't know more than that.
E = A; E = A;
} }
} }
}
if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) { if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
Expr *ExprNode = C->getImplicitObjectArgument(); Expr *ExprNode = C->getImplicitObjectArgument();
if (ExprNode->getSourceRange() == SR) { if (ExprNode->getSourceRange() == SR) {
E = ExprNode; E = ExprNode;
continue; continue;
} }
if (auto *PE = dyn_cast<ParenExpr>(ExprNode)) { if (auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
▲ Show 20 Lines • Show All 1,972 Lines • Show Last 20 Lines

clang/lib/AST/ParentMapContext.cpp

Show First 20 Lines • Show All 148 Lines • ▼ Show 20 Lines auto ShouldSkip = [](const Expr *E, const Expr *Child) {
if (isa<ParenExpr>(E)) if (isa<ParenExpr>(E))
return true; return true;
if (isa<ExprWithCleanups>(E)) if (isa<ExprWithCleanups>(E))
return true; return true;
auto SR = Child->getSourceRange(); auto SR = Child->getSourceRange();
if (auto *C = dyn_cast<CXXFunctionalCastExpr>(E)) {
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: 'auto *C' can be declared as 'const auto *C' [llvm-qualified-auto]
not useful

Lint: Pre-merge checks: clang-tidy: warning: 'auto *C' can be declared as 'const auto *C' [llvm-qualified-auto] [[https…
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

const auto *

aaron.ballman: `const auto *`
if (C->getSourceRange() == SR)
return true;
}
if (const auto *C = dyn_cast<CXXConstructExpr>(E)) { if (const auto *C = dyn_cast<CXXConstructExpr>(E)) {
if (C->getSourceRange() == SR || !isa<CXXTemporaryObjectExpr>(C)) if (C->getSourceRange() == SR || C->isElidable())
ymandelUnsubmitted
Not Done
ReplyInline Actions

Same here. Please comment on the logic.

ymandel: Same here. Please comment on the logic.
return true; return true;
} }
if (const auto *C = dyn_cast<CXXMemberCallExpr>(E)) { if (const auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
if (C->getSourceRange() == SR) if (C->getSourceRange() == SR)
return true; return true;
} }
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

clang/unittests/AST/ASTTraverserTest.cpp

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines
template <unsigned alignment> template <unsigned alignment>
void template_test() { void template_test() {
static_assert(alignment, ""); static_assert(alignment, "");
} }
void actual_template_test() { void actual_template_test() {
template_test<4>(); template_test<4>();
} }
struct OneParamCtor {
explicit OneParamCtor(int);
};
struct TwoParamCtor {
explicit TwoParamCtor(int, int);
};
void varDeclCtors() {
{
auto var1 = OneParamCtor(5);
auto var2 = TwoParamCtor(6, 7);
}
{
OneParamCtor var3(5);
TwoParamCtor var4(6, 7);
}
int i = 0;
{
auto var5 = OneParamCtor(i);
auto var6 = TwoParamCtor(i, 7);
}
{
OneParamCtor var7(i);
TwoParamCtor var8(i, 7);
}
}
)cpp"); )cpp");
{ {
auto FN = auto FN =
ast_matchers::match(functionDecl(hasName("stringConstruct")).bind("fn"), ast_matchers::match(functionDecl(hasName("stringConstruct")).bind("fn"),
AST->getASTContext()); AST->getASTContext());
EXPECT_EQ(FN.size(), 1u); EXPECT_EQ(FN.size(), 1u);
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines)cpp");
EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
FN[1].getNodeAs<Decl>("staticAssert")), FN[1].getNodeAs<Decl>("staticAssert")),
R"cpp( R"cpp(
StaticAssertDecl StaticAssertDecl
|-IntegerLiteral |-IntegerLiteral
`-StringLiteral `-StringLiteral
)cpp"); )cpp");
} }
auto varChecker = [&AST](StringRef varName, StringRef SemanticDump,
StringRef SyntacticDump) {
auto FN = ast_matchers::match(
functionDecl(
hasName("varDeclCtors"),
forEachDescendant(varDecl(hasName(varName)).bind("varDeclCtor"))),
AST->getASTContext());
EXPECT_EQ(FN.size(), 1u);
EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("varDeclCtor")),
SemanticDump);
EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
FN[0].getNodeAs<Decl>("varDeclCtor")),
SyntacticDump);
};
varChecker("var1",
R"cpp(
VarDecl 'var1'
`-ExprWithCleanups
`-CXXConstructExpr
`-MaterializeTemporaryExpr
`-CXXFunctionalCastExpr
`-CXXConstructExpr
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var1'
`-CXXConstructExpr
`-IntegerLiteral
)cpp");
varChecker("var2",
R"cpp(
VarDecl 'var2'
`-ExprWithCleanups
`-CXXConstructExpr
`-MaterializeTemporaryExpr
`-CXXTemporaryObjectExpr
|-IntegerLiteral
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var2'
`-CXXTemporaryObjectExpr
|-IntegerLiteral
`-IntegerLiteral
)cpp");
varChecker("var3",
R"cpp(
VarDecl 'var3'
`-CXXConstructExpr
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var3'
`-CXXConstructExpr
`-IntegerLiteral
)cpp");
varChecker("var4",
R"cpp(
VarDecl 'var4'
`-CXXConstructExpr
|-IntegerLiteral
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var4'
`-CXXConstructExpr
|-IntegerLiteral
`-IntegerLiteral
)cpp");
varChecker("var5",
R"cpp(
VarDecl 'var5'
`-ExprWithCleanups
`-CXXConstructExpr
`-MaterializeTemporaryExpr
`-CXXFunctionalCastExpr
`-CXXConstructExpr
`-ImplicitCastExpr
`-DeclRefExpr 'i'
)cpp",
R"cpp(
VarDecl 'var5'
`-CXXConstructExpr
`-DeclRefExpr 'i'
)cpp");
varChecker("var6",
R"cpp(
VarDecl 'var6'
`-ExprWithCleanups
`-CXXConstructExpr
`-MaterializeTemporaryExpr
`-CXXTemporaryObjectExpr
|-ImplicitCastExpr
| `-DeclRefExpr 'i'
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var6'
`-CXXTemporaryObjectExpr
|-DeclRefExpr 'i'
`-IntegerLiteral
)cpp");
varChecker("var7",
R"cpp(
VarDecl 'var7'
`-CXXConstructExpr
`-ImplicitCastExpr
`-DeclRefExpr 'i'
)cpp",
R"cpp(
VarDecl 'var7'
`-CXXConstructExpr
`-DeclRefExpr 'i'
)cpp");
varChecker("var8",
R"cpp(
VarDecl 'var8'
`-CXXConstructExpr
|-ImplicitCastExpr
| `-DeclRefExpr 'i'
`-IntegerLiteral
)cpp",
R"cpp(
VarDecl 'var8'
`-CXXConstructExpr
|-DeclRefExpr 'i'
`-IntegerLiteral
)cpp");
} }
TEST(Traverse, IgnoreUnlessSpelledInSourceStructs) { TEST(Traverse, IgnoreUnlessSpelledInSourceStructs) {
auto AST = buildASTFromCode(R"cpp( auto AST = buildASTFromCode(R"cpp(
struct MyStruct { struct MyStruct {
MyStruct(); MyStruct();
MyStruct(int i) { MyStruct(int i) {
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines)cpp";
EXPECT_EQ( EXPECT_EQ(
dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func2")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func2")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
FunctionDecl 'func3' FunctionDecl 'func3'
`-CompoundStmt `-CompoundStmt
`-ReturnStmt `-ReturnStmt
`-CXXFunctionalCastExpr `-CXXConstructExpr
`-IntegerLiteral `-IntegerLiteral
)cpp"; )cpp";
EXPECT_EQ( EXPECT_EQ(
dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func3")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func3")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
FunctionDecl 'func4' FunctionDecl 'func4'
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

Show First 20 Lines • Show All 959 Lines • ▼ Show 20 Lines EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
"B b;" "B b;"
"D* p = dynamic_cast<D*>(&b);", "D* p = dynamic_cast<D*>(&b);",
cxxReinterpretCastExpr())); cxxReinterpretCastExpr()));
} }
TEST(FunctionalCast, MatchesSimpleCase) { TEST(FunctionalCast, MatchesSimpleCase) {
StringRef foo_class = "class Foo { public: Foo(const char*); };"; StringRef foo_class = "class Foo { public: Foo(const char*); };";
EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }", EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
cxxFunctionalCastExpr())); traverse(TK_AsIs, cxxFunctionalCastExpr())));
ymandelUnsubmitted
Done
ReplyInline Actions

is this necessary/desirable given that we reverted the default behavior? if so, should we update other tests (at least, others involving this matcher) as well?

ymandel: is this necessary/desirable given that we reverted the default behavior? if so, should we…
} }
TEST(FunctionalCast, DoesNotMatchOtherCasts) { TEST(FunctionalCast, DoesNotMatchOtherCasts) {
StringRef FooClass = "class Foo { public: Foo(const char*); };"; StringRef FooClass = "class Foo { public: Foo(const char*); };";
EXPECT_TRUE( EXPECT_TRUE(
notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }", notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
cxxFunctionalCastExpr())); cxxFunctionalCastExpr()));
EXPECT_TRUE( EXPECT_TRUE(
▲ Show 20 Lines • Show All 892 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 1,885 Lines • ▼ Show 20 Lines)cpp";
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_AsIs, traverse(TK_AsIs,
staticAssertDecl(has(implicitCastExpr(has( staticAssertDecl(has(implicitCastExpr(has(
substNonTypeTemplateParmExpr(has(integerLiteral()))))))))); substNonTypeTemplateParmExpr(has(integerLiteral())))))))));
EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
staticAssertDecl(has(integerLiteral()))))); staticAssertDecl(has(integerLiteral())))));
Code = R"cpp(
struct OneParamCtor {
explicit OneParamCtor(int);
};
struct TwoParamCtor {
explicit TwoParamCtor(int, int);
};
void varDeclCtors() {
{
auto var1 = OneParamCtor(5);
auto var2 = TwoParamCtor(6, 7);
}
{
OneParamCtor var3(5);
TwoParamCtor var4(6, 7);
}
int i = 0;
{
auto var5 = OneParamCtor(i);
auto var6 = TwoParamCtor(i, 7);
}
{
OneParamCtor var7(i);
TwoParamCtor var8(i, 7);
}
}
)cpp";
EXPECT_TRUE(matches(
Code,
traverse(TK_AsIs, varDecl(hasName("var1"), hasInitializer(hasDescendant(
cxxConstructExpr()))))));
EXPECT_TRUE(matches(
Code,
traverse(TK_AsIs, varDecl(hasName("var2"), hasInitializer(hasDescendant(
cxxConstructExpr()))))));
EXPECT_TRUE(matches(
Code, traverse(TK_AsIs, varDecl(hasName("var3"),
hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code, traverse(TK_AsIs, varDecl(hasName("var4"),
hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_AsIs, varDecl(hasName("var5"), hasInitializer(hasDescendant(
cxxConstructExpr()))))));
EXPECT_TRUE(matches(
Code,
traverse(TK_AsIs, varDecl(hasName("var6"), hasInitializer(hasDescendant(
cxxConstructExpr()))))));
EXPECT_TRUE(matches(
Code, traverse(TK_AsIs, varDecl(hasName("var7"),
hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code, traverse(TK_AsIs, varDecl(hasName("var8"),
hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var1"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var2"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var3"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var4"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var5"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var6"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var7"), hasInitializer(cxxConstructExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("var8"), hasInitializer(cxxConstructExpr())))));
} }
template <typename MatcherT> template <typename MatcherT>
bool matcherTemplateWithBinding(StringRef Code, const MatcherT &M) { bool matcherTemplateWithBinding(StringRef Code, const MatcherT &M) {
return matchAndVerifyResultTrue( return matchAndVerifyResultTrue(
Code, M.bind("matchedStmt"), Code, M.bind("matchedStmt"),
std::make_unique<VerifyIdIsBoundTo<ReturnStmt>>("matchedStmt", 1)); std::make_unique<VerifyIdIsBoundTo<ReturnStmt>>("matchedStmt", 1));
} }
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt( hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func2"))))))))), forFunction(functionDecl(hasName("func2"))))))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, matches(Code,
traverse( traverse(TK_IgnoreUnlessSpelledInSource,
TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func3"))), returnStmt(forFunction(functionDecl(hasName("func3"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxConstructExpr(hasArgument(
hasSourceExpression(integerLiteral(equals(42))))))), 0, integerLiteral(equals(42))))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(cxxFunctionalCastExpr(hasParent(returnStmt( hasParent(cxxConstructExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func3"))))))))), forFunction(functionDecl(hasName("func3"))))))))),
langCxx20OrLater())); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func4"))), returnStmt(forFunction(functionDecl(hasName("func4"))),
hasReturnValue(cxxTemporaryObjectExpr()))), hasReturnValue(cxxTemporaryObjectExpr()))),
▲ Show 20 Lines • Show All 1,235 Lines • Show Last 20 Lines