Matches if the provided matcher does not match.
@@ -2980,7 +3003,7 @@
| Matcher<CXXDependentScopeMemberExpr> | hasMemberName | std::string N |
-Matches template-dependent, but known, member names
+Matches template-dependent, but known, member names.
In template declarations, dependent members are not resolved and so can
not be matched to particular named declarations.
diff --git a/clang/docs/tools/dump_ast_matchers.py b/clang/docs/tools/dump_ast_matchers.py
--- a/clang/docs/tools/dump_ast_matchers.py
+++ b/clang/docs/tools/dump_ast_matchers.py
@@ -119,8 +119,15 @@
ids[name] += 1
args = unify_arguments(args)
result_type = unify_type(result_type)
+
+ docs_result_type = esc('Matcher<%s>' % result_type);
+
+ if name == 'mapAnyOf':
+ args = "nodeMatcherFunction..."
+ docs_result_type = "unspecified"
+
matcher_html = TD_TEMPLATE % {
- 'result': esc('Matcher<%s>' % result_type),
+ 'result': docs_result_type,
'name': name,
'args': esc(args),
'comment': esc(strip_doxygen(comment)),
@@ -135,7 +142,7 @@
# exclude known narrowing matchers that also take other matchers as
# arguments.
elif ('Matcher<' not in args or
- name in ['allOf', 'anyOf', 'anything', 'unless']):
+ name in ['allOf', 'anyOf', 'anything', 'unless', 'mapAnyOf']):
dict = narrowing_matchers
lookup = result_type + name + esc(args)
else:
@@ -382,6 +389,10 @@
\)\s*{""", declaration, re.X)
if m:
template_name, result, name, args = m.groups()
+
+ if "AnyOfHelper" in args:
+ return
+
if template_name:
matcherTemplateArgs = re.findall(r'Matcher<\s*(%s)\s*>' % template_name, args)
templateArgs = re.findall(r'(?:^|[\s,<])(%s)(?:$|[\s,>])' % template_name, args)
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
@@ -847,6 +847,14 @@
TK, InnerMatcher);
}
+template
+internal::Matcher traverse(
+ TraversalKind TK,
+ const internal::AnyOfHelper...>
+ &InnerMatcher) {
+ return traverse(TK, InnerMatcher.with(anything()));
+}
+
/// Matches expressions that match InnerMatcher after any implicit AST
/// nodes are stripped off.
///
@@ -2693,6 +2701,38 @@
UnaryExprOrTypeTraitExpr>
unaryExprOrTypeTraitExpr;
+/// Matches any of the \p NodeMatchers with InnerMatchers nested within
+///
+/// Given
+/// \code
+/// if (true);
+/// for (; true; );
+/// \endcode
+/// with the matcher
+/// \code
+/// mapAnyOf(ifStmt, forStmt).with(
+/// hasCondition(cxxBoolLiteralExpr(equals(true)))
+/// ).bind("trueCond")
+/// \endcode
+/// matches the \c if and the \c for. It is equivalent to:
+/// \code
+/// auto trueCond = hasCondition(cxxBoolLiteralExpr(equals(true)));
+/// anyOf(
+/// ifStmt(trueCond).bind("trueCond"),
+/// forStmt(trueCond).bind("trueCond")
+/// );
+/// \endcode
+///
+/// The with() chain-call accepts zero or more matchers which are combined
+/// as-if with allOf() in each of the node matchers.
+/// Usable as: Any Matcher
+template
+auto mapAnyOf(
+ internal::VariadicDynCastAllOfMatcher const &... NodeMatcher) {
+ return internal::AnyOfHelper...>(
+ NodeMatcher...);
+}
+
/// Matches unary expressions that have a specific type of argument.
///
/// Given
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
@@ -1987,6 +1987,51 @@
llvm::Regex::RegexFlags Flags,
StringRef MatcherID);
+template
+constexpr auto applyMatcherImpl(F &&f, Tuple &&args,
+ std::index_sequence) {
+ return std::forward(f)(std::get(std::forward(args))...);
+}
+
+template
+constexpr auto applyMatcher(F &&f, Tuple &&args) {
+ return applyMatcherImpl(
+ std::forward(f), std::forward(args),
+ std::make_index_sequence<
+ std::tuple_size::type>::value>());
+}
+
+template struct AnyOfHelper {
+ std::tuple NodeMatchers;
+ AnyOfHelper(MatcherTypes const &... NodeMatchers)
+ : NodeMatchers(NodeMatchers...) {}
+
+ template struct GetCladeImpl;
+ template
+ struct GetCladeImpl> {
+ using Type = T;
+ };
+ template struct GetClade : GetCladeImpl {};
+ using CladeType = typename GetClade::Type;
+
+ template
+ BindableMatcher with(InnerMatchers &&... InnerMatcher) const {
+ // TODO: Use std::apply from c++17
+ return VariadicAllOfMatcher()(applyMatcher(
+ internal::VariadicOperatorMatcherFunc<
+ 0, std::numeric_limits::max()>{
+ internal::DynTypedMatcher::VO_AnyOf},
+ applyMatcher(
+ [&](auto... Matcher) {
+ return std::make_tuple(Matcher(
+ std::forward(InnerMatcher)...)...);
+ },
+ NodeMatchers)));
+ }
+
+ Matcher bind(StringRef ID) const { return with().bind(ID); }
+};
+
} // namespace internal
} // namespace ast_matchers
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
@@ -473,6 +473,59 @@
EXPECT_TRUE(matches("int F() { return 1; }", integerLiteral(anyOf())));
}
+TEST_P(ASTMatchersTest, MapAnyOf) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
+
+ StringRef Code = R"cpp(
+void F() {
+ if (true) {}
+ for ( ; false; ) {}
+}
+)cpp";
+
+ auto trueExpr = cxxBoolLiteral(equals(true));
+ auto falseExpr = cxxBoolLiteral(equals(false));
+
+ EXPECT_TRUE(matches(
+ Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(ifStmt, forStmt).with(hasCondition(trueExpr)))));
+ EXPECT_TRUE(matches(
+ Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(ifStmt, forStmt).with(hasCondition(falseExpr)))));
+
+ Code = R"cpp(
+void func(bool b) {}
+struct S {
+ S(bool b) {}
+};
+void F() {
+ func(false);
+ S s(true);
+}
+)cpp";
+ EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(callExpr, cxxConstructExpr)
+ .with(hasArgument(0, trueExpr)))));
+ EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(callExpr, cxxConstructExpr)
+ .with(hasArgument(0, falseExpr)))));
+
+ EXPECT_TRUE(
+ matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(callExpr, cxxConstructExpr)
+ .with(hasArgument(0, expr()),
+ hasDeclaration(functionDecl())))));
+
+ EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(callExpr, cxxConstructExpr))));
+
+ EXPECT_TRUE(matches(
+ Code, traverse(TK_IgnoreUnlessSpelledInSource,
+ mapAnyOf(callExpr, cxxConstructExpr).bind("call"))));
+}
+
TEST_P(ASTMatchersTest, IsDerivedFrom) {
if (!GetParam().isCXX()) {
return;
| | |