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();
36 llvm_unreachable("unhandled ArgKind");
39 bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const {
42 if (K != AK_Matcher) {
48 if (!MatcherKind.isBaseOf(To.MatcherKind, &Distance))
52 *Specificity = 100 - Distance;
57 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
58 bool &IsExactMatch) const {
59 IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
60 return Matcher.canConvertTo(NodeKind);
63 llvm::Optional<DynTypedMatcher>
64 VariantMatcher::MatcherOps::constructVariadicOperator(
65 DynTypedMatcher::VariadicOperator Op,
66 ArrayRef<VariantMatcher> InnerMatchers) const {
67 std::vector<DynTypedMatcher> DynMatchers;
68 for (const auto &InnerMatcher : InnerMatchers) {
69 // Abort if any of the inner matchers can't be converted to
71 if (!InnerMatcher.Value)
73 llvm::Optional<DynTypedMatcher> Inner =
74 InnerMatcher.Value->getTypedMatcher(*this);
77 DynMatchers.push_back(*Inner);
79 return DynTypedMatcher::constructVariadic(Op, NodeKind, DynMatchers);
82 VariantMatcher::Payload::~Payload() {}
84 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
86 SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
88 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
92 std::string getTypeAsString() const override {
93 return (Twine("Matcher<") + Matcher.getSupportedKind().asStringRef() + ">")
97 llvm::Optional<DynTypedMatcher>
98 getTypedMatcher(const MatcherOps &Ops) const override {
100 if (Ops.canConstructFrom(Matcher, Ignore))
105 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
106 unsigned *Specificity) const override {
107 return ArgKind(Matcher.getSupportedKind())
108 .isConvertibleTo(Kind, Specificity);
112 const DynTypedMatcher Matcher;
115 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
117 PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
118 : Matchers(std::move(MatchersIn)) {}
120 ~PolymorphicPayload() override {}
122 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
123 if (Matchers.size() != 1)
124 return llvm::Optional<DynTypedMatcher>();
128 std::string getTypeAsString() const override {
130 for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
133 Inner += Matchers[i].getSupportedKind().asStringRef();
135 return (Twine("Matcher<") + Inner + ">").str();
138 llvm::Optional<DynTypedMatcher>
139 getTypedMatcher(const MatcherOps &Ops) const override {
140 bool FoundIsExact = false;
141 const DynTypedMatcher *Found = nullptr;
143 for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
145 if (Ops.canConstructFrom(Matchers[i], IsExactMatch)) {
148 assert(!IsExactMatch && "We should not have two exact matches.");
152 Found = &Matchers[i];
153 FoundIsExact = IsExactMatch;
157 // We only succeed if we found exactly one, or if we found an exact match.
158 if (Found && (FoundIsExact || NumFound == 1))
163 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
164 unsigned *Specificity) const override {
165 unsigned MaxSpecificity = 0;
166 for (const DynTypedMatcher &Matcher : Matchers) {
167 unsigned ThisSpecificity;
168 if (ArgKind(Matcher.getSupportedKind())
169 .isConvertibleTo(Kind, &ThisSpecificity)) {
170 MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
174 *Specificity = MaxSpecificity;
175 return MaxSpecificity > 0;
178 const std::vector<DynTypedMatcher> Matchers;
181 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
183 VariadicOpPayload(DynTypedMatcher::VariadicOperator Op,
184 std::vector<VariantMatcher> Args)
185 : Op(Op), Args(std::move(Args)) {}
187 llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
188 return llvm::Optional<DynTypedMatcher>();
191 std::string getTypeAsString() const override {
193 for (size_t i = 0, e = Args.size(); i != e; ++i) {
196 Inner += Args[i].getTypeAsString();
201 llvm::Optional<DynTypedMatcher>
202 getTypedMatcher(const MatcherOps &Ops) const override {
203 return Ops.constructVariadicOperator(Op, Args);
206 bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
207 unsigned *Specificity) const override {
208 for (const VariantMatcher &Matcher : Args) {
209 if (!Matcher.isConvertibleTo(Kind, Specificity))
216 const DynTypedMatcher::VariadicOperator Op;
217 const std::vector<VariantMatcher> Args;
220 VariantMatcher::VariantMatcher() {}
222 VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) {
223 return VariantMatcher(std::make_shared<SinglePayload>(Matcher));
227 VariantMatcher::PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers) {
228 return VariantMatcher(
229 std::make_shared<PolymorphicPayload>(std::move(Matchers)));
232 VariantMatcher VariantMatcher::VariadicOperatorMatcher(
233 DynTypedMatcher::VariadicOperator Op,
234 std::vector<VariantMatcher> Args) {
235 return VariantMatcher(
236 std::make_shared<VariadicOpPayload>(Op, std::move(Args)));
239 llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
240 return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
243 void VariantMatcher::reset() { Value.reset(); }
245 std::string VariantMatcher::getTypeAsString() const {
246 if (Value) return Value->getTypeAsString();
250 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
254 VariantValue::VariantValue(bool Boolean) : Type(VT_Nothing) {
258 VariantValue::VariantValue(double Double) : Type(VT_Nothing) {
262 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
263 setUnsigned(Unsigned);
266 VariantValue::VariantValue(StringRef String) : Type(VT_Nothing) {
270 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
274 VariantValue::~VariantValue() { reset(); }
276 VariantValue &VariantValue::operator=(const VariantValue &Other) {
277 if (this == &Other) return *this;
279 switch (Other.Type) {
281 setBoolean(Other.getBoolean());
284 setDouble(Other.getDouble());
287 setUnsigned(Other.getUnsigned());
290 setString(Other.getString());
293 setMatcher(Other.getMatcher());
302 void VariantValue::reset() {
308 delete Value.Matcher;
310 // Cases that do nothing.
320 bool VariantValue::isBoolean() const {
321 return Type == VT_Boolean;
324 bool VariantValue::getBoolean() const {
326 return Value.Boolean;
329 void VariantValue::setBoolean(bool NewValue) {
332 Value.Boolean = NewValue;
335 bool VariantValue::isDouble() const {
336 return Type == VT_Double;
339 double VariantValue::getDouble() const {
344 void VariantValue::setDouble(double NewValue) {
347 Value.Double = NewValue;
350 bool VariantValue::isUnsigned() const {
351 return Type == VT_Unsigned;
354 unsigned VariantValue::getUnsigned() const {
355 assert(isUnsigned());
356 return Value.Unsigned;
359 void VariantValue::setUnsigned(unsigned NewValue) {
362 Value.Unsigned = NewValue;
365 bool VariantValue::isString() const {
366 return Type == VT_String;
369 const std::string &VariantValue::getString() const {
371 return *Value.String;
374 void VariantValue::setString(StringRef NewValue) {
377 Value.String = new std::string(NewValue);
380 bool VariantValue::isMatcher() const {
381 return Type == VT_Matcher;
384 const VariantMatcher &VariantValue::getMatcher() const {
386 return *Value.Matcher;
389 void VariantValue::setMatcher(const VariantMatcher &NewValue) {
392 Value.Matcher = new VariantMatcher(NewValue);
395 bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const {
396 switch (Kind.getArgKind()) {
397 case ArgKind::AK_Boolean:
403 case ArgKind::AK_Double:
409 case ArgKind::AK_Unsigned:
415 case ArgKind::AK_String:
421 case ArgKind::AK_Matcher:
424 return getMatcher().isConvertibleTo(Kind.getMatcherKind(), Specificity);
426 llvm_unreachable("Invalid Type");
429 bool VariantValue::isConvertibleTo(ArrayRef<ArgKind> Kinds,
430 unsigned *Specificity) const {
431 unsigned MaxSpecificity = 0;
432 for (const ArgKind& Kind : Kinds) {
433 unsigned ThisSpecificity;
434 if (!isConvertibleTo(Kind, &ThisSpecificity))
436 MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
438 if (Specificity && MaxSpecificity > 0) {
439 *Specificity = MaxSpecificity;
441 return MaxSpecificity > 0;
444 std::string VariantValue::getTypeAsString() const {
446 case VT_String: return "String";
447 case VT_Matcher: return getMatcher().getTypeAsString();
448 case VT_Boolean: return "Boolean";
449 case VT_Double: return "Double";
450 case VT_Unsigned: return "Unsigned";
451 case VT_Nothing: return "Nothing";
453 llvm_unreachable("Invalid Type");
456 } // end namespace dynamic
457 } // end namespace ast_matchers
458 } // end namespace clang