contrib/llvm/tools/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

   1 //===--- VariantValue.cpp - Polymorphic value type -*- C++ -*-===/
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// Polymorphic value type.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
  16 #include "clang/Basic/LLVM.h"
  17 #include "llvm/ADT/STLExtras.h"
  18
  19 namespace clang {
  20 namespace ast_matchers {
  21 namespace dynamic {
  22
  23 std::string ArgKind::asString() const {
  24   switch (getArgKind()) {
  25   case AK_Matcher:
  26     return (Twine("Matcher<") + MatcherKind.asStringRef() + ">").str();
  27   case AK_Boolean:
  28     return "boolean";
  29   case AK_Double:
  30     return "double";
  31   case AK_Unsigned:
  32     return "unsigned";
  33   case AK_String:
  34     return "string";
  35   }
  36   llvm_unreachable("unhandled ArgKind");
  37 }
  38
  39 bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const {
  40   if (K != To.K)
  41     return false;
  42   if (K != AK_Matcher) {
  43     if (Specificity)
  44       *Specificity = 1;
  45     return true;
  46   }
  47   unsigned Distance;
  48   if (!MatcherKind.isBaseOf(To.MatcherKind, &Distance))
  49     return false;
  50
  51   if (Specificity)
  52     *Specificity = 100 - Distance;
  53   return true;
  54 }
  55
  56 bool
  57 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
  58                                              bool &IsExactMatch) const {
  59   IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
  60   return Matcher.canConvertTo(NodeKind);
  61 }
  62
  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
  70     // Matcher<T>.
  71     if (!InnerMatcher.Value)
  72       return llvm::None;
  73     llvm::Optional<DynTypedMatcher> Inner =
  74         InnerMatcher.Value->getTypedMatcher(*this);
  75     if (!Inner)
  76       return llvm::None;
  77     DynMatchers.push_back(*Inner);
  78   }
  79   return DynTypedMatcher::constructVariadic(Op, NodeKind, DynMatchers);
  80 }
  81
  82 VariantMatcher::Payload::~Payload() {}
  83
  84 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
  85 public:
  86   SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
  87
  88   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
  89     return Matcher;
  90   }
  91
  92   std::string getTypeAsString() const override {
  93     return (Twine("Matcher<") + Matcher.getSupportedKind().asStringRef() + ">")
  94         .str();
  95   }
  96
  97   llvm::Optional<DynTypedMatcher>
  98   getTypedMatcher(const MatcherOps &Ops) const override {
  99     bool Ignore;
 100     if (Ops.canConstructFrom(Matcher, Ignore))
 101       return Matcher;
 102     return llvm::None;
 103   }
 104
 105   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
 106                        unsigned *Specificity) const override {
 107     return ArgKind(Matcher.getSupportedKind())
 108         .isConvertibleTo(Kind, Specificity);
 109   }
 110
 111 private:
 112   const DynTypedMatcher Matcher;
 113 };
 114
 115 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
 116 public:
 117   PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
 118       : Matchers(std::move(MatchersIn)) {}
 119
 120   ~PolymorphicPayload() override {}
 121
 122   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
 123     if (Matchers.size() != 1)
 124       return llvm::Optional<DynTypedMatcher>();
 125     return Matchers[0];
 126   }
 127
 128   std::string getTypeAsString() const override {
 129     std::string Inner;
 130     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
 131       if (i != 0)
 132         Inner += "|";
 133       Inner += Matchers[i].getSupportedKind().asStringRef();
 134     }
 135     return (Twine("Matcher<") + Inner + ">").str();
 136   }
 137
 138   llvm::Optional<DynTypedMatcher>
 139   getTypedMatcher(const MatcherOps &Ops) const override {
 140     bool FoundIsExact = false;
 141     const DynTypedMatcher *Found = nullptr;
 142     int NumFound = 0;
 143     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
 144       bool IsExactMatch;
 145       if (Ops.canConstructFrom(Matchers[i], IsExactMatch)) {
 146         if (Found) {
 147           if (FoundIsExact) {
 148             assert(!IsExactMatch && "We should not have two exact matches.");
 149             continue;
 150           }
 151         }
 152         Found = &Matchers[i];
 153         FoundIsExact = IsExactMatch;
 154         ++NumFound;
 155       }
 156     }
 157     // We only succeed if we found exactly one, or if we found an exact match.
 158     if (Found && (FoundIsExact || NumFound == 1))
 159       return *Found;
 160     return llvm::None;
 161   }
 162
 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);
 171       }
 172     }
 173     if (Specificity)
 174       *Specificity = MaxSpecificity;
 175     return MaxSpecificity > 0;
 176   }
 177
 178   const std::vector<DynTypedMatcher> Matchers;
 179 };
 180
 181 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
 182 public:
 183   VariadicOpPayload(DynTypedMatcher::VariadicOperator Op,
 184                     std::vector<VariantMatcher> Args)
 185       : Op(Op), Args(std::move(Args)) {}
 186
 187   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
 188     return llvm::Optional<DynTypedMatcher>();
 189   }
 190
 191   std::string getTypeAsString() const override {
 192     std::string Inner;
 193     for (size_t i = 0, e = Args.size(); i != e; ++i) {
 194       if (i != 0)
 195         Inner += "&";
 196       Inner += Args[i].getTypeAsString();
 197     }
 198     return Inner;
 199   }
 200
 201   llvm::Optional<DynTypedMatcher>
 202   getTypedMatcher(const MatcherOps &Ops) const override {
 203     return Ops.constructVariadicOperator(Op, Args);
 204   }
 205
 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))
 210         return false;
 211     }
 212     return true;
 213   }
 214
 215 private:
 216   const DynTypedMatcher::VariadicOperator Op;
 217   const std::vector<VariantMatcher> Args;
 218 };
 219
 220 VariantMatcher::VariantMatcher() {}
 221
 222 VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) {
 223   return VariantMatcher(std::make_shared<SinglePayload>(Matcher));
 224 }
 225
 226 VariantMatcher
 227 VariantMatcher::PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers) {
 228   return VariantMatcher(
 229       std::make_shared<PolymorphicPayload>(std::move(Matchers)));
 230 }
 231
 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)));
 237 }
 238
 239 llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
 240   return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
 241 }
 242
 243 void VariantMatcher::reset() { Value.reset(); }
 244
 245 std::string VariantMatcher::getTypeAsString() const {
 246   if (Value) return Value->getTypeAsString();
 247   return "<Nothing>";
 248 }
 249
 250 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
 251   *this = Other;
 252 }
 253
 254 VariantValue::VariantValue(bool Boolean) : Type(VT_Nothing) {
 255   setBoolean(Boolean);
 256 }
 257
 258 VariantValue::VariantValue(double Double) : Type(VT_Nothing) {
 259   setDouble(Double);
 260 }
 261
 262 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
 263   setUnsigned(Unsigned);
 264 }
 265
 266 VariantValue::VariantValue(StringRef String) : Type(VT_Nothing) {
 267   setString(String);
 268 }
 269
 270 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
 271   setMatcher(Matcher);
 272 }
 273
 274 VariantValue::~VariantValue() { reset(); }
 275
 276 VariantValue &VariantValue::operator=(const VariantValue &Other) {
 277   if (this == &Other) return *this;
 278   reset();
 279   switch (Other.Type) {
 280   case VT_Boolean:
 281     setBoolean(Other.getBoolean());
 282     break;
 283   case VT_Double:
 284     setDouble(Other.getDouble());
 285     break;
 286   case VT_Unsigned:
 287     setUnsigned(Other.getUnsigned());
 288     break;
 289   case VT_String:
 290     setString(Other.getString());
 291     break;
 292   case VT_Matcher:
 293     setMatcher(Other.getMatcher());
 294     break;
 295   case VT_Nothing:
 296     Type = VT_Nothing;
 297     break;
 298   }
 299   return *this;
 300 }
 301
 302 void VariantValue::reset() {
 303   switch (Type) {
 304   case VT_String:
 305     delete Value.String;
 306     break;
 307   case VT_Matcher:
 308     delete Value.Matcher;
 309     break;
 310   // Cases that do nothing.
 311   case VT_Boolean:
 312   case VT_Double:
 313   case VT_Unsigned:
 314   case VT_Nothing:
 315     break;
 316   }
 317   Type = VT_Nothing;
 318 }
 319
 320 bool VariantValue::isBoolean() const {
 321   return Type == VT_Boolean;
 322 }
 323
 324 bool VariantValue::getBoolean() const {
 325   assert(isBoolean());
 326   return Value.Boolean;
 327 }
 328
 329 void VariantValue::setBoolean(bool NewValue) {
 330   reset();
 331   Type = VT_Boolean;
 332   Value.Boolean = NewValue;
 333 }
 334
 335 bool VariantValue::isDouble() const {
 336   return Type == VT_Double;
 337 }
 338
 339 double VariantValue::getDouble() const {
 340   assert(isDouble());
 341   return Value.Double;
 342 }
 343
 344 void VariantValue::setDouble(double NewValue) {
 345   reset();
 346   Type = VT_Double;
 347   Value.Double = NewValue;
 348 }
 349
 350 bool VariantValue::isUnsigned() const {
 351   return Type == VT_Unsigned;
 352 }
 353
 354 unsigned VariantValue::getUnsigned() const {
 355   assert(isUnsigned());
 356   return Value.Unsigned;
 357 }
 358
 359 void VariantValue::setUnsigned(unsigned NewValue) {
 360   reset();
 361   Type = VT_Unsigned;
 362   Value.Unsigned = NewValue;
 363 }
 364
 365 bool VariantValue::isString() const {
 366   return Type == VT_String;
 367 }
 368
 369 const std::string &VariantValue::getString() const {
 370   assert(isString());
 371   return *Value.String;
 372 }
 373
 374 void VariantValue::setString(StringRef NewValue) {
 375   reset();
 376   Type = VT_String;
 377   Value.String = new std::string(NewValue);
 378 }
 379
 380 bool VariantValue::isMatcher() const {
 381   return Type == VT_Matcher;
 382 }
 383
 384 const VariantMatcher &VariantValue::getMatcher() const {
 385   assert(isMatcher());
 386   return *Value.Matcher;
 387 }
 388
 389 void VariantValue::setMatcher(const VariantMatcher &NewValue) {
 390   reset();
 391   Type = VT_Matcher;
 392   Value.Matcher = new VariantMatcher(NewValue);
 393 }
 394
 395 bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const {
 396   switch (Kind.getArgKind()) {
 397   case ArgKind::AK_Boolean:
 398     if (!isBoolean())
 399       return false;
 400     *Specificity = 1;
 401     return true;
 402
 403   case ArgKind::AK_Double:
 404     if (!isDouble())
 405       return false;
 406     *Specificity = 1;
 407     return true;
 408
 409   case ArgKind::AK_Unsigned:
 410     if (!isUnsigned())
 411       return false;
 412     *Specificity = 1;
 413     return true;
 414
 415   case ArgKind::AK_String:
 416     if (!isString())
 417       return false;
 418     *Specificity = 1;
 419     return true;
 420
 421   case ArgKind::AK_Matcher:
 422     if (!isMatcher())
 423       return false;
 424     return getMatcher().isConvertibleTo(Kind.getMatcherKind(), Specificity);
 425   }
 426   llvm_unreachable("Invalid Type");
 427 }
 428
 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))
 435       continue;
 436     MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
 437   }
 438   if (Specificity && MaxSpecificity > 0) {
 439     *Specificity = MaxSpecificity;
 440   }
 441   return MaxSpecificity > 0;
 442 }
 443
 444 std::string VariantValue::getTypeAsString() const {
 445   switch (Type) {
 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";
 452   }
 453   llvm_unreachable("Invalid Type");
 454 }
 455
 456 } // end namespace dynamic
 457 } // end namespace ast_matchers
 458 } // end namespace clang