This is an archive of the discontinued LLVM Phabricator instance.

Differential D104389

[ASTMatchers] Fix bug in `hasUnaryOperand`
ClosedPublic

Authored by ymandel on Jun 16 2021, 8:21 AM.

Details

Reviewers
gribozavr2
Commits
rG439c9206945a: [ASTMatchers] Fix bug in `hasUnaryOperand`
Summary

Currently, hasUnaryOperand fails for the overloaded operator*. This patch fixes the bug and
adds tests for this case.

Diff Detail

Event Timeline

ymandel requested review of this revision.Jun 16 2021, 8:21 AM
ymandel created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptJun 16 2021, 8:21 AM
ymandel added a child revision: D104390: [libTooling] Change `access` stencil to recognize use of `operator*`..Jun 16 2021, 8:37 AM
gribozavr2 accepted this revision.Jun 16 2021, 11:25 AM
This revision is now accepted and ready to land.Jun 16 2021, 11:25 AM
This revision was landed with ongoing or failed builds.Jun 16 2021, 1:19 PM
Closed by commit rG439c9206945a: [ASTMatchers] Fix bug in `hasUnaryOperand` (authored by ymandel). · Explain Why
This revision was automatically updated to reflect the committed changes.
ymandel added a commit: rG439c9206945a: [ASTMatchers] Fix bug in `hasUnaryOperand`.
Harbormaster completed remote builds in B109522: Diff 352447.Jun 16 2021, 6:19 PM

Revision Contents

PathSize
clang/
include/
clang/
ASTMatchers/
2 lines
unittests/
ASTMatchers/
17 lines

Diff 352534

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

Show First 20 Lines • Show All 2,096 Lines • ▼ Show 20 LinesequivalentUnaryOperator<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) {
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;
case OO_Amp: case OO_Amp:
return UO_AddrOf; return UO_AddrOf;
case OO_Star:
return UO_Deref;
case OO_Tilde: case OO_Tilde:
return UO_Not; return UO_Not;
case OO_Exclaim: case OO_Exclaim:
return UO_LNot; return UO_LNot;
case OO_PlusPlus: { case OO_PlusPlus: {
const auto *FD = Node.getDirectCallee(); const auto *FD = Node.getDirectCallee();
if (!FD) if (!FD)
return None; return None;
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 1,887 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches(
forFunction(functionDecl(hasName("postfixIncOperatorFree"))), forFunction(functionDecl(hasName("postfixIncOperatorFree"))),
hasOperatorName("++"), hasUnaryOperand(declRefExpr()))))); hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));
EXPECT_FALSE(matches( EXPECT_FALSE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr( cxxOperatorCallExpr(
forFunction(functionDecl(hasName("plusIntOperator"))), forFunction(functionDecl(hasName("plusIntOperator"))),
hasOperatorName("+"), hasUnaryOperand(expr()))))); hasOperatorName("+"), hasUnaryOperand(expr())))));
Code = R"cpp(
struct HasOpArrow
{
int& operator*();
};
void foo()
{
HasOpArrow s1;
*s1;
}
)cpp";
EXPECT_TRUE(
matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
cxxOperatorCallExpr(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,829 Lines • Show Last 20 Lines