This is an archive of the discontinued LLVM Phabricator instance.

Differential D97095

[ASTMatchers] Fix hasUnaryOperand matcher for postfix operators
ClosedPublic

Authored by steveire on Feb 19 2021, 3:45 PM.

Details

Reviewers
aaron.ballman
njames93
Commits
rG559f3728441d: [ASTMatchers] Fix hasUnaryOperand matcher for postfix operators

Diff Detail

Event Timeline

steveire requested review of this revision.Feb 19 2021, 3:45 PM
steveire created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 19 2021, 3:45 PM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B89988: Diff 325105.Feb 19 2021, 4:24 PM
njames93 accepted this revision.Feb 20 2021, 9:51 AM
This revision is now accepted and ready to land.Feb 20 2021, 9:51 AM
Closed by commit rG559f3728441d: [ASTMatchers] Fix hasUnaryOperand matcher for postfix operators (authored by • stephenkelly). · Explain WhyFeb 20 2021, 9:54 AM
This revision was automatically updated to reflect the committed changes.
• stephenkelly added a commit: rG559f3728441d: [ASTMatchers] Fix hasUnaryOperand matcher for postfix operators.

Revision Contents

PathSize
clang/
include/
clang/
ASTMatchers/
3 lines
unittests/
ASTMatchers/
78 lines

Diff 325215

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

Show First 20 Lines • Show All 2,033 Lines • ▼ Show 20 Lines
inline Optional<UnaryOperatorKind> inline Optional<UnaryOperatorKind>
equivalentUnaryOperator(const NodeType &Node) { equivalentUnaryOperator(const NodeType &Node) {
return Node.getOpcode(); return Node.getOpcode();
} }
template <> template <>
inline Optional<UnaryOperatorKind> inline Optional<UnaryOperatorKind>
equivalentUnaryOperator<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { equivalentUnaryOperator<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) {
if (Node.getNumArgs() != 1) if (Node.getNumArgs() != 1 && Node.getOperator() != OO_PlusPlus &&
Node.getOperator() != OO_MinusMinus)
return None; return None;
switch (Node.getOperator()) { switch (Node.getOperator()) {
default: default:
return None; return None;
case OO_Plus: case OO_Plus:
return UO_Plus; return UO_Plus;
case OO_Minus: case OO_Minus:
return UO_Minus; return UO_Minus;
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 1,624 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches(
forFunction(functionDecl(hasName("opFree"))), forFunction(functionDecl(hasName("opFree"))),
hasOperatorName("!"), hasUnaryOperand(s1Expr))))); hasOperatorName("!"), hasUnaryOperand(s1Expr)))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(forFunction(functionDecl(hasName("opFree"))), cxxOperatorCallExpr(forFunction(functionDecl(hasName("opFree"))),
hasAnyOperatorName("+", "!"), hasAnyOperatorName("+", "!"),
hasUnaryOperand(s1Expr))))); hasUnaryOperand(s1Expr)))));
Code = R"cpp(
struct HasIncOperatorsMem
{
HasIncOperatorsMem& operator++();
HasIncOperatorsMem operator++(int);
};
struct HasIncOperatorsFree
{
};
HasIncOperatorsFree& operator++(HasIncOperatorsFree&);
HasIncOperatorsFree operator++(HasIncOperatorsFree&, int);
void prefixIncOperatorMem()
{
HasIncOperatorsMem s1;
++s1;
}
void prefixIncOperatorFree()
{
HasIncOperatorsFree s1;
++s1;
}
void postfixIncOperatorMem()
{
HasIncOperatorsMem s1;
s1++;
}
void postfixIncOperatorFree()
{
HasIncOperatorsFree s1;
s1++;
}
struct HasOpPlusInt
{
HasOpPlusInt& operator+(int);
};
void plusIntOperator()
{
HasOpPlusInt s1;
s1+1;
}
)cpp";
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(
forFunction(functionDecl(hasName("prefixIncOperatorMem"))),
hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(
forFunction(functionDecl(hasName("prefixIncOperatorFree"))),
hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(
forFunction(functionDecl(hasName("postfixIncOperatorMem"))),
hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));
EXPECT_TRUE(matches(
Code,
traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(
forFunction(functionDecl(hasName("postfixIncOperatorFree"))),
hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));
EXPECT_FALSE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(
forFunction(functionDecl(hasName("plusIntOperator"))),
hasOperatorName("+"), hasUnaryOperand(expr())))));
} }
TEST(Matcher, UnaryOperatorTypes) { TEST(Matcher, UnaryOperatorTypes) {
// Integration test that verifies the AST provides all unary operators in // Integration test that verifies the AST provides all unary operators in
// a way we expect. // a way we expect.
EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!")))); EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
EXPECT_TRUE( EXPECT_TRUE(
matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&")))); matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
▲ Show 20 Lines • Show All 3,752 Lines • Show Last 20 Lines