Individual matchers might not be convertible to each other's kind, but
they might still all be convertible to the target kind.
All the callers already know the target kind, so just pass it down.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@242534
91177308-0d34-0410-b5e6-
96231b3b80d8
};
static DynTypedMatcher
constructVariadic(VariadicOperator Op,
+ ast_type_traits::ASTNodeKind SupportedKind,
std::vector<DynTypedMatcher> InnerMatchers);
/// \brief Get a "true" matcher for \p NodeKind.
template <typename T> operator Matcher<T>() const {
return DynTypedMatcher::constructVariadic(
- Op, getMatchers<T>(llvm::index_sequence_for<Ps...>()))
+ Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
+ getMatchers<T>(llvm::index_sequence_for<Ps...>()))
.template unconditionalConvertTo<T>();
}
std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()),
PI(InnerMatchers.end()));
return BindableMatcher<T>(
- DynTypedMatcher::constructVariadic(DynTypedMatcher::VO_AllOf,
- std::move(DynMatchers))
+ DynTypedMatcher::constructVariadic(
+ DynTypedMatcher::VO_AllOf,
+ ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
+ std::move(DynMatchers))
.template unconditionalConvertTo<T>());
}
DynTypedMatcher DynTypedMatcher::constructVariadic(
DynTypedMatcher::VariadicOperator Op,
+ ast_type_traits::ASTNodeKind SupportedKind,
std::vector<DynTypedMatcher> InnerMatchers) {
assert(InnerMatchers.size() > 0 && "Array must not be empty.");
assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(),
- [&InnerMatchers](const DynTypedMatcher &M) {
- return InnerMatchers[0].canConvertTo(M.SupportedKind);
- }) &&
- "SupportedKind must be convertible to a common type!");
+ [SupportedKind](const DynTypedMatcher &M) {
+ return M.canConvertTo(SupportedKind);
+ }) &&
+ "InnerMatchers must be convertible to SupportedKind!");
- auto SupportedKind = InnerMatchers[0].SupportedKind;
// We must relax the restrict kind here.
// The different operators might deal differently with a mismatch.
// Make it the same as SupportedKind, since that is the broadest type we are
return llvm::None;
DynMatchers.push_back(*Inner);
}
- return DynTypedMatcher::constructVariadic(Op, DynMatchers);
+ return DynTypedMatcher::constructVariadic(Op, NodeKind, DynMatchers);
}
VariantMatcher::Payload::~Payload() {}
hasArgument(3, integerLiteral(equals(4)))))));
}
+TEST(ConstructVariadic, MismatchedTypes_Regression) {
+ EXPECT_TRUE(
+ matches("const int a = 0;",
+ internal::DynTypedMatcher::constructVariadic(
+ internal::DynTypedMatcher::VO_AnyOf,
+ ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>(),
+ {isConstQualified(), arrayType()})
+ .convertTo<QualType>()));
+}
+
TEST(DeclarationMatcher, MatchAnyOf) {
DeclarationMatcher YOrZDerivedFromX =
recordDecl(anyOf(hasName("Y"), allOf(isDerivedFrom("X"), hasName("Z"))));