1 //===--- VariantValue.cpp - Polymorphic value type -*- C++ -*-===/
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief Polymorphic value type.
13 //===----------------------------------------------------------------------===//
15 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
16 #include "clang/Basic/LLVM.h"
17 #include "llvm/ADT/STLExtras.h"
20 namespace ast_matchers {
23 std::string ArgKind::asString() const {
24 switch (getArgKind()) {
26 return (Twine("Matcher<") + MatcherKind.asStringRef() + ">").str();
32 llvm_unreachable("unhandled ArgKind");
35 bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const {
38 if (K != AK_Matcher) {
44 if (!MatcherKind.isBaseOf(To.MatcherKind, &Distance))
48 *Specificity = 100 - Distance;
53 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
54 bool &IsExactMatch) const {
55 IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
56 return Matcher.canConvertTo(NodeKind);
59 llvm::Optional<DynTypedMatcher>
60 VariantMatcher::MatcherOps::constructVariadicOperator(
61 DynTypedMatcher::VariadicOperator Op,
62 ArrayRef<VariantMatcher> InnerMatchers) const {
63 std::vector<DynTypedMatcher> DynMatchers;
64 for (const auto &InnerMatcher : InnerMatchers) {
65 // Abort if any of the inner matchers can't be converted to
67 if (!InnerMatcher.Value)
69 llvm::Optional<DynTypedMatcher> Inner =
70 InnerMatcher.Value->getTypedMatcher(*this);
73 DynMatchers.push_back(*Inner);
75 return DynTypedMatcher::constructVariadic(Op, DynMatchers);
78 VariantMatcher::Payload::~Payload() {}
80 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
82 SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
84 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
88 std::string getTypeAsString() const override {
89 return (Twine("Matcher<") + Matcher.getSupportedKind().asStringRef() + ">")
93 llvm::Optional<DynTypedMatcher>
94 getTypedMatcher(const MatcherOps &Ops) const override {
96 if (Ops.canConstructFrom(Matcher, Ignore))
101 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
102 unsigned *Specificity) const override {
103 return ArgKind(Matcher.getSupportedKind())
104 .isConvertibleTo(Kind, Specificity);
108 const DynTypedMatcher Matcher;
111 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
113 PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
114 : Matchers(std::move(MatchersIn)) {}
116 ~PolymorphicPayload() override {}
118 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
119 if (Matchers.size() != 1)
120 return llvm::Optional<DynTypedMatcher>();
124 std::string getTypeAsString() const override {
126 for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
129 Inner += Matchers[i].getSupportedKind().asStringRef();
131 return (Twine("Matcher<") + Inner + ">").str();
134 llvm::Optional<DynTypedMatcher>
135 getTypedMatcher(const MatcherOps &Ops) const override {
136 bool FoundIsExact = false;
137 const DynTypedMatcher *Found = nullptr;
139 for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
141 if (Ops.canConstructFrom(Matchers[i], IsExactMatch)) {
144 assert(!IsExactMatch && "We should not have two exact matches.");
148 Found = &Matchers[i];
149 FoundIsExact = IsExactMatch;
153 // We only succeed if we found exactly one, or if we found an exact match.
154 if (Found && (FoundIsExact || NumFound == 1))
159 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
160 unsigned *Specificity) const override {
161 unsigned MaxSpecificity = 0;
162 for (const DynTypedMatcher &Matcher : Matchers) {
163 unsigned ThisSpecificity;
164 if (ArgKind(Matcher.getSupportedKind())
165 .isConvertibleTo(Kind, &ThisSpecificity)) {
166 MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
170 *Specificity = MaxSpecificity;
171 return MaxSpecificity > 0;
174 const std::vector<DynTypedMatcher> Matchers;
177 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
179 VariadicOpPayload(DynTypedMatcher::VariadicOperator Op,
180 std::vector<VariantMatcher> Args)
181 : Op(Op), Args(std::move(Args)) {}
183 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
184 return llvm::Optional<DynTypedMatcher>();
187 std::string getTypeAsString() const override {
189 for (size_t i = 0, e = Args.size(); i != e; ++i) {
192 Inner += Args[i].getTypeAsString();
197 llvm::Optional<DynTypedMatcher>
198 getTypedMatcher(const MatcherOps &Ops) const override {
199 return Ops.constructVariadicOperator(Op, Args);
202 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
203 unsigned *Specificity) const override {
204 for (const VariantMatcher &Matcher : Args) {
205 if (!Matcher.isConvertibleTo(Kind, Specificity))
212 const DynTypedMatcher::VariadicOperator Op;
213 const std::vector<VariantMatcher> Args;
216 VariantMatcher::VariantMatcher() {}
218 VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) {
219 return VariantMatcher(new SinglePayload(Matcher));
223 VariantMatcher::PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers) {
224 return VariantMatcher(new PolymorphicPayload(std::move(Matchers)));
227 VariantMatcher VariantMatcher::VariadicOperatorMatcher(
228 DynTypedMatcher::VariadicOperator Op,
229 std::vector<VariantMatcher> Args) {
230 return VariantMatcher(new VariadicOpPayload(Op, std::move(Args)));
233 llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
234 return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
237 void VariantMatcher::reset() { Value.reset(); }
239 std::string VariantMatcher::getTypeAsString() const {
240 if (Value) return Value->getTypeAsString();
244 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
248 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
249 setUnsigned(Unsigned);
252 VariantValue::VariantValue(const std::string &String) : Type(VT_Nothing) {
256 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
260 VariantValue::~VariantValue() { reset(); }
262 VariantValue &VariantValue::operator=(const VariantValue &Other) {
263 if (this == &Other) return *this;
265 switch (Other.Type) {
267 setUnsigned(Other.getUnsigned());
270 setString(Other.getString());
273 setMatcher(Other.getMatcher());
282 void VariantValue::reset() {
288 delete Value.Matcher;
290 // Cases that do nothing.
298 bool VariantValue::isUnsigned() const {
299 return Type == VT_Unsigned;
302 unsigned VariantValue::getUnsigned() const {
303 assert(isUnsigned());
304 return Value.Unsigned;
307 void VariantValue::setUnsigned(unsigned NewValue) {
310 Value.Unsigned = NewValue;
313 bool VariantValue::isString() const {
314 return Type == VT_String;
317 const std::string &VariantValue::getString() const {
319 return *Value.String;
322 void VariantValue::setString(const std::string &NewValue) {
325 Value.String = new std::string(NewValue);
328 bool VariantValue::isMatcher() const {
329 return Type == VT_Matcher;
332 const VariantMatcher &VariantValue::getMatcher() const {
334 return *Value.Matcher;
337 void VariantValue::setMatcher(const VariantMatcher &NewValue) {
340 Value.Matcher = new VariantMatcher(NewValue);
343 bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const {
344 switch (Kind.getArgKind()) {
345 case ArgKind::AK_Unsigned:
351 case ArgKind::AK_String:
357 case ArgKind::AK_Matcher:
360 return getMatcher().isConvertibleTo(Kind.getMatcherKind(), Specificity);
362 llvm_unreachable("Invalid Type");
365 bool VariantValue::isConvertibleTo(ArrayRef<ArgKind> Kinds,
366 unsigned *Specificity) const {
367 unsigned MaxSpecificity = 0;
368 for (const ArgKind& Kind : Kinds) {
369 unsigned ThisSpecificity;
370 if (!isConvertibleTo(Kind, &ThisSpecificity))
372 MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
374 if (Specificity && MaxSpecificity > 0) {
375 *Specificity = MaxSpecificity;
377 return MaxSpecificity > 0;
380 std::string VariantValue::getTypeAsString() const {
382 case VT_String: return "String";
383 case VT_Matcher: return getMatcher().getTypeAsString();
384 case VT_Unsigned: return "Unsigned";
385 case VT_Nothing: return "Nothing";
387 llvm_unreachable("Invalid Type");
390 } // end namespace dynamic
391 } // end namespace ast_matchers
392 } // end namespace clang