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