Matches expressions that match InnerMatcher after any implicit casts
are stripped off.
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
@@ -6452,6 +6452,45 @@
return false;
}
+/// Matches expressions that match InnerMatcher that are possibly wrapped in an
+/// elidable constructor.
+///
+/// In C++17 copy elidable constructors are no longer being
+/// generated in the AST as it is not permitted by the standard. They are
+/// however part of the AST in C++14 and earlier. Therefore, to write a matcher
+/// that works in all language modes, the matcher has to skip elidable
+/// constructor AST nodes if they appear in the AST. This matcher can be used to
+/// skip those elidable constructors.
+///
+/// Given
+///
+/// \code
+/// struct H {};
+/// H G();
+/// void f() {
+/// H D = G();
+/// }
+/// \endcode
+///
+/// ``varDecl(hasInitializer(any(
+/// ignoringElidableMoveConstructorCall(callExpr()),
+/// exprWithCleanups(ignoringElidableMoveConstructorCall(callExpr()))))``
+/// matches ``H D = G()``
+AST_MATCHER_P(Expr, ignoringElidableConstructorCall,
+ ast_matchers::internal::Matcher, InnerMatcher) {
+ if (const auto *CtorExpr = dyn_cast(&Node)) {
+ if (CtorExpr->isElidable()) {
+ if (const auto *MaterializeTemp =
+ dyn_cast(CtorExpr->getArg(0))) {
+ return InnerMatcher.matches(*MaterializeTemp->GetTemporaryExpr(),
+ Finder, Builder);
+ }
+ return InnerMatcher.matches(*CtorExpr, Finder, Builder);
+ }
+ }
+ return InnerMatcher.matches(Node, Finder, Builder);
+}
+
//----------------------------------------------------------------------------//
// OpenMP handling.
//----------------------------------------------------------------------------//
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
@@ -320,6 +320,7 @@
REGISTER_MATCHER(hasUnqualifiedDesugaredType);
REGISTER_MATCHER(hasValueType);
REGISTER_MATCHER(ifStmt);
+ REGISTER_MATCHER(ignoringElidableConstructorCall);
REGISTER_MATCHER(ignoringImpCasts);
REGISTER_MATCHER(ignoringImplicit);
REGISTER_MATCHER(ignoringParenCasts);
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
@@ -566,6 +566,73 @@
llvm::make_unique>("x")));
}
+TEST(Matcher, IgnoresElidableConstructors) {
+ auto matcher1 = cxxOperatorCallExpr(hasArgument(
+ 1,
+ callExpr(hasArgument(0, ignoringElidableConstructorCall(callExpr())))));
+ auto matcher2 = cxxOperatorCallExpr(
+ hasArgument(1, callExpr(hasArgument(0, ignoringElidableConstructorCall(
+ integerLiteral())))));
+ auto matcher3 = varDecl(hasInitializer(anyOf(
+ ignoringElidableConstructorCall(callExpr()),
+ exprWithCleanups(has(ignoringElidableConstructorCall(callExpr()))))));
+
+ auto code1 = "struct H {};"
+ "template H B(T A);"
+ "void f() {"
+ " H D1;"
+ " D1 = B(B(1));"
+ "}";
+ auto code2 = "struct H {};"
+ "template H B(T A);"
+ "void f() {"
+ " H D1;"
+ " D1 = B(1);"
+ "}";
+ auto code3 = "struct H {};"
+ "H G();"
+ "void f() {"
+ " H D = G();"
+ "}";
+
+ EXPECT_TRUE(matches(code1, matcher1, LanguageMode::CXX11OrLater));
+ EXPECT_TRUE(matches(code2, matcher2, LanguageMode::CXX11OrLater));
+ EXPECT_TRUE(matches(code3, matcher3, LanguageMode::CXX11OrLater));
+}
+
+TEST(Matcher, IgnoresElidableInReturn) {
+ auto matcher = expr(ignoringElidableConstructorCall(declRefExpr()));
+ EXPECT_TRUE(matches("struct H {};"
+ "H f() {"
+ " H g;"
+ " return g;"
+ "}",
+ matcher, LanguageMode::CXX11OrLater));
+ EXPECT_TRUE(notMatches("struct H {};"
+ "H f() {"
+ " return H();"
+ "}",
+ matcher, LanguageMode::CXX11OrLater));
+}
+
+TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) {
+ auto matcher = varDecl(
+ hasInitializer(ignoringElidableConstructorCall(cxxConstructExpr())));
+ EXPECT_TRUE(matches("struct H {};"
+ "void f() {"
+ " H D;"
+ "}",
+ matcher, LanguageMode::CXX11OrLater));
+};
+
+TEST(Matcher, IgnoresElidableDoesNotPreventMatches) {
+ EXPECT_TRUE(matches("void f() {"
+ " int D = 10;"
+ "}",
+ expr(ignoringElidableConstructorCall(integerLiteral())),
+ LanguageMode::CXX11OrLater));
+}
+
TEST(Matcher, BindTheSameNameInAlternatives) {
StatementMatcher matcher = anyOf(
binaryOperator(hasOperatorName("+"),
@@ -914,10 +981,10 @@
varDecl(hasName("foo"), isConstexpr())));
EXPECT_TRUE(matches("constexpr int bar();",
functionDecl(hasName("bar"), isConstexpr())));
- EXPECT_TRUE(matchesConditionally("void baz() { if constexpr(1 > 0) {} }",
- ifStmt(isConstexpr()), true, "-std=c++17"));
- EXPECT_TRUE(matchesConditionally("void baz() { if (1 > 0) {} }",
- ifStmt(isConstexpr()), false, "-std=c++17"));
+ EXPECT_TRUE(matches("void baz() { if constexpr(1 > 0) {} }",
+ ifStmt(isConstexpr()), LanguageMode::CXX17OrLater));
+ EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }", ifStmt(isConstexpr()),
+ LanguageMode::CXX17OrLater));
}
TEST(TemplateArgumentCountIs, Matches) {
diff --git a/clang/unittests/ASTMatchers/ASTMatchersTest.h b/clang/unittests/ASTMatchers/ASTMatchersTest.h
--- a/clang/unittests/ASTMatchers/ASTMatchersTest.h
+++ b/clang/unittests/ASTMatchers/ASTMatchersTest.h
@@ -57,6 +57,17 @@
const std::unique_ptr FindResultReviewer;
};
+enum class LanguageMode : int {
+ CXX11 = 0,
+ CXX14 = 1,
+ CXX17 = 2,
+ CXX20 = 3,
+ CXX11OrLater,
+ CXX14OrLater,
+ CXX17OrLater,
+ CXX20OrLater
+};
+
template
testing::AssertionResult matchesConditionally(
const std::string &Code, const T &AMatcher, bool ExpectMatch,
@@ -116,14 +127,56 @@
}
template
-testing::AssertionResult matches(const std::string &Code, const T &AMatcher) {
- return matchesConditionally(Code, AMatcher, true, "-std=c++11");
+testing::AssertionResult
+matchesConditionally(const std::string &Code, const T &AMatcher,
+ bool ExpectMatch, const LanguageMode &Mode) {
+ std::vector LangModeStrings{"-std=c++11", "-std=c++14",
+ "-std=c++17", "-std=c++20"};
+ std::vector LangModes;
+ switch (Mode) {
+ case LanguageMode::CXX11:
+ case LanguageMode::CXX14:
+ case LanguageMode::CXX17:
+ case LanguageMode::CXX20:
+ LangModes = {Mode};
+ break;
+ case LanguageMode::CXX11OrLater:
+ LangModes = {LanguageMode::CXX11, LanguageMode::CXX14, LanguageMode::CXX17, LanguageMode::CXX20};
+ break;
+ case LanguageMode::CXX14OrLater:
+ LangModes = {LanguageMode::CXX14, LanguageMode::CXX17, LanguageMode::CXX20};
+ break;
+ case LanguageMode::CXX17OrLater:
+ LangModes = {LanguageMode::CXX17, LanguageMode::CXX20};
+ break;
+ case LanguageMode::CXX20OrLater:
+ LangModes = {LanguageMode::CXX20};
+ };
+
+ for (auto Mode : LangModes) {
+ auto LangModeArg = LangModeStrings[static_cast(Mode)];
+ auto Result =
+ matchesConditionally(Code, AMatcher, ExpectMatch, LangModeArg);
+ if (!Result) {
+ return Result;
+ }
+ }
+
+ return testing::AssertionSuccess();
}
template
-testing::AssertionResult notMatches(const std::string &Code,
- const T &AMatcher) {
- return matchesConditionally(Code, AMatcher, false, "-std=c++11");
+testing::AssertionResult
+matches(const std::string &Code, const T &AMatcher,
+ const LanguageMode &Modes = LanguageMode::CXX11) {
+ return matchesConditionally(Code, AMatcher, true, Modes);
+}
+
+template
+testing::AssertionResult
+notMatches(const std::string &Code, const T &AMatcher,
+ const LanguageMode &Modes = LanguageMode::CXX11) {
+ return matchesConditionally(Code, AMatcher, false, Modes);
}
template
|