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