clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

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