public:
enum Kind {
AK_Matcher,
+ AK_Node,
AK_Boolean,
AK_Double,
AK_Unsigned,
return ArgKind{AK_Matcher, MatcherKind};
}
+ static ArgKind MakeNodeArg(ASTNodeKind MatcherKind) {
+ return ArgKind{AK_Node, MatcherKind};
+ }
+
Kind getArgKind() const { return K; }
ASTNodeKind getMatcherKind() const {
assert(K == AK_Matcher);
return NodeKind;
}
+ ASTNodeKind getNodeKind() const {
+ assert(K == AK_Node);
+ return NodeKind;
+ }
/// Determines if this type can be converted to \p To.
///
bool isConvertibleTo(ArgKind To, unsigned *Specificity) const;
bool operator<(const ArgKind &Other) const {
- if (K == AK_Matcher && Other.K == AK_Matcher)
+ if ((K == AK_Matcher && Other.K == AK_Matcher) ||
+ (K == AK_Node && Other.K == AK_Node))
return NodeKind < Other.NodeKind;
return K < Other.K;
}
switch (getArgKind()) {
case AK_Matcher:
return (Twine("Matcher<") + NodeKind.asStringRef() + ">").str();
+ case AK_Node:
+ return NodeKind.asStringRef().str();
case AK_Boolean:
return "boolean";
case AK_Double:
bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const {
if (K != To.K)
return false;
- if (K != AK_Matcher) {
+ if (K != AK_Matcher && K != AK_Node) {
if (Specificity)
*Specificity = 1;
return true;
*Specificity = 1;
return true;
+ case ArgKind::AK_Node:
+ if (!isNodeKind())
+ return false;
+ return getMatcher().isConvertibleTo(Kind.getNodeKind(), Specificity);
+
case ArgKind::AK_Matcher:
if (!isMatcher())
return false;