Matches operator expressions (binary or unary) that have any of the
+| Matcher<UnaryOperator> | hasAnyOperatorName | StringRef, ..., StringRef |
+Matches operator expressions (binary or unary) that have any of the
specified names.
hasAnyOperatorName("+", "-")
@@ -5184,8 +5286,8 @@
|
-| Matcher<UnaryOperator> | hasOperatorName | std::string Name |
-Matches the operator Name of operator expressions (binary or
+| Matcher<UnaryOperator> | hasOperatorName | std::string Name |
+Matches the operator Name of operator expressions (binary or
unary).
Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
@@ -5446,13 +5548,16 @@
The code
var1 != var2;
-might be represented in the clang AST as a binaryOperator or a
-cxxOperatorCallExpr, depending on
+might be represented in the clang AST as a binaryOperator, a
+cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on
* whether the types of var1 and var2 are fundamental (binaryOperator) or at
least one is a class type (cxxOperatorCallExpr)
* whether the code appears in a template declaration, if at least one of the
vars is a dependent-type (binaryOperator)
+* whether the code relies on a rewritten binary operator, such as a
+spaceship operator or an inverted equality operator
+(cxxRewrittenBinaryOperator)
This matcher elides details in places where the matchers for the nodes are
compatible.
@@ -5480,6 +5585,31 @@
1 != 2;
T() != S();
}
+ struct HasOpEq
+ {
+ bool operator==(const HasOpEq &) const;
+ };
+
+ void inverse()
+ {
+ HasOpEq s1;
+ HasOpEq s2;
+ if (s1 != s2)
+ return;
+ }
+
+ struct HasSpaceship
+ {
+ bool operator<=>(const HasOpEq &) const;
+ };
+
+ void use_spaceship()
+ {
+ HasSpaceship s1;
+ HasSpaceship s2;
+ if (s1 != s2)
+ return;
+ }
|
@@ -5753,16 +5883,16 @@
|
-| Matcher<ArraySubscriptExpr> | hasLHS | Matcher<Expr> InnerMatcher |
-Matches the left hand side of binary operator expressions.
+| Matcher<ArraySubscriptExpr> | hasLHS | Matcher<Expr> InnerMatcher |
+Matches the left hand side of binary operator expressions.
Example matches a (matcher = binaryOperator(hasLHS()))
a || b
|
-| Matcher<ArraySubscriptExpr> | hasRHS | Matcher<Expr> InnerMatcher |
-Matches the right hand side of binary operator expressions.
+| Matcher<ArraySubscriptExpr> | hasRHS | Matcher<Expr> InnerMatcher |
+Matches the right hand side of binary operator expressions.
Example matches b (matcher = binaryOperator(hasRHS()))
a || b
@@ -6480,6 +6610,40 @@
|
+| Matcher<CXXRewrittenBinaryOperator> | hasEitherOperand | Matcher<Expr> InnerMatcher |
+Matches if either the left hand side or the right hand side of a
+binary operator matches.
+ |
+
+
+| Matcher<CXXRewrittenBinaryOperator> | hasLHS | Matcher<Expr> InnerMatcher |
+Matches the left hand side of binary operator expressions.
+
+Example matches a (matcher = binaryOperator(hasLHS()))
+ a || b
+ |
+
+
+| Matcher<CXXRewrittenBinaryOperator> | hasOperands | Matcher<Expr> Matcher1, Matcher<Expr> Matcher2 |
+Matches if both matchers match with opposite sides of the binary operator.
+
+Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
+ integerLiteral(equals(2)))
+ 1 + 2 // Match
+ 2 + 1 // Match
+ 1 + 1 // No match
+ 2 + 2 // No match
+ |
+
+
+| Matcher<CXXRewrittenBinaryOperator> | hasRHS | Matcher<Expr> InnerMatcher |
+Matches the right hand side of binary operator expressions.
+
+Example matches b (matcher = binaryOperator(hasRHS()))
+ a || b
+ |
+
+
| Matcher<CXXUnresolvedConstructExpr> | hasAnyArgument | Matcher<Expr> InnerMatcher |
Matches any argument of a call expression or a constructor call
expression, or an ObjC-message-send expression.
diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h
--- a/clang/include/clang/AST/ASTNodeTraverser.h
+++ b/clang/include/clang/AST/ASTNodeTraverser.h
@@ -145,7 +145,8 @@
return;
if (Traversal == TK_IgnoreUnlessSpelledInSource &&
- isa(S))
+ isa(S))
return;
for (const Stmt *SubStmt : S->children())
@@ -746,6 +747,15 @@
}
}
+ void VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *Node) {
+ if (Traversal == TK_IgnoreUnlessSpelledInSource) {
+ Visit(Node->getLHS());
+ Visit(Node->getRHS());
+ } else {
+ ConstStmtVisitor::VisitCXXRewrittenBinaryOperator(Node);
+ }
+ }
+
void VisitExpressionTemplateArgument(const TemplateArgument &TA) {
Visit(TA.getAsExpr());
}
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -320,6 +320,16 @@
bool isReversed() const { return CXXRewrittenBinaryOperatorBits.IsReversed; }
BinaryOperatorKind getOperator() const { return getDecomposedForm().Opcode; }
+ BinaryOperatorKind getOpcode() const { return getOperator(); }
+ static StringRef getOpcodeStr(BinaryOperatorKind Op) {
+ return BinaryOperator::getOpcodeStr(Op);
+ }
+ StringRef getOpcodeStr() const {
+ return BinaryOperator::getOpcodeStr(getOpcode());
+ }
+ bool isComparisonOp() const { return true; }
+ bool isAssignmentOp() const { return false; }
+
const Expr *getLHS() const { return getDecomposedForm().LHS; }
const Expr *getRHS() const { return getDecomposedForm().RHS; }
diff --git a/clang/include/clang/ASTMatchers/ASTMatchers.h b/clang/include/clang/ASTMatchers/ASTMatchers.h
--- a/clang/include/clang/ASTMatchers/ASTMatchers.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchers.h
@@ -1976,6 +1976,27 @@
extern const internal::VariadicDynCastAllOfMatcher
cxxOperatorCallExpr;
+/// Matches rewritten binary operators
+///
+/// Example matches use of "<":
+/// \code
+/// #include
+/// struct HasSpaceshipMem {
+/// int a;
+/// constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
+/// };
+/// void compare() {
+/// HasSpaceshipMem hs1, hs2;
+/// if (hs1 < hs2)
+/// return;
+/// }
+/// \endcode
+/// See also the binaryOperation() matcher for more-general matching
+/// of this AST node.
+extern const internal::VariadicDynCastAllOfMatcher
+ cxxRewrittenBinaryOperator;
+
/// Matches expressions.
///
/// Example matches x()
@@ -2738,13 +2759,16 @@
/// \code
/// var1 != var2;
/// \endcode
-/// might be represented in the clang AST as a binaryOperator or a
-/// cxxOperatorCallExpr, depending on
+/// might be represented in the clang AST as a binaryOperator, a
+/// cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on
///
/// * whether the types of var1 and var2 are fundamental (binaryOperator) or at
/// least one is a class type (cxxOperatorCallExpr)
/// * whether the code appears in a template declaration, if at least one of the
/// vars is a dependent-type (binaryOperator)
+/// * whether the code relies on a rewritten binary operator, such as a
+/// spaceship operator or an inverted equality operator
+/// (cxxRewrittenBinaryOperator)
///
/// This matcher elides details in places where the matchers for the nodes are
/// compatible.
@@ -2775,8 +2799,34 @@
/// 1 != 2;
/// T() != S();
/// }
+/// struct HasOpEq
+/// {
+/// bool operator==(const HasOpEq &) const;
+/// };
+///
+/// void inverse()
+/// {
+/// HasOpEq s1;
+/// HasOpEq s2;
+/// if (s1 != s2)
+/// return;
+/// }
+///
+/// struct HasSpaceship
+/// {
+/// bool operator<=>(const HasOpEq &) const;
+/// };
+///
+/// void use_spaceship()
+/// {
+/// HasSpaceship s1;
+/// HasSpaceship s2;
+/// if (s1 != s2)
+/// return;
+/// }
/// \endcode
-extern const internal::MapAnyOfMatcher
+extern const internal::MapAnyOfMatcher
binaryOperation;
/// Matches unary expressions that have a specific type of argument.
@@ -5245,11 +5295,11 @@
/// \code
/// !(a || b)
/// \endcode
-AST_POLYMORPHIC_MATCHER_P(hasOperatorName,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr,
- UnaryOperator),
- std::string, Name) {
+AST_POLYMORPHIC_MATCHER_P(
+ hasOperatorName,
+ AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator, UnaryOperator),
+ std::string, Name) {
if (Optional OpName = internal::getOpName(Node))
return *OpName == Name;
return false;
@@ -5265,6 +5315,7 @@
internal::PolymorphicMatcherWithParam1<
internal::HasAnyOperatorNameMatcher, std::vector,
AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator,
UnaryOperator)>,
StringRef, internal::hasAnyOperatorNameFunc>
hasAnyOperatorName;
@@ -5283,9 +5334,10 @@
/// struct S { S& operator=(const S&); };
/// void x() { S s1, s2; s1 = s2; }
/// \endcode
-AST_POLYMORPHIC_MATCHER(isAssignmentOperator,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr)) {
+AST_POLYMORPHIC_MATCHER(
+ isAssignmentOperator,
+ AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator)) {
return Node.isAssignmentOp();
}
@@ -5303,9 +5355,10 @@
/// struct S { bool operator<(const S& other); };
/// void x(S s1, S s2) { bool b1 = s1 < s2; }
/// \endcode
-AST_POLYMORPHIC_MATCHER(isComparisonOperator,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr)) {
+AST_POLYMORPHIC_MATCHER(
+ isComparisonOperator,
+ AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator)) {
return Node.isComparisonOp();
}
@@ -5316,9 +5369,9 @@
/// a || b
/// \endcode
AST_POLYMORPHIC_MATCHER_P(hasLHS,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr,
- ArraySubscriptExpr),
+ AST_POLYMORPHIC_SUPPORTED_TYPES(
+ BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator, ArraySubscriptExpr),
internal::Matcher, InnerMatcher) {
const Expr *LeftHandSide = internal::getLHS(Node);
return (LeftHandSide != nullptr &&
@@ -5332,9 +5385,9 @@
/// a || b
/// \endcode
AST_POLYMORPHIC_MATCHER_P(hasRHS,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr,
- ArraySubscriptExpr),
+ AST_POLYMORPHIC_SUPPORTED_TYPES(
+ BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator, ArraySubscriptExpr),
internal::Matcher, InnerMatcher) {
const Expr *RightHandSide = internal::getRHS(Node);
return (RightHandSide != nullptr &&
@@ -5343,10 +5396,11 @@
/// Matches if either the left hand side or the right hand side of a
/// binary operator matches.
-AST_POLYMORPHIC_MATCHER_P(hasEitherOperand,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr),
- internal::Matcher, InnerMatcher) {
+AST_POLYMORPHIC_MATCHER_P(
+ hasEitherOperand,
+ AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator),
+ internal::Matcher, InnerMatcher) {
return internal::VariadicDynCastAllOfMatcher()(
anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)))
.matches(Node, Finder, Builder);
@@ -5362,11 +5416,11 @@
/// 1 + 1 // No match
/// 2 + 2 // No match
/// \endcode
-AST_POLYMORPHIC_MATCHER_P2(hasOperands,
- AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator,
- CXXOperatorCallExpr),
- internal::Matcher, Matcher1,
- internal::Matcher, Matcher2) {
+AST_POLYMORPHIC_MATCHER_P2(
+ hasOperands,
+ AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
+ CXXRewrittenBinaryOperator),
+ internal::Matcher, Matcher1, internal::Matcher, Matcher2) {
return internal::VariadicDynCastAllOfMatcher()(
anyOf(allOf(hasLHS(Matcher1), hasRHS(Matcher2)),
allOf(hasLHS(Matcher2), hasRHS(Matcher1))))
diff --git a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
--- a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
@@ -2089,6 +2089,9 @@
inline Optional getOpName(const BinaryOperator &Node) {
return Node.getOpcodeStr();
}
+inline StringRef getOpName(const CXXRewrittenBinaryOperator &Node) {
+ return Node.getOpcodeStr();
+}
inline Optional getOpName(const CXXOperatorCallExpr &Node) {
auto optBinaryOpcode = equivalentBinaryOperator(Node);
if (!optBinaryOpcode) {
@@ -2108,9 +2111,10 @@
class HasAnyOperatorNameMatcher : public SingleNodeMatcherInterface {
static_assert(std::is_same::value ||
std::is_same::value ||
+ std::is_same::value ||
std::is_same::value,
- "Matcher only supports `BinaryOperator`, `UnaryOperator` and "
- "`CXXOperatorCallExpr`");
+ "Matcher only supports `BinaryOperator`, `UnaryOperator`, "
+ "`CXXOperatorCallExpr` and `CXXRewrittenBinaryOperator`");
static_assert(std::is_same>::value,
"Matcher ArgT must be std::vector");
@@ -2128,12 +2132,33 @@
}
private:
+ static Optional getOpName(const UnaryOperator &Node) {
+ return Node.getOpcodeStr(Node.getOpcode());
+ }
+ static Optional getOpName(const BinaryOperator &Node) {
+ return Node.getOpcodeStr();
+ }
+ static StringRef getOpName(const CXXRewrittenBinaryOperator &Node) {
+ return Node.getOpcodeStr();
+ }
+ static Optional getOpName(const CXXOperatorCallExpr &Node) {
+ auto optBinaryOpcode = equivalentBinaryOperator(Node);
+ if (!optBinaryOpcode) {
+ auto optUnaryOpcode = equivalentUnaryOperator(Node);
+ if (!optUnaryOpcode)
+ return None;
+ return UnaryOperator::getOpcodeStr(*optUnaryOpcode);
+ }
+ return BinaryOperator::getOpcodeStr(*optBinaryOpcode);
+ }
+
const std::vector Names;
};
using HasOpNameMatcher = PolymorphicMatcherWithParam1<
HasAnyOperatorNameMatcher, std::vector,
- void(TypeList)>;
+ void(TypeList)>;
HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef NameRefs);
diff --git a/clang/lib/ASTMatchers/ASTMatchFinder.cpp b/clang/lib/ASTMatchers/ASTMatchFinder.cpp
--- a/clang/lib/ASTMatchers/ASTMatchFinder.cpp
+++ b/clang/lib/ASTMatchers/ASTMatchFinder.cpp
@@ -250,6 +250,18 @@
return false;
return VisitorBase::TraverseStmt(Node->getBody());
}
+ bool TraverseCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *Node) {
+ if (!Finder->isTraversalIgnoringImplicitNodes())
+ return VisitorBase::TraverseCXXRewrittenBinaryOperator(Node);
+ if (!Node)
+ return true;
+ ScopedIncrement ScopedDepth(&CurrentDepth);
+
+ if (!match(*Node->getDecomposedForm().LHS) ||
+ !match(*Node->getDecomposedForm().RHS))
+ return false;
+ return true;
+ }
bool TraverseLambdaExpr(LambdaExpr *Node) {
if (!Finder->isTraversalIgnoringImplicitNodes())
return VisitorBase::TraverseLambdaExpr(Node);
@@ -489,6 +501,19 @@
}
}
return true;
+ } else if (auto *RBO = dyn_cast(S)) {
+ {
+ ASTNodeNotAsIsSourceScope RAII(this, true);
+ TraverseStmt(const_cast(RBO->getLHS()));
+ TraverseStmt(const_cast(RBO->getRHS()));
+ }
+ {
+ ASTNodeNotSpelledInSourceScope RAII(this, true);
+ for (auto *SubStmt : RBO->children()) {
+ TraverseStmt(SubStmt);
+ }
+ }
+ return true;
} else if (auto *LE = dyn_cast(S)) {
for (auto I : llvm::zip(LE->captures(), LE->capture_inits())) {
auto C = std::get<0>(I);
diff --git a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
--- a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
+++ b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
@@ -868,6 +868,8 @@
cxxDefaultArgExpr;
const internal::VariadicDynCastAllOfMatcher
cxxOperatorCallExpr;
+const internal::VariadicDynCastAllOfMatcher
+ cxxRewrittenBinaryOperator;
const internal::VariadicDynCastAllOfMatcher expr;
const internal::VariadicDynCastAllOfMatcher declRefExpr;
const internal::VariadicDynCastAllOfMatcher objcIvarRefExpr;
@@ -919,7 +921,8 @@
const internal::VariadicDynCastAllOfMatcher stmtExpr;
const internal::VariadicDynCastAllOfMatcher
binaryOperator;
-const internal::MapAnyOfMatcher
+const internal::MapAnyOfMatcher
binaryOperation;
const internal::VariadicDynCastAllOfMatcher unaryOperator;
const internal::VariadicDynCastAllOfMatcher
diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
--- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
@@ -192,6 +192,7 @@
REGISTER_MATCHER(cxxOperatorCallExpr);
REGISTER_MATCHER(cxxRecordDecl);
REGISTER_MATCHER(cxxReinterpretCastExpr);
+ REGISTER_MATCHER(cxxRewrittenBinaryOperator);
REGISTER_MATCHER(cxxStaticCastExpr);
REGISTER_MATCHER(cxxStdInitializerListExpr);
REGISTER_MATCHER(cxxTemporaryObjectExpr);
diff --git a/clang/unittests/AST/ASTTraverserTest.cpp b/clang/unittests/AST/ASTTraverserTest.cpp
--- a/clang/unittests/AST/ASTTraverserTest.cpp
+++ b/clang/unittests/AST/ASTTraverserTest.cpp
@@ -1733,4 +1733,64 @@
}
}
+TEST(Traverse, CXXRewrittenBinaryOperator) {
+
+ auto AST = buildASTFromCodeWithArgs(R"cpp(
+namespace std {
+struct strong_ordering {
+ int n;
+ constexpr operator int() const { return n; }
+ static const strong_ordering equal, greater, less;
+};
+constexpr strong_ordering strong_ordering::equal = {0};
+constexpr strong_ordering strong_ordering::greater = {1};
+constexpr strong_ordering strong_ordering::less = {-1};
+}
+
+struct HasSpaceshipMem {
+ int a;
+ constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
+};
+
+void binop()
+{
+ HasSpaceshipMem hs1, hs2;
+ if (hs1 < hs2)
+ return;
+}
+)cpp",
+ {"-std=c++20"});
+ {
+ auto BN = ast_matchers::match(cxxRewrittenBinaryOperator().bind("binop"),
+ AST->getASTContext());
+ EXPECT_EQ(BN.size(), 1u);
+
+ EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs("binop")),
+ R"cpp(
+CXXRewrittenBinaryOperator
+`-BinaryOperator
+ |-ImplicitCastExpr
+ | `-CXXMemberCallExpr
+ | `-MemberExpr
+ | `-ImplicitCastExpr
+ | `-MaterializeTemporaryExpr
+ | `-CXXOperatorCallExpr
+ | |-ImplicitCastExpr
+ | | `-DeclRefExpr 'operator<=>'
+ | |-ImplicitCastExpr
+ | | `-DeclRefExpr 'hs1'
+ | `-ImplicitCastExpr
+ | `-DeclRefExpr 'hs2'
+ `-IntegerLiteral
+)cpp");
+ EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
+ BN[0].getNodeAs("binop")),
+ R"cpp(
+CXXRewrittenBinaryOperator
+|-DeclRefExpr 'hs1'
+`-DeclRefExpr 'hs2'
+)cpp");
+ }
+}
+
} // namespace clang
diff --git a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
@@ -714,6 +714,65 @@
hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
hasRHS(declRefExpr(to(varDecl(hasName("s2")))))))));
+ Code = R"cpp(
+struct HasOpEq
+{
+ bool operator==(const HasOpEq &) const;
+};
+
+void inverse()
+{
+ HasOpEq s1;
+ HasOpEq s2;
+ if (s1 != s2)
+ return;
+}
+
+namespace std {
+struct strong_ordering {
+ int n;
+ constexpr operator int() const { return n; }
+ static const strong_ordering equal, greater, less;
+};
+constexpr strong_ordering strong_ordering::equal = {0};
+constexpr strong_ordering strong_ordering::greater = {1};
+constexpr strong_ordering strong_ordering::less = {-1};
+}
+
+struct HasSpaceshipMem {
+ int a;
+ constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
+};
+
+void rewritten()
+{
+ HasSpaceshipMem s1;
+ HasSpaceshipMem s2;
+ if (s1 != s2)
+ return;
+}
+)cpp";
+
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(hasOperatorName("!="),
+ forFunction(functionDecl(hasName("inverse"))),
+ hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("s2"))))))),
+ true, {"-std=c++20"}));
+
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(hasOperatorName("!="),
+ forFunction(functionDecl(hasName("rewritten"))),
+ hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("s2"))))))),
+ true, {"-std=c++20"}));
+
Code = R"cpp(
struct HasOpBangMem
{
diff --git a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
@@ -3330,6 +3330,527 @@
EXPECT_TRUE(matches(Code, traverse(TK_AsIs, lambdaImplicitCapture)));
EXPECT_FALSE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, lambdaImplicitCapture)));
+
+ Code = R"cpp(
+struct S {};
+
+struct HasOpEq
+{
+ bool operator==(const S& other)
+ {
+ return true;
+ }
+};
+
+void binop()
+{
+ HasOpEq s1;
+ S s2;
+ if (s1 != s2)
+ return;
+}
+)cpp";
+ {
+ auto M = unaryOperator(
+ hasOperatorName("!"),
+ has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = declRefExpr(to(varDecl(hasName("s1"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxOperatorCallExpr(hasOverloadedOperatorName("=="));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxOperatorCallExpr(hasOverloadedOperatorName("!="));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ auto withDescendants = [](StringRef lName, StringRef rName) {
+ return stmt(hasDescendant(declRefExpr(to(varDecl(hasName(lName))))),
+ hasDescendant(declRefExpr(to(varDecl(hasName(rName))))));
+ };
+ {
+ auto M = cxxRewrittenBinaryOperator(withDescendants("s1", "s2"));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxRewrittenBinaryOperator(
+ has(declRefExpr(to(varDecl(hasName("s1"))))),
+ has(declRefExpr(to(varDecl(hasName("s2"))))));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s1")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s2")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s2")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s1"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("s2")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("s2"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("s2"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("s1")))),
+ declRefExpr(to(varDecl(hasName("s2"))))))),
+ true, {"-std=c++20"}));
+ }
+
+ Code = R"cpp(
+namespace std {
+struct strong_ordering {
+ int n;
+ constexpr operator int() const { return n; }
+ static const strong_ordering equal, greater, less;
+};
+constexpr strong_ordering strong_ordering::equal = {0};
+constexpr strong_ordering strong_ordering::greater = {1};
+constexpr strong_ordering strong_ordering::less = {-1};
+}
+
+struct HasSpaceshipMem {
+ int a;
+ constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
+};
+
+void binop()
+{
+ HasSpaceshipMem hs1, hs2;
+ if (hs1 == hs2)
+ return;
+
+ HasSpaceshipMem hs3, hs4;
+ if (hs3 != hs4)
+ return;
+
+ HasSpaceshipMem hs5, hs6;
+ if (hs5 < hs6)
+ return;
+
+ HasSpaceshipMem hs7, hs8;
+ if (hs7 > hs8)
+ return;
+
+ HasSpaceshipMem hs9, hs10;
+ if (hs9 <= hs10)
+ return;
+
+ HasSpaceshipMem hs11, hs12;
+ if (hs11 >= hs12)
+ return;
+}
+)cpp";
+ auto withArgs = [](StringRef lName, StringRef rName) {
+ return cxxOperatorCallExpr(
+ hasArgument(0, declRefExpr(to(varDecl(hasName(lName))))),
+ hasArgument(1, declRefExpr(to(varDecl(hasName(rName))))));
+ };
+ {
+ auto M = ifStmt(hasCondition(cxxOperatorCallExpr(
+ hasOverloadedOperatorName("=="), withArgs("hs1", "hs2"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M =
+ unaryOperator(hasOperatorName("!"),
+ has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="),
+ withArgs("hs3", "hs4"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M =
+ unaryOperator(hasOperatorName("!"),
+ has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="),
+ withArgs("hs3", "hs4"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = binaryOperator(
+ hasOperatorName("<"),
+ hasLHS(hasDescendant(cxxOperatorCallExpr(
+ hasOverloadedOperatorName("<=>"), withArgs("hs5", "hs6")))),
+ hasRHS(integerLiteral(equals(0))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxRewrittenBinaryOperator(withDescendants("hs3", "hs4"));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = declRefExpr(to(varDecl(hasName("hs3"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxRewrittenBinaryOperator(has(
+ unaryOperator(hasOperatorName("!"), withDescendants("hs3", "hs4"))));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ auto M = cxxRewrittenBinaryOperator(
+ has(declRefExpr(to(varDecl(hasName("hs3"))))),
+ has(declRefExpr(to(varDecl(hasName("hs4"))))));
+ EXPECT_FALSE(
+ matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
+ EXPECT_TRUE(
+ matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs3")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs4")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs3")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs3"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("hs4")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("hs3"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("hs4"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("hs3"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("hs3")))),
+ declRefExpr(to(varDecl(hasName("hs4"))))))),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("<"), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs5")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs6")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs5")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs5"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("hs6")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("<"), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("hs5"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("hs6"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("hs5"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("hs5")))),
+ declRefExpr(to(varDecl(hasName("hs6"))))))),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName(">"), hasAnyOperatorName("<", ">"),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs7")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs8")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs7")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs7"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("hs8")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName(">"), hasAnyOperatorName("<", ">"),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("hs7"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("hs8"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("hs7"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("hs7")))),
+ declRefExpr(to(varDecl(hasName("hs8"))))))),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("<="), hasAnyOperatorName("<", "<="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs9")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs10")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs9")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs9"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("hs10")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName("<="), hasAnyOperatorName("<", "<="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("hs9"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("hs10"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("hs9"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("hs9")))),
+ declRefExpr(to(varDecl(hasName("hs10"))))))),
+ true, {"-std=c++20"}));
+ }
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName(">="), hasAnyOperatorName("<", ">="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs11")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs12")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs11")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("hs11"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("hs12")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ cxxRewrittenBinaryOperator(
+ hasOperatorName(">="), hasAnyOperatorName("<", ">="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("hs11"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("hs12"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("hs11"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("hs11")))),
+ declRefExpr(to(varDecl(hasName("hs12"))))))),
+ true, {"-std=c++20"}));
+ }
+
+ Code = R"cpp(
+struct S {};
+
+struct HasOpEq
+{
+ bool operator==(const S& other) const
+ {
+ return true;
+ }
+};
+
+struct HasOpEqMem {
+ bool operator==(const HasOpEqMem&) const { return true; }
+};
+
+struct HasOpEqFree {
+};
+bool operator==(const HasOpEqFree&, const HasOpEqFree&) { return true; }
+
+void binop()
+{
+ {
+ HasOpEq s1;
+ S s2;
+ if (s1 != s2)
+ return;
+ }
+
+ {
+ int i1;
+ int i2;
+ if (i1 != i2)
+ return;
+ }
+
+ {
+ HasOpEqMem M1;
+ HasOpEqMem M2;
+ if (M1 == M2)
+ return;
+ }
+
+ {
+ HasOpEqFree F1;
+ HasOpEqFree F2;
+ if (F1 == F2)
+ return;
+ }
+}
+)cpp";
+ {
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs,
+ binaryOperation(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s1")))))),
+ hasRHS(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s2")))))),
+ hasEitherOperand(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s2")))))),
+ hasOperands(ignoringImplicit(
+ declRefExpr(to(varDecl(hasName("s1"))))),
+ ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("s2")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs, binaryOperation(hasOperatorName("!="),
+ hasLHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("i1")))))),
+ hasRHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("i2")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs, binaryOperation(hasOperatorName("=="),
+ hasLHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("M1")))))),
+ hasRHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("M2")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_AsIs, binaryOperation(hasOperatorName("=="),
+ hasLHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("F1")))))),
+ hasRHS(ignoringImplicit(declRefExpr(
+ to(varDecl(hasName("F2")))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(
+ hasOperatorName("!="), hasAnyOperatorName("<", "!="),
+ isComparisonOperator(),
+ hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("s2"))))),
+ hasEitherOperand(declRefExpr(to(varDecl(hasName("s2"))))),
+ hasOperands(declRefExpr(to(varDecl(hasName("s1")))),
+ declRefExpr(to(varDecl(hasName("s2"))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(hasOperatorName("!="),
+ hasLHS(declRefExpr(to(varDecl(hasName("i1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("i2"))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(hasOperatorName("=="),
+ hasLHS(declRefExpr(to(varDecl(hasName("M1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("M2"))))))),
+ true, {"-std=c++20"}));
+ EXPECT_TRUE(matchesConditionally(
+ Code,
+ traverse(
+ TK_IgnoreUnlessSpelledInSource,
+ binaryOperation(hasOperatorName("=="),
+ hasLHS(declRefExpr(to(varDecl(hasName("F1"))))),
+ hasRHS(declRefExpr(to(varDecl(hasName("F2"))))))),
+ true, {"-std=c++20"}));
+ }
}
TEST(IgnoringImpCasts, MatchesImpCasts) {
| | | |