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
30namespace clang {
31namespace ast_matchers {
32namespace dynamic {
33
34namespace internal {
35
36struct 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
71private:
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.
79template <class T> struct ArgTypeTraits;
80template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
81};
82
83template <> 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
93template <>
94struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
95};
96
97template <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
109template <> 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.
123class MatcherDescriptor {
124public:
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
160inline 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.
186class FixedArgCountMatcherDescriptor : public MatcherDescriptor {
187public:
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
225private:
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.
235template <class PolyMatcher>
236static void mergePolyMatchers(const PolyMatcher &Poly,
237                              std::vector<DynTypedMatcher> &Out,
238                              ast_matchers::internal::EmptyTypeList) {}
239
240template <class PolyMatcher, class TypeList>
241static 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.
253static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
254  return VariantMatcher::SingleMatcher(Matcher);
255}
256
257template <typename T>
258static 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
267template <typename T>
268inline 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
275template <>
276inline void
277buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
278    std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
279
280template <typename T>
281struct BuildReturnTypeVector {
282  static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
283    buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
284  }
285};
286
287template <typename T>
288struct 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
294template <typename T>
295struct 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.
302template <typename ResultT, typename ArgT,
303          ResultT (*Func)(ArrayRef<const ArgT *>)>
304VariantMatcher
305variadicMatcherDescriptor(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.
343class VariadicFuncMatcherDescriptor : public MatcherDescriptor {
344public:
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
377private:
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.
385class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
386public:
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
414private:
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.
436template <typename ReturnType>
437static 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.
447template <typename ReturnType, typename ArgType1>
448static 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.
460template <typename ReturnType, typename ArgType1, typename ArgType2>
461static 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.
479template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
480          typename FromTypes, typename ToTypes>
481class AdaptativeOverloadCollector {
482public:
483  AdaptativeOverloadCollector(StringRef Name,
484                              std::vector<MatcherDescriptor *> &Out)
485      : Name(Name), Out(Out) {
486    collect(FromTypes());
487  }
488
489private:
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.
510class OverloadedMatcherDescriptor : public MatcherDescriptor {
511public:
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
577private:
578  std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
579};
580
581/// \brief Variadic operator marshaller function.
582class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
583public:
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
631private:
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
642template <typename ReturnType>
643MatcherDescriptor *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
653template <typename ReturnType, typename ArgType1>
654MatcherDescriptor *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
665template <typename ReturnType, typename ArgType1, typename ArgType2>
666MatcherDescriptor *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.
678template <typename ResultT, typename ArgT,
679          ResultT (*Func)(ArrayRef<const ArgT *>)>
680MatcherDescriptor *
681makeMatcherAutoMarshall(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.
690template <typename BaseT, typename DerivedT>
691MatcherDescriptor *
692makeMatcherAutoMarshall(ast_matchers::internal::VariadicDynCastAllOfMatcher<
693                            BaseT, DerivedT> VarFunc,
694                        StringRef MatcherName) {
695  return new DynCastAllOfMatcherDescriptor(VarFunc, MatcherName);
696}
697
698/// \brief Argument adaptative overload.
699template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
700          typename FromTypes, typename ToTypes>
701MatcherDescriptor *
702makeMatcherAutoMarshall(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
711template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
712          typename FromTypes, typename ToTypes>
713template <typename FromTypeList>
714inline 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.
722template <unsigned MinCount, unsigned MaxCount>
723MatcherDescriptor *
724makeMatcherAutoMarshall(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