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