contrib/llvm/tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h

   1 //===--- Marshallers.h - Generic matcher function marshallers -*- 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 /// \brief Functions templates and classes to wrap matcher construct functions.
  12 ///
  13 /// A collection of template function and classes that provide a generic
  14 /// marshalling layer on top of matcher construct functions.
  15 /// These are used by the registry to export all marshaller constructors with
  16 /// the same generic interface.
  17 ///
  18 //===----------------------------------------------------------------------===//
  19
  20 #ifndef LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
  21 #define LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
  22
  23 #include "clang/ASTMatchers/ASTMatchers.h"
  24 #include "clang/ASTMatchers/Dynamic/Diagnostics.h"
  25 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
  26 #include "clang/Basic/LLVM.h"
  27 #include "llvm/ADT/STLExtras.h"
  28 #include <string>
  29
  30 namespace clang {
  31 namespace ast_matchers {
  32 namespace dynamic {
  33 namespace internal {
  34
  35
  36 /// \brief Helper template class to just from argument type to the right is/get
  37 ///   functions in VariantValue.
  38 /// Used to verify and extract the matcher arguments below.
  39 template <class T> struct ArgTypeTraits;
  40 template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
  41 };
  42
  43 template <> struct ArgTypeTraits<std::string> {
  44   static bool is(const VariantValue &Value) { return Value.isString(); }
  45   static const std::string &get(const VariantValue &Value) {
  46     return Value.getString();
  47   }
  48   static ArgKind getKind() {
  49     return ArgKind(ArgKind::AK_String);
  50   }
  51 };
  52
  53 template <>
  54 struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
  55 };
  56
  57 template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T> > {
  58   static bool is(const VariantValue &Value) {
  59     return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
  60   }
  61   static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
  62     return Value.getMatcher().getTypedMatcher<T>();
  63   }
  64   static ArgKind getKind() {
  65     return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  66   }
  67 };
  68
  69 template <> struct ArgTypeTraits<unsigned> {
  70   static bool is(const VariantValue &Value) { return Value.isUnsigned(); }
  71   static unsigned get(const VariantValue &Value) {
  72     return Value.getUnsigned();
  73   }
  74   static ArgKind getKind() {
  75     return ArgKind(ArgKind::AK_Unsigned);
  76   }
  77 };
  78
  79 template <> struct ArgTypeTraits<attr::Kind> {
  80 private:
  81   static attr::Kind getAttrKind(llvm::StringRef AttrKind) {
  82     return llvm::StringSwitch<attr::Kind>(AttrKind)
  83 #define ATTR(X) .Case("attr::" #X, attr:: X)
  84 #include "clang/Basic/AttrList.inc"
  85         .Default(attr::Kind(-1));
  86   }
  87 public:
  88   static bool is(const VariantValue &Value) {
  89     return Value.isString() &&
  90         getAttrKind(Value.getString()) != attr::Kind(-1);
  91   }
  92   static attr::Kind get(const VariantValue &Value) {
  93     return getAttrKind(Value.getString());
  94   }
  95   static ArgKind getKind() {
  96     return ArgKind(ArgKind::AK_String);
  97   }
  98 };
  99
 100 /// \brief Matcher descriptor interface.
 101 ///
 102 /// Provides a \c create() method that constructs the matcher from the provided
 103 /// arguments, and various other methods for type introspection.
 104 class MatcherDescriptor {
 105 public:
 106   virtual ~MatcherDescriptor() {}
 107   virtual VariantMatcher create(SourceRange NameRange,
 108                                 ArrayRef<ParserValue> Args,
 109                                 Diagnostics *Error) const = 0;
 110
 111   /// Returns whether the matcher is variadic. Variadic matchers can take any
 112   /// number of arguments, but they must be of the same type.
 113   virtual bool isVariadic() const = 0;
 114
 115   /// Returns the number of arguments accepted by the matcher if not variadic.
 116   virtual unsigned getNumArgs() const = 0;
 117
 118   /// Given that the matcher is being converted to type \p ThisKind, append the
 119   /// set of argument types accepted for argument \p ArgNo to \p ArgKinds.
 120   // FIXME: We should provide the ability to constrain the output of this
 121   // function based on the types of other matcher arguments.
 122   virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
 123                            std::vector<ArgKind> &ArgKinds) const = 0;
 124
 125   /// Returns whether this matcher is convertible to the given type.  If it is
 126   /// so convertible, store in *Specificity a value corresponding to the
 127   /// "specificity" of the converted matcher to the given context, and in
 128   /// *LeastDerivedKind the least derived matcher kind which would result in the
 129   /// same matcher overload.  Zero specificity indicates that this conversion
 130   /// would produce a trivial matcher that will either always or never match.
 131   /// Such matchers are excluded from code completion results.
 132   virtual bool isConvertibleTo(
 133       ast_type_traits::ASTNodeKind Kind, unsigned *Specificity = nullptr,
 134       ast_type_traits::ASTNodeKind *LeastDerivedKind = nullptr) const = 0;
 135
 136   /// Returns whether the matcher will, given a matcher of any type T, yield a
 137   /// matcher of type T.
 138   virtual bool isPolymorphic() const { return false; }
 139 };
 140
 141 inline bool isRetKindConvertibleTo(
 142     ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
 143     ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 144     ast_type_traits::ASTNodeKind *LeastDerivedKind) {
 145   for (const ast_type_traits::ASTNodeKind &NodeKind : RetKinds) {
 146     if (ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) {
 147       if (LeastDerivedKind)
 148         *LeastDerivedKind = NodeKind;
 149       return true;
 150     }
 151   }
 152   return false;
 153 }
 154
 155 /// \brief Simple callback implementation. Marshaller and function are provided.
 156 ///
 157 /// This class wraps a function of arbitrary signature and a marshaller
 158 /// function into a MatcherDescriptor.
 159 /// The marshaller is in charge of taking the VariantValue arguments, checking
 160 /// their types, unpacking them and calling the underlying function.
 161 class FixedArgCountMatcherDescriptor : public MatcherDescriptor {
 162 public:
 163   typedef VariantMatcher (*MarshallerType)(void (*Func)(),
 164                                            StringRef MatcherName,
 165                                            SourceRange NameRange,
 166                                            ArrayRef<ParserValue> Args,
 167                                            Diagnostics *Error);
 168
 169   /// \param Marshaller Function to unpack the arguments and call \c Func
 170   /// \param Func Matcher construct function. This is the function that
 171   ///   compile-time matcher expressions would use to create the matcher.
 172   /// \param RetKinds The list of matcher types to which the matcher is
 173   ///   convertible.
 174   /// \param ArgKinds The types of the arguments this matcher takes.
 175   FixedArgCountMatcherDescriptor(
 176       MarshallerType Marshaller, void (*Func)(), StringRef MatcherName,
 177       ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
 178       ArrayRef<ArgKind> ArgKinds)
 179       : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
 180         RetKinds(RetKinds.begin(), RetKinds.end()),
 181         ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
 182
 183   VariantMatcher create(SourceRange NameRange,
 184                         ArrayRef<ParserValue> Args,
 185                         Diagnostics *Error) const override {
 186     return Marshaller(Func, MatcherName, NameRange, Args, Error);
 187   }
 188
 189   bool isVariadic() const override { return false; }
 190   unsigned getNumArgs() const override { return ArgKinds.size(); }
 191   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
 192                    std::vector<ArgKind> &Kinds) const override {
 193     Kinds.push_back(ArgKinds[ArgNo]);
 194   }
 195   bool isConvertibleTo(
 196       ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 197       ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
 198     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
 199                                   LeastDerivedKind);
 200   }
 201
 202 private:
 203   const MarshallerType Marshaller;
 204   void (* const Func)();
 205   const std::string MatcherName;
 206   const std::vector<ast_type_traits::ASTNodeKind> RetKinds;
 207   const std::vector<ArgKind> ArgKinds;
 208 };
 209
 210 /// \brief Helper methods to extract and merge all possible typed matchers
 211 /// out of the polymorphic object.
 212 template <class PolyMatcher>
 213 static void mergePolyMatchers(const PolyMatcher &Poly,
 214                               std::vector<DynTypedMatcher> &Out,
 215                               ast_matchers::internal::EmptyTypeList) {}
 216
 217 template <class PolyMatcher, class TypeList>
 218 static void mergePolyMatchers(const PolyMatcher &Poly,
 219                               std::vector<DynTypedMatcher> &Out, TypeList) {
 220   Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
 221   mergePolyMatchers(Poly, Out, typename TypeList::tail());
 222 }
 223
 224 /// \brief Convert the return values of the functions into a VariantMatcher.
 225 ///
 226 /// There are 2 cases right now: The return value is a Matcher<T> or is a
 227 /// polymorphic matcher. For the former, we just construct the VariantMatcher.
 228 /// For the latter, we instantiate all the possible Matcher<T> of the poly
 229 /// matcher.
 230 static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
 231   return VariantMatcher::SingleMatcher(Matcher);
 232 }
 233
 234 template <typename T>
 235 static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
 236                                                typename T::ReturnTypes * =
 237                                                    NULL) {
 238   std::vector<DynTypedMatcher> Matchers;
 239   mergePolyMatchers(PolyMatcher, Matchers, typename T::ReturnTypes());
 240   VariantMatcher Out = VariantMatcher::PolymorphicMatcher(std::move(Matchers));
 241   return Out;
 242 }
 243
 244 template <typename T>
 245 inline void buildReturnTypeVectorFromTypeList(
 246     std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
 247   RetTypes.push_back(
 248       ast_type_traits::ASTNodeKind::getFromNodeKind<typename T::head>());
 249   buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
 250 }
 251
 252 template <>
 253 inline void
 254 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
 255     std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
 256
 257 template <typename T>
 258 struct BuildReturnTypeVector {
 259   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
 260     buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
 261   }
 262 };
 263
 264 template <typename T>
 265 struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T> > {
 266   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
 267     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
 268   }
 269 };
 270
 271 template <typename T>
 272 struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T> > {
 273   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
 274     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
 275   }
 276 };
 277
 278 /// \brief Variadic marshaller function.
 279 template <typename ResultT, typename ArgT,
 280           ResultT (*Func)(ArrayRef<const ArgT *>)>
 281 VariantMatcher
 282 variadicMatcherDescriptor(StringRef MatcherName, SourceRange NameRange,
 283                           ArrayRef<ParserValue> Args, Diagnostics *Error) {
 284   ArgT **InnerArgs = new ArgT *[Args.size()]();
 285
 286   bool HasError = false;
 287   for (size_t i = 0, e = Args.size(); i != e; ++i) {
 288     typedef ArgTypeTraits<ArgT> ArgTraits;
 289     const ParserValue &Arg = Args[i];
 290     const VariantValue &Value = Arg.Value;
 291     if (!ArgTraits::is(Value)) {
 292       Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
 293           << (i + 1) << ArgTraits::getKind().asString() << Value.getTypeAsString();
 294       HasError = true;
 295       break;
 296     }
 297     InnerArgs[i] = new ArgT(ArgTraits::get(Value));
 298   }
 299
 300   VariantMatcher Out;
 301   if (!HasError) {
 302     Out = outvalueToVariantMatcher(Func(llvm::makeArrayRef(InnerArgs,
 303                                                            Args.size())));
 304   }
 305
 306   for (size_t i = 0, e = Args.size(); i != e; ++i) {
 307     delete InnerArgs[i];
 308   }
 309   delete[] InnerArgs;
 310   return Out;
 311 }
 312
 313 /// \brief Matcher descriptor for variadic functions.
 314 ///
 315 /// This class simply wraps a VariadicFunction with the right signature to export
 316 /// it as a MatcherDescriptor.
 317 /// This allows us to have one implementation of the interface for as many free
 318 /// functions as we want, reducing the number of symbols and size of the
 319 /// object file.
 320 class VariadicFuncMatcherDescriptor : public MatcherDescriptor {
 321 public:
 322   typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
 323                                     SourceRange NameRange,
 324                                     ArrayRef<ParserValue> Args,
 325                                     Diagnostics *Error);
 326
 327   template <typename ResultT, typename ArgT,
 328             ResultT (*F)(ArrayRef<const ArgT *>)>
 329   VariadicFuncMatcherDescriptor(llvm::VariadicFunction<ResultT, ArgT, F> Func,
 330                           StringRef MatcherName)
 331       : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
 332         MatcherName(MatcherName.str()),
 333         ArgsKind(ArgTypeTraits<ArgT>::getKind()) {
 334     BuildReturnTypeVector<ResultT>::build(RetKinds);
 335   }
 336
 337   VariantMatcher create(SourceRange NameRange,
 338                         ArrayRef<ParserValue> Args,
 339                         Diagnostics *Error) const override {
 340     return Func(MatcherName, NameRange, Args, Error);
 341   }
 342
 343   bool isVariadic() const override { return true; }
 344   unsigned getNumArgs() const override { return 0; }
 345   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
 346                    std::vector<ArgKind> &Kinds) const override {
 347     Kinds.push_back(ArgsKind);
 348   }
 349   bool isConvertibleTo(
 350       ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 351       ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
 352     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
 353                                   LeastDerivedKind);
 354   }
 355
 356 private:
 357   const RunFunc Func;
 358   const std::string MatcherName;
 359   std::vector<ast_type_traits::ASTNodeKind> RetKinds;
 360   const ArgKind ArgsKind;
 361 };
 362
 363 /// \brief Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
 364 class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
 365 public:
 366   template <typename BaseT, typename DerivedT>
 367   DynCastAllOfMatcherDescriptor(
 368       ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
 369       StringRef MatcherName)
 370       : VariadicFuncMatcherDescriptor(Func, MatcherName),
 371         DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
 372   }
 373
 374   bool
 375   isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 376                 ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
 377     // If Kind is not a base of DerivedKind, either DerivedKind is a base of
 378     // Kind (in which case the match will always succeed) or Kind and
 379     // DerivedKind are unrelated (in which case it will always fail), so set
 380     // Specificity to 0.
 381     if (VariadicFuncMatcherDescriptor::isConvertibleTo(Kind, Specificity,
 382                                                  LeastDerivedKind)) {
 383       if (Kind.isSame(DerivedKind) || !Kind.isBaseOf(DerivedKind)) {
 384         if (Specificity)
 385           *Specificity = 0;
 386       }
 387       return true;
 388     } else {
 389       return false;
 390     }
 391   }
 392
 393 private:
 394   const ast_type_traits::ASTNodeKind DerivedKind;
 395 };
 396
 397 /// \brief Helper macros to check the arguments on all marshaller functions.
 398 #define CHECK_ARG_COUNT(count)                                                 \
 399   if (Args.size() != count) {                                                  \
 400     Error->addError(NameRange, Error->ET_RegistryWrongArgCount)                \
 401         << count << Args.size();                                               \
 402     return VariantMatcher();                                                   \
 403   }
 404
 405 #define CHECK_ARG_TYPE(index, type)                                            \
 406   if (!ArgTypeTraits<type>::is(Args[index].Value)) {                           \
 407     Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType)         \
 408         << (index + 1) << ArgTypeTraits<type>::getKind().asString()            \
 409         << Args[index].Value.getTypeAsString();                                \
 410     return VariantMatcher();                                                   \
 411   }
 412
 413
 414 /// \brief 0-arg marshaller function.
 415 template <typename ReturnType>
 416 static VariantMatcher matcherMarshall0(void (*Func)(), StringRef MatcherName,
 417                                        SourceRange NameRange,
 418                                        ArrayRef<ParserValue> Args,
 419                                        Diagnostics *Error) {
 420   typedef ReturnType (*FuncType)();
 421   CHECK_ARG_COUNT(0);
 422   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)());
 423 }
 424
 425 /// \brief 1-arg marshaller function.
 426 template <typename ReturnType, typename ArgType1>
 427 static VariantMatcher matcherMarshall1(void (*Func)(), StringRef MatcherName,
 428                                        SourceRange NameRange,
 429                                        ArrayRef<ParserValue> Args,
 430                                        Diagnostics *Error) {
 431   typedef ReturnType (*FuncType)(ArgType1);
 432   CHECK_ARG_COUNT(1);
 433   CHECK_ARG_TYPE(0, ArgType1);
 434   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
 435       ArgTypeTraits<ArgType1>::get(Args[0].Value)));
 436 }
 437
 438 /// \brief 2-arg marshaller function.
 439 template <typename ReturnType, typename ArgType1, typename ArgType2>
 440 static VariantMatcher matcherMarshall2(void (*Func)(), StringRef MatcherName,
 441                                        SourceRange NameRange,
 442                                        ArrayRef<ParserValue> Args,
 443                                        Diagnostics *Error) {
 444   typedef ReturnType (*FuncType)(ArgType1, ArgType2);
 445   CHECK_ARG_COUNT(2);
 446   CHECK_ARG_TYPE(0, ArgType1);
 447   CHECK_ARG_TYPE(1, ArgType2);
 448   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
 449       ArgTypeTraits<ArgType1>::get(Args[0].Value),
 450       ArgTypeTraits<ArgType2>::get(Args[1].Value)));
 451 }
 452
 453 #undef CHECK_ARG_COUNT
 454 #undef CHECK_ARG_TYPE
 455
 456 /// \brief Helper class used to collect all the possible overloads of an
 457 ///   argument adaptative matcher function.
 458 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
 459           typename FromTypes, typename ToTypes>
 460 class AdaptativeOverloadCollector {
 461 public:
 462   AdaptativeOverloadCollector(StringRef Name,
 463                               std::vector<MatcherDescriptor *> &Out)
 464       : Name(Name), Out(Out) {
 465     collect(FromTypes());
 466   }
 467
 468 private:
 469   typedef ast_matchers::internal::ArgumentAdaptingMatcherFunc<
 470       ArgumentAdapterT, FromTypes, ToTypes> AdaptativeFunc;
 471
 472   /// \brief End case for the recursion
 473   static void collect(ast_matchers::internal::EmptyTypeList) {}
 474
 475   /// \brief Recursive case. Get the overload for the head of the list, and
 476   ///   recurse to the tail.
 477   template <typename FromTypeList>
 478   inline void collect(FromTypeList);
 479
 480   StringRef Name;
 481   std::vector<MatcherDescriptor *> &Out;
 482 };
 483
 484 /// \brief MatcherDescriptor that wraps multiple "overloads" of the same
 485 ///   matcher.
 486 ///
 487 /// It will try every overload and generate appropriate errors for when none or
 488 /// more than one overloads match the arguments.
 489 class OverloadedMatcherDescriptor : public MatcherDescriptor {
 490 public:
 491   OverloadedMatcherDescriptor(ArrayRef<MatcherDescriptor *> Callbacks)
 492       : Overloads(Callbacks.begin(), Callbacks.end()) {}
 493
 494   ~OverloadedMatcherDescriptor() override {}
 495
 496   VariantMatcher create(SourceRange NameRange,
 497                         ArrayRef<ParserValue> Args,
 498                         Diagnostics *Error) const override {
 499     std::vector<VariantMatcher> Constructed;
 500     Diagnostics::OverloadContext Ctx(Error);
 501     for (const auto &O : Overloads) {
 502       VariantMatcher SubMatcher = O->create(NameRange, Args, Error);
 503       if (!SubMatcher.isNull()) {
 504         Constructed.push_back(SubMatcher);
 505       }
 506     }
 507
 508     if (Constructed.empty()) return VariantMatcher(); // No overload matched.
 509     // We ignore the errors if any matcher succeeded.
 510     Ctx.revertErrors();
 511     if (Constructed.size() > 1) {
 512       // More than one constructed. It is ambiguous.
 513       Error->addError(NameRange, Error->ET_RegistryAmbiguousOverload);
 514       return VariantMatcher();
 515     }
 516     return Constructed[0];
 517   }
 518
 519   bool isVariadic() const override {
 520     bool Overload0Variadic = Overloads[0]->isVariadic();
 521 #ifndef NDEBUG
 522     for (const auto &O : Overloads) {
 523       assert(Overload0Variadic == O->isVariadic());
 524     }
 525 #endif
 526     return Overload0Variadic;
 527   }
 528
 529   unsigned getNumArgs() const override {
 530     unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
 531 #ifndef NDEBUG
 532     for (const auto &O : Overloads) {
 533       assert(Overload0NumArgs == O->getNumArgs());
 534     }
 535 #endif
 536     return Overload0NumArgs;
 537   }
 538
 539   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
 540                    std::vector<ArgKind> &Kinds) const override {
 541     for (const auto &O : Overloads) {
 542       if (O->isConvertibleTo(ThisKind))
 543         O->getArgKinds(ThisKind, ArgNo, Kinds);
 544     }
 545   }
 546
 547   bool isConvertibleTo(
 548       ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 549       ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
 550     for (const auto &O : Overloads) {
 551       if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
 552         return true;
 553     }
 554     return false;
 555   }
 556
 557 private:
 558   std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
 559 };
 560
 561 /// \brief Variadic operator marshaller function.
 562 class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
 563 public:
 564   typedef DynTypedMatcher::VariadicOperator VarOp;
 565   VariadicOperatorMatcherDescriptor(unsigned MinCount, unsigned MaxCount,
 566                                     VarOp Op, StringRef MatcherName)
 567       : MinCount(MinCount), MaxCount(MaxCount), Op(Op),
 568         MatcherName(MatcherName) {}
 569
 570   VariantMatcher create(SourceRange NameRange,
 571                         ArrayRef<ParserValue> Args,
 572                         Diagnostics *Error) const override {
 573     if (Args.size() < MinCount || MaxCount < Args.size()) {
 574       const std::string MaxStr =
 575           (MaxCount == UINT_MAX ? "" : Twine(MaxCount)).str();
 576       Error->addError(NameRange, Error->ET_RegistryWrongArgCount)
 577           << ("(" + Twine(MinCount) + ", " + MaxStr + ")") << Args.size();
 578       return VariantMatcher();
 579     }
 580
 581     std::vector<VariantMatcher> InnerArgs;
 582     for (size_t i = 0, e = Args.size(); i != e; ++i) {
 583       const ParserValue &Arg = Args[i];
 584       const VariantValue &Value = Arg.Value;
 585       if (!Value.isMatcher()) {
 586         Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
 587             << (i + 1) << "Matcher<>" << Value.getTypeAsString();
 588         return VariantMatcher();
 589       }
 590       InnerArgs.push_back(Value.getMatcher());
 591     }
 592     return VariantMatcher::VariadicOperatorMatcher(Op, std::move(InnerArgs));
 593   }
 594
 595   bool isVariadic() const override { return true; }
 596   unsigned getNumArgs() const override { return 0; }
 597   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
 598                    std::vector<ArgKind> &Kinds) const override {
 599     Kinds.push_back(ThisKind);
 600   }
 601   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
 602                        ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
 603     if (Specificity)
 604       *Specificity = 1;
 605     if (LeastDerivedKind)
 606       *LeastDerivedKind = Kind;
 607     return true;
 608   }
 609   bool isPolymorphic() const override { return true; }
 610
 611 private:
 612   const unsigned MinCount;
 613   const unsigned MaxCount;
 614   const VarOp Op;
 615   const StringRef MatcherName;
 616 };
 617
 618 /// Helper functions to select the appropriate marshaller functions.
 619 /// They detect the number of arguments, arguments types and return type.
 620
 621 /// \brief 0-arg overload
 622 template <typename ReturnType>
 623 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(),
 624                                      StringRef MatcherName) {
 625   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
 626   BuildReturnTypeVector<ReturnType>::build(RetTypes);
 627   return new FixedArgCountMatcherDescriptor(
 628       matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
 629       MatcherName, RetTypes, None);
 630 }
 631
 632 /// \brief 1-arg overload
 633 template <typename ReturnType, typename ArgType1>
 634 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
 635                                      StringRef MatcherName) {
 636   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
 637   BuildReturnTypeVector<ReturnType>::build(RetTypes);
 638   ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
 639   return new FixedArgCountMatcherDescriptor(
 640       matcherMarshall1<ReturnType, ArgType1>,
 641       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AK);
 642 }
 643
 644 /// \brief 2-arg overload
 645 template <typename ReturnType, typename ArgType1, typename ArgType2>
 646 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
 647                                      StringRef MatcherName) {
 648   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
 649   BuildReturnTypeVector<ReturnType>::build(RetTypes);
 650   ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
 651                     ArgTypeTraits<ArgType2>::getKind() };
 652   return new FixedArgCountMatcherDescriptor(
 653       matcherMarshall2<ReturnType, ArgType1, ArgType2>,
 654       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AKs);
 655 }
 656
 657 /// \brief Variadic overload.
 658 template <typename ResultT, typename ArgT,
 659           ResultT (*Func)(ArrayRef<const ArgT *>)>
 660 MatcherDescriptor *
 661 makeMatcherAutoMarshall(llvm::VariadicFunction<ResultT, ArgT, Func> VarFunc,
 662                         StringRef MatcherName) {
 663   return new VariadicFuncMatcherDescriptor(VarFunc, MatcherName);
 664 }
 665
 666 /// \brief Overload for VariadicDynCastAllOfMatchers.
 667 ///
 668 /// Not strictly necessary, but DynCastAllOfMatcherDescriptor gives us better
 669 /// completion results for that type of matcher.
 670 template <typename BaseT, typename DerivedT>
 671 MatcherDescriptor *
 672 makeMatcherAutoMarshall(ast_matchers::internal::VariadicDynCastAllOfMatcher<
 673                             BaseT, DerivedT> VarFunc,
 674                         StringRef MatcherName) {
 675   return new DynCastAllOfMatcherDescriptor(VarFunc, MatcherName);
 676 }
 677
 678 /// \brief Argument adaptative overload.
 679 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
 680           typename FromTypes, typename ToTypes>
 681 MatcherDescriptor *
 682 makeMatcherAutoMarshall(ast_matchers::internal::ArgumentAdaptingMatcherFunc<
 683                             ArgumentAdapterT, FromTypes, ToTypes>,
 684                         StringRef MatcherName) {
 685   std::vector<MatcherDescriptor *> Overloads;
 686   AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>(MatcherName,
 687                                                                     Overloads);
 688   return new OverloadedMatcherDescriptor(Overloads);
 689 }
 690
 691 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
 692           typename FromTypes, typename ToTypes>
 693 template <typename FromTypeList>
 694 inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
 695                                         ToTypes>::collect(FromTypeList) {
 696   Out.push_back(makeMatcherAutoMarshall(
 697       &AdaptativeFunc::template create<typename FromTypeList::head>, Name));
 698   collect(typename FromTypeList::tail());
 699 }
 700
 701 /// \brief Variadic operator overload.
 702 template <unsigned MinCount, unsigned MaxCount>
 703 MatcherDescriptor *
 704 makeMatcherAutoMarshall(ast_matchers::internal::VariadicOperatorMatcherFunc<
 705                             MinCount, MaxCount> Func,
 706                         StringRef MatcherName) {
 707   return new VariadicOperatorMatcherDescriptor(MinCount, MaxCount, Func.Op,
 708                                                MatcherName);
 709 }
 710
 711 }  // namespace internal
 712 }  // namespace dynamic
 713 }  // namespace ast_matchers
 714 }  // namespace clang
 715
 716 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H