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 "clang/Basic/TypeTraits.h"
31 #include "llvm/ADT/ArrayRef.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 "llvm/Support/Regex.h"
37 #include <cassert>
38 #include <cstddef>
39 #include <iterator>
40 #include <limits>
41 #include <memory>
42 #include <optional>
43 #include <string>
44 #include <utility>
45 #include <vector>
46 
47 namespace clang {
48 namespace ast_matchers {
49 namespace dynamic {
50 namespace internal {
51 
52 /// Helper template class to just from argument type to the right is/get
53 ///   functions in VariantValue.
54 /// Used to verify and extract the matcher arguments below.
55 template <class T> struct ArgTypeTraits;
56 template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
57 };
58 
59 template <> struct ArgTypeTraits<std::string> {
60   static bool hasCorrectType(const VariantValue &Value) {
61     return Value.isString();
62   }
63   static bool hasCorrectValue(const VariantValue &Value) { return true; }
64 
65   static const std::string &get(const VariantValue &Value) {
66     return Value.getString();
67   }
68 
69   static ArgKind getKind() {
70     return ArgKind(ArgKind::AK_String);
71   }
72 
73   static std::optional<std::string> getBestGuess(const VariantValue &) {
74     return std::nullopt;
75   }
76 };
77 
78 template <>
79 struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
80 };
81 
82 template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T>> {
83   static bool hasCorrectType(const VariantValue& Value) {
84     return Value.isMatcher();
85   }
86   static bool hasCorrectValue(const VariantValue &Value) {
87     return Value.getMatcher().hasTypedMatcher<T>();
88   }
89 
90   static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
91     return Value.getMatcher().getTypedMatcher<T>();
92   }
93 
94   static ArgKind getKind() {
95     return ArgKind::MakeMatcherArg(ASTNodeKind::getFromNodeKind<T>());
96   }
97 
98   static std::optional<std::string> getBestGuess(const VariantValue &) {
99     return std::nullopt;
100   }
101 };
102 
103 template <> struct ArgTypeTraits<bool> {
104   static bool hasCorrectType(const VariantValue &Value) {
105     return Value.isBoolean();
106   }
107   static bool hasCorrectValue(const VariantValue &Value) { return true; }
108 
109   static bool get(const VariantValue &Value) {
110     return Value.getBoolean();
111   }
112 
113   static ArgKind getKind() {
114     return ArgKind(ArgKind::AK_Boolean);
115   }
116 
117   static std::optional<std::string> getBestGuess(const VariantValue &) {
118     return std::nullopt;
119   }
120 };
121 
122 template <> struct ArgTypeTraits<double> {
123   static bool hasCorrectType(const VariantValue &Value) {
124     return Value.isDouble();
125   }
126   static bool hasCorrectValue(const VariantValue &Value) { return true; }
127 
128   static double get(const VariantValue &Value) {
129     return Value.getDouble();
130   }
131 
132   static ArgKind getKind() {
133     return ArgKind(ArgKind::AK_Double);
134   }
135 
136   static std::optional<std::string> getBestGuess(const VariantValue &) {
137     return std::nullopt;
138   }
139 };
140 
141 template <> struct ArgTypeTraits<unsigned> {
142   static bool hasCorrectType(const VariantValue &Value) {
143     return Value.isUnsigned();
144   }
145   static bool hasCorrectValue(const VariantValue &Value) { return true; }
146 
147   static unsigned get(const VariantValue &Value) {
148     return Value.getUnsigned();
149   }
150 
151   static ArgKind getKind() {
152     return ArgKind(ArgKind::AK_Unsigned);
153   }
154 
155   static std::optional<std::string> getBestGuess(const VariantValue &) {
156     return std::nullopt;
157   }
158 };
159 
160 template <> struct ArgTypeTraits<attr::Kind> {
161 private:
162   static std::optional<attr::Kind> getAttrKind(llvm::StringRef AttrKind) {
163     if (!AttrKind.consume_front("attr::"))
164       return std::nullopt;
165     return llvm::StringSwitch<std::optional<attr::Kind>>(AttrKind)
166 #define ATTR(X) .Case(#X, attr::X)
167 #include "clang/Basic/AttrList.inc"
168         .Default(std::nullopt);
169   }
170 
171 public:
172   static bool hasCorrectType(const VariantValue &Value) {
173     return Value.isString();
174   }
175   static bool hasCorrectValue(const VariantValue& Value) {
176     return getAttrKind(Value.getString()).has_value();
177   }
178 
179   static attr::Kind get(const VariantValue &Value) {
180     return *getAttrKind(Value.getString());
181   }
182 
183   static ArgKind getKind() {
184     return ArgKind(ArgKind::AK_String);
185   }
186 
187   static std::optional<std::string> getBestGuess(const VariantValue &Value);
188 };
189 
190 template <> struct ArgTypeTraits<CastKind> {
191 private:
192   static std::optional<CastKind> getCastKind(llvm::StringRef AttrKind) {
193     if (!AttrKind.consume_front("CK_"))
194       return std::nullopt;
195     return llvm::StringSwitch<std::optional<CastKind>>(AttrKind)
196 #define CAST_OPERATION(Name) .Case(#Name, CK_##Name)
197 #include "clang/AST/OperationKinds.def"
198         .Default(std::nullopt);
199   }
200 
201 public:
202   static bool hasCorrectType(const VariantValue &Value) {
203     return Value.isString();
204   }
205   static bool hasCorrectValue(const VariantValue& Value) {
206     return getCastKind(Value.getString()).has_value();
207   }
208 
209   static CastKind get(const VariantValue &Value) {
210     return *getCastKind(Value.getString());
211   }
212 
213   static ArgKind getKind() {
214     return ArgKind(ArgKind::AK_String);
215   }
216 
217   static std::optional<std::string> getBestGuess(const VariantValue &Value);
218 };
219 
220 template <> struct ArgTypeTraits<llvm::Regex::RegexFlags> {
221 private:
222   static std::optional<llvm::Regex::RegexFlags> getFlags(llvm::StringRef Flags);
223 
224 public:
225   static bool hasCorrectType(const VariantValue &Value) {
226     return Value.isString();
227   }
228   static bool hasCorrectValue(const VariantValue& Value) {
229     return getFlags(Value.getString()).has_value();
230   }
231 
232   static llvm::Regex::RegexFlags get(const VariantValue &Value) {
233     return *getFlags(Value.getString());
234   }
235 
236   static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
237 
238   static std::optional<std::string> getBestGuess(const VariantValue &Value);
239 };
240 
241 template <> struct ArgTypeTraits<OpenMPClauseKind> {
242 private:
243   static std::optional<OpenMPClauseKind>
244   getClauseKind(llvm::StringRef ClauseKind) {
245     return llvm::StringSwitch<std::optional<OpenMPClauseKind>>(ClauseKind)
246 #define GEN_CLANG_CLAUSE_CLASS
247 #define CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
248 #include "llvm/Frontend/OpenMP/OMP.inc"
249         .Default(std::nullopt);
250   }
251 
252 public:
253   static bool hasCorrectType(const VariantValue &Value) {
254     return Value.isString();
255   }
256   static bool hasCorrectValue(const VariantValue& Value) {
257     return getClauseKind(Value.getString()).has_value();
258   }
259 
260   static OpenMPClauseKind get(const VariantValue &Value) {
261     return *getClauseKind(Value.getString());
262   }
263 
264   static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
265 
266   static std::optional<std::string> getBestGuess(const VariantValue &Value);
267 };
268 
269 template <> struct ArgTypeTraits<UnaryExprOrTypeTrait> {
270 private:
271   static std::optional<UnaryExprOrTypeTrait>
272   getUnaryOrTypeTraitKind(llvm::StringRef ClauseKind) {
273     if (!ClauseKind.consume_front("UETT_"))
274       return std::nullopt;
275     return llvm::StringSwitch<std::optional<UnaryExprOrTypeTrait>>(ClauseKind)
276 #define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) .Case(#Name, UETT_##Name)
277 #define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key)                    \
278   .Case(#Name, UETT_##Name)
279 #include "clang/Basic/TokenKinds.def"
280         .Default(std::nullopt);
281   }
282 
283 public:
284   static bool hasCorrectType(const VariantValue &Value) {
285     return Value.isString();
286   }
287   static bool hasCorrectValue(const VariantValue& Value) {
288     return getUnaryOrTypeTraitKind(Value.getString()).has_value();
289   }
290 
291   static UnaryExprOrTypeTrait get(const VariantValue &Value) {
292     return *getUnaryOrTypeTraitKind(Value.getString());
293   }
294 
295   static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
296 
297   static std::optional<std::string> getBestGuess(const VariantValue &Value);
298 };
299 
300 /// Matcher descriptor interface.
301 ///
302 /// Provides a \c create() method that constructs the matcher from the provided
303 /// arguments, and various other methods for type introspection.
304 class MatcherDescriptor {
305 public:
306   virtual ~MatcherDescriptor() = default;
307 
308   virtual VariantMatcher create(SourceRange NameRange,
309                                 ArrayRef<ParserValue> Args,
310                                 Diagnostics *Error) const = 0;
311 
312   virtual ASTNodeKind nodeMatcherType() const { return ASTNodeKind(); }
313 
314   virtual bool isBuilderMatcher() const { return false; }
315 
316   virtual std::unique_ptr<MatcherDescriptor>
317   buildMatcherCtor(SourceRange NameRange, ArrayRef<ParserValue> Args,
318                    Diagnostics *Error) const {
319     return {};
320   }
321 
322   /// Returns whether the matcher is variadic. Variadic matchers can take any
323   /// number of arguments, but they must be of the same type.
324   virtual bool isVariadic() const = 0;
325 
326   /// Returns the number of arguments accepted by the matcher if not variadic.
327   virtual unsigned getNumArgs() const = 0;
328 
329   /// Given that the matcher is being converted to type \p ThisKind, append the
330   /// set of argument types accepted for argument \p ArgNo to \p ArgKinds.
331   // FIXME: We should provide the ability to constrain the output of this
332   // function based on the types of other matcher arguments.
333   virtual void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
334                            std::vector<ArgKind> &ArgKinds) const = 0;
335 
336   /// Returns whether this matcher is convertible to the given type.  If it is
337   /// so convertible, store in *Specificity a value corresponding to the
338   /// "specificity" of the converted matcher to the given context, and in
339   /// *LeastDerivedKind the least derived matcher kind which would result in the
340   /// same matcher overload.  Zero specificity indicates that this conversion
341   /// would produce a trivial matcher that will either always or never match.
342   /// Such matchers are excluded from code completion results.
343   virtual bool
344   isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity = nullptr,
345                   ASTNodeKind *LeastDerivedKind = nullptr) const = 0;
346 
347   /// Returns whether the matcher will, given a matcher of any type T, yield a
348   /// matcher of type T.
349   virtual bool isPolymorphic() const { return false; }
350 };
351 
352 inline bool isRetKindConvertibleTo(ArrayRef<ASTNodeKind> RetKinds,
353                                    ASTNodeKind Kind, unsigned *Specificity,
354                                    ASTNodeKind *LeastDerivedKind) {
355   for (const ASTNodeKind &NodeKind : RetKinds) {
356     if (ArgKind::MakeMatcherArg(NodeKind).isConvertibleTo(
357             ArgKind::MakeMatcherArg(Kind), Specificity)) {
358       if (LeastDerivedKind)
359         *LeastDerivedKind = NodeKind;
360       return true;
361     }
362   }
363   return false;
364 }
365 
366 /// Simple callback implementation. Marshaller and function are provided.
367 ///
368 /// This class wraps a function of arbitrary signature and a marshaller
369 /// function into a MatcherDescriptor.
370 /// The marshaller is in charge of taking the VariantValue arguments, checking
371 /// their types, unpacking them and calling the underlying function.
372 class FixedArgCountMatcherDescriptor : public MatcherDescriptor {
373 public:
374   using MarshallerType = VariantMatcher (*)(void (*Func)(),
375                                             StringRef MatcherName,
376                                             SourceRange NameRange,
377                                             ArrayRef<ParserValue> Args,
378                                             Diagnostics *Error);
379 
380   /// \param Marshaller Function to unpack the arguments and call \c Func
381   /// \param Func Matcher construct function. This is the function that
382   ///   compile-time matcher expressions would use to create the matcher.
383   /// \param RetKinds The list of matcher types to which the matcher is
384   ///   convertible.
385   /// \param ArgKinds The types of the arguments this matcher takes.
386   FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void (*Func)(),
387                                  StringRef MatcherName,
388                                  ArrayRef<ASTNodeKind> RetKinds,
389                                  ArrayRef<ArgKind> ArgKinds)
390       : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
391         RetKinds(RetKinds.begin(), RetKinds.end()),
392         ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
393 
394   VariantMatcher create(SourceRange NameRange,
395                         ArrayRef<ParserValue> Args,
396                         Diagnostics *Error) const override {
397     return Marshaller(Func, MatcherName, NameRange, Args, Error);
398   }
399 
400   bool isVariadic() const override { return false; }
401   unsigned getNumArgs() const override { return ArgKinds.size(); }
402 
403   void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
404                    std::vector<ArgKind> &Kinds) const override {
405     Kinds.push_back(ArgKinds[ArgNo]);
406   }
407 
408   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
409                        ASTNodeKind *LeastDerivedKind) const override {
410     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
411                                   LeastDerivedKind);
412   }
413 
414 private:
415   const MarshallerType Marshaller;
416   void (* const Func)();
417   const std::string MatcherName;
418   const std::vector<ASTNodeKind> RetKinds;
419   const std::vector<ArgKind> ArgKinds;
420 };
421 
422 /// Helper methods to extract and merge all possible typed matchers
423 /// out of the polymorphic object.
424 template <class PolyMatcher>
425 static void mergePolyMatchers(const PolyMatcher &Poly,
426                               std::vector<DynTypedMatcher> &Out,
427                               ast_matchers::internal::EmptyTypeList) {}
428 
429 template <class PolyMatcher, class TypeList>
430 static void mergePolyMatchers(const PolyMatcher &Poly,
431                               std::vector<DynTypedMatcher> &Out, TypeList) {
432   Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
433   mergePolyMatchers(Poly, Out, typename TypeList::tail());
434 }
435 
436 /// Convert the return values of the functions into a VariantMatcher.
437 ///
438 /// There are 2 cases right now: The return value is a Matcher<T> or is a
439 /// polymorphic matcher. For the former, we just construct the VariantMatcher.
440 /// For the latter, we instantiate all the possible Matcher<T> of the poly
441 /// matcher.
442 inline VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
443   return VariantMatcher::SingleMatcher(Matcher);
444 }
445 
446 template <typename T>
447 static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
448                                                typename T::ReturnTypes * =
449                                                    nullptr) {
450   std::vector<DynTypedMatcher> Matchers;
451   mergePolyMatchers(PolyMatcher, Matchers, typename T::ReturnTypes());
452   VariantMatcher Out = VariantMatcher::PolymorphicMatcher(std::move(Matchers));
453   return Out;
454 }
455 
456 template <typename T>
457 inline void
458 buildReturnTypeVectorFromTypeList(std::vector<ASTNodeKind> &RetTypes) {
459   RetTypes.push_back(ASTNodeKind::getFromNodeKind<typename T::head>());
460   buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
461 }
462 
463 template <>
464 inline void
465 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
466     std::vector<ASTNodeKind> &RetTypes) {}
467 
468 template <typename T>
469 struct BuildReturnTypeVector {
470   static void build(std::vector<ASTNodeKind> &RetTypes) {
471     buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
472   }
473 };
474 
475 template <typename T>
476 struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T>> {
477   static void build(std::vector<ASTNodeKind> &RetTypes) {
478     RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
479   }
480 };
481 
482 template <typename T>
483 struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T>> {
484   static void build(std::vector<ASTNodeKind> &RetTypes) {
485     RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
486   }
487 };
488 
489 /// Variadic marshaller function.
490 template <typename ResultT, typename ArgT,
491           ResultT (*Func)(ArrayRef<const ArgT *>)>
492 VariantMatcher
493 variadicMatcherDescriptor(StringRef MatcherName, SourceRange NameRange,
494                           ArrayRef<ParserValue> Args, Diagnostics *Error) {
495   SmallVector<ArgT *, 8> InnerArgsPtr;
496   InnerArgsPtr.resize_for_overwrite(Args.size());
497   SmallVector<ArgT, 8> InnerArgs;
498   InnerArgs.reserve(Args.size());
499 
500   for (size_t i = 0, e = Args.size(); i != e; ++i) {
501     using ArgTraits = ArgTypeTraits<ArgT>;
502 
503     const ParserValue &Arg = Args[i];
504     const VariantValue &Value = Arg.Value;
505     if (!ArgTraits::hasCorrectType(Value)) {
506       Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
507           << (i + 1) << ArgTraits::getKind().asString() << Value.getTypeAsString();
508       return {};
509     }
510     if (!ArgTraits::hasCorrectValue(Value)) {
511       if (std::optional<std::string> BestGuess =
512               ArgTraits::getBestGuess(Value)) {
513         Error->addError(Arg.Range, Error->ET_RegistryUnknownEnumWithReplace)
514             << i + 1 << Value.getString() << *BestGuess;
515       } else if (Value.isString()) {
516         Error->addError(Arg.Range, Error->ET_RegistryValueNotFound)
517             << Value.getString();
518       } else {
519         // This isn't ideal, but it's better than reporting an empty string as
520         // the error in this case.
521         Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
522             << (i + 1) << ArgTraits::getKind().asString()
523             << Value.getTypeAsString();
524       }
525       return {};
526     }
527     assert(InnerArgs.size() < InnerArgs.capacity());
528     InnerArgs.emplace_back(ArgTraits::get(Value));
529     InnerArgsPtr[i] = &InnerArgs[i];
530   }
531   return outvalueToVariantMatcher(Func(InnerArgsPtr));
532 }
533 
534 /// Matcher descriptor for variadic functions.
535 ///
536 /// This class simply wraps a VariadicFunction with the right signature to export
537 /// it as a MatcherDescriptor.
538 /// This allows us to have one implementation of the interface for as many free
539 /// functions as we want, reducing the number of symbols and size of the
540 /// object file.
541 class VariadicFuncMatcherDescriptor : public MatcherDescriptor {
542 public:
543   using RunFunc = VariantMatcher (*)(StringRef MatcherName,
544                                      SourceRange NameRange,
545                                      ArrayRef<ParserValue> Args,
546                                      Diagnostics *Error);
547 
548   template <typename ResultT, typename ArgT,
549             ResultT (*F)(ArrayRef<const ArgT *>)>
550   VariadicFuncMatcherDescriptor(
551       ast_matchers::internal::VariadicFunction<ResultT, ArgT, F> Func,
552       StringRef MatcherName)
553       : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
554         MatcherName(MatcherName.str()),
555         ArgsKind(ArgTypeTraits<ArgT>::getKind()) {
556     BuildReturnTypeVector<ResultT>::build(RetKinds);
557   }
558 
559   VariantMatcher create(SourceRange NameRange,
560                         ArrayRef<ParserValue> Args,
561                         Diagnostics *Error) const override {
562     return Func(MatcherName, NameRange, Args, Error);
563   }
564 
565   bool isVariadic() const override { return true; }
566   unsigned getNumArgs() const override { return 0; }
567 
568   void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
569                    std::vector<ArgKind> &Kinds) const override {
570     Kinds.push_back(ArgsKind);
571   }
572 
573   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
574                        ASTNodeKind *LeastDerivedKind) const override {
575     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
576                                   LeastDerivedKind);
577   }
578 
579   ASTNodeKind nodeMatcherType() const override { return RetKinds[0]; }
580 
581 private:
582   const RunFunc Func;
583   const std::string MatcherName;
584   std::vector<ASTNodeKind> RetKinds;
585   const ArgKind ArgsKind;
586 };
587 
588 /// Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
589 class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
590 public:
591   template <typename BaseT, typename DerivedT>
592   DynCastAllOfMatcherDescriptor(
593       ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
594       StringRef MatcherName)
595       : VariadicFuncMatcherDescriptor(Func, MatcherName),
596         DerivedKind(ASTNodeKind::getFromNodeKind<DerivedT>()) {}
597 
598   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
599                        ASTNodeKind *LeastDerivedKind) const override {
600     // If Kind is not a base of DerivedKind, either DerivedKind is a base of
601     // Kind (in which case the match will always succeed) or Kind and
602     // DerivedKind are unrelated (in which case it will always fail), so set
603     // Specificity to 0.
604     if (VariadicFuncMatcherDescriptor::isConvertibleTo(Kind, Specificity,
605                                                  LeastDerivedKind)) {
606       if (Kind.isSame(DerivedKind) || !Kind.isBaseOf(DerivedKind)) {
607         if (Specificity)
608           *Specificity = 0;
609       }
610       return true;
611     } else {
612       return false;
613     }
614   }
615 
616   ASTNodeKind nodeMatcherType() const override { return DerivedKind; }
617 
618 private:
619   const ASTNodeKind DerivedKind;
620 };
621 
622 /// Helper macros to check the arguments on all marshaller functions.
623 #define CHECK_ARG_COUNT(count)                                                 \
624   if (Args.size() != count) {                                                  \
625     Error->addError(NameRange, Error->ET_RegistryWrongArgCount)                \
626         << count << Args.size();                                               \
627     return VariantMatcher();                                                   \
628   }
629 
630 #define CHECK_ARG_TYPE(index, type)                                            \
631   if (!ArgTypeTraits<type>::hasCorrectType(Args[index].Value)) {               \
632     Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType)         \
633         << (index + 1) << ArgTypeTraits<type>::getKind().asString()            \
634         << Args[index].Value.getTypeAsString();                                \
635     return VariantMatcher();                                                   \
636   }                                                                            \
637   if (!ArgTypeTraits<type>::hasCorrectValue(Args[index].Value)) {              \
638     if (std::optional<std::string> BestGuess =                                 \
639             ArgTypeTraits<type>::getBestGuess(Args[index].Value)) {            \
640       Error->addError(Args[index].Range,                                       \
641                       Error->ET_RegistryUnknownEnumWithReplace)                \
642           << index + 1 << Args[index].Value.getString() << *BestGuess;         \
643     } else if (Args[index].Value.isString()) {                                 \
644       Error->addError(Args[index].Range, Error->ET_RegistryValueNotFound)      \
645           << Args[index].Value.getString();                                    \
646     }                                                                          \
647     return VariantMatcher();                                                   \
648   }
649 
650 /// 0-arg marshaller function.
651 template <typename ReturnType>
652 static VariantMatcher matcherMarshall0(void (*Func)(), StringRef MatcherName,
653                                        SourceRange NameRange,
654                                        ArrayRef<ParserValue> Args,
655                                        Diagnostics *Error) {
656   using FuncType = ReturnType (*)();
657   CHECK_ARG_COUNT(0);
658   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)());
659 }
660 
661 /// 1-arg marshaller function.
662 template <typename ReturnType, typename ArgType1>
663 static VariantMatcher matcherMarshall1(void (*Func)(), StringRef MatcherName,
664                                        SourceRange NameRange,
665                                        ArrayRef<ParserValue> Args,
666                                        Diagnostics *Error) {
667   using FuncType = ReturnType (*)(ArgType1);
668   CHECK_ARG_COUNT(1);
669   CHECK_ARG_TYPE(0, ArgType1);
670   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
671       ArgTypeTraits<ArgType1>::get(Args[0].Value)));
672 }
673 
674 /// 2-arg marshaller function.
675 template <typename ReturnType, typename ArgType1, typename ArgType2>
676 static VariantMatcher matcherMarshall2(void (*Func)(), StringRef MatcherName,
677                                        SourceRange NameRange,
678                                        ArrayRef<ParserValue> Args,
679                                        Diagnostics *Error) {
680   using FuncType = ReturnType (*)(ArgType1, ArgType2);
681   CHECK_ARG_COUNT(2);
682   CHECK_ARG_TYPE(0, ArgType1);
683   CHECK_ARG_TYPE(1, ArgType2);
684   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
685       ArgTypeTraits<ArgType1>::get(Args[0].Value),
686       ArgTypeTraits<ArgType2>::get(Args[1].Value)));
687 }
688 
689 #undef CHECK_ARG_COUNT
690 #undef CHECK_ARG_TYPE
691 
692 /// Helper class used to collect all the possible overloads of an
693 ///   argument adaptative matcher function.
694 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
695           typename FromTypes, typename ToTypes>
696 class AdaptativeOverloadCollector {
697 public:
698   AdaptativeOverloadCollector(
699       StringRef Name, std::vector<std::unique_ptr<MatcherDescriptor>> &Out)
700       : Name(Name), Out(Out) {
701     collect(FromTypes());
702   }
703 
704 private:
705   using AdaptativeFunc = ast_matchers::internal::ArgumentAdaptingMatcherFunc<
706       ArgumentAdapterT, FromTypes, ToTypes>;
707 
708   /// End case for the recursion
709   static void collect(ast_matchers::internal::EmptyTypeList) {}
710 
711   /// Recursive case. Get the overload for the head of the list, and
712   ///   recurse to the tail.
713   template <typename FromTypeList>
714   inline void collect(FromTypeList);
715 
716   StringRef Name;
717   std::vector<std::unique_ptr<MatcherDescriptor>> &Out;
718 };
719 
720 /// MatcherDescriptor that wraps multiple "overloads" of the same
721 ///   matcher.
722 ///
723 /// It will try every overload and generate appropriate errors for when none or
724 /// more than one overloads match the arguments.
725 class OverloadedMatcherDescriptor : public MatcherDescriptor {
726 public:
727   OverloadedMatcherDescriptor(
728       MutableArrayRef<std::unique_ptr<MatcherDescriptor>> Callbacks)
729       : Overloads(std::make_move_iterator(Callbacks.begin()),
730                   std::make_move_iterator(Callbacks.end())) {}
731 
732   ~OverloadedMatcherDescriptor() override = default;
733 
734   VariantMatcher create(SourceRange NameRange,
735                         ArrayRef<ParserValue> Args,
736                         Diagnostics *Error) const override {
737     std::vector<VariantMatcher> Constructed;
738     Diagnostics::OverloadContext Ctx(Error);
739     for (const auto &O : Overloads) {
740       VariantMatcher SubMatcher = O->create(NameRange, Args, Error);
741       if (!SubMatcher.isNull()) {
742         Constructed.push_back(SubMatcher);
743       }
744     }
745 
746     if (Constructed.empty()) return VariantMatcher(); // No overload matched.
747     // We ignore the errors if any matcher succeeded.
748     Ctx.revertErrors();
749     if (Constructed.size() > 1) {
750       // More than one constructed. It is ambiguous.
751       Error->addError(NameRange, Error->ET_RegistryAmbiguousOverload);
752       return VariantMatcher();
753     }
754     return Constructed[0];
755   }
756 
757   bool isVariadic() const override {
758     bool Overload0Variadic = Overloads[0]->isVariadic();
759 #ifndef NDEBUG
760     for (const auto &O : Overloads) {
761       assert(Overload0Variadic == O->isVariadic());
762     }
763 #endif
764     return Overload0Variadic;
765   }
766 
767   unsigned getNumArgs() const override {
768     unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
769 #ifndef NDEBUG
770     for (const auto &O : Overloads) {
771       assert(Overload0NumArgs == O->getNumArgs());
772     }
773 #endif
774     return Overload0NumArgs;
775   }
776 
777   void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
778                    std::vector<ArgKind> &Kinds) const override {
779     for (const auto &O : Overloads) {
780       if (O->isConvertibleTo(ThisKind))
781         O->getArgKinds(ThisKind, ArgNo, Kinds);
782     }
783   }
784 
785   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
786                        ASTNodeKind *LeastDerivedKind) const override {
787     for (const auto &O : Overloads) {
788       if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
789         return true;
790     }
791     return false;
792   }
793 
794 private:
795   std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
796 };
797 
798 template <typename ReturnType>
799 class RegexMatcherDescriptor : public MatcherDescriptor {
800 public:
801   RegexMatcherDescriptor(ReturnType (*WithFlags)(StringRef,
802                                                  llvm::Regex::RegexFlags),
803                          ReturnType (*NoFlags)(StringRef),
804                          ArrayRef<ASTNodeKind> RetKinds)
805       : WithFlags(WithFlags), NoFlags(NoFlags),
806         RetKinds(RetKinds.begin(), RetKinds.end()) {}
807   bool isVariadic() const override { return true; }
808   unsigned getNumArgs() const override { return 0; }
809 
810   void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
811                    std::vector<ArgKind> &Kinds) const override {
812     assert(ArgNo < 2);
813     Kinds.push_back(ArgKind::AK_String);
814   }
815 
816   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
817                        ASTNodeKind *LeastDerivedKind) const override {
818     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
819                                   LeastDerivedKind);
820   }
821 
822   VariantMatcher create(SourceRange NameRange, ArrayRef<ParserValue> Args,
823                         Diagnostics *Error) const override {
824     if (Args.size() < 1 || Args.size() > 2) {
825       Error->addError(NameRange, Diagnostics::ET_RegistryWrongArgCount)
826           << "1 or 2" << Args.size();
827       return VariantMatcher();
828     }
829     if (!ArgTypeTraits<StringRef>::hasCorrectType(Args[0].Value)) {
830       Error->addError(Args[0].Range, Error->ET_RegistryWrongArgType)
831           << 1 << ArgTypeTraits<StringRef>::getKind().asString()
832           << Args[0].Value.getTypeAsString();
833       return VariantMatcher();
834     }
835     if (Args.size() == 1) {
836       return outvalueToVariantMatcher(
837           NoFlags(ArgTypeTraits<StringRef>::get(Args[0].Value)));
838     }
839     if (!ArgTypeTraits<llvm::Regex::RegexFlags>::hasCorrectType(
840             Args[1].Value)) {
841       Error->addError(Args[1].Range, Error->ET_RegistryWrongArgType)
842           << 2 << ArgTypeTraits<llvm::Regex::RegexFlags>::getKind().asString()
843           << Args[1].Value.getTypeAsString();
844       return VariantMatcher();
845     }
846     if (!ArgTypeTraits<llvm::Regex::RegexFlags>::hasCorrectValue(
847             Args[1].Value)) {
848       if (std::optional<std::string> BestGuess =
849               ArgTypeTraits<llvm::Regex::RegexFlags>::getBestGuess(
850                   Args[1].Value)) {
851         Error->addError(Args[1].Range, Error->ET_RegistryUnknownEnumWithReplace)
852             << 2 << Args[1].Value.getString() << *BestGuess;
853       } else {
854         Error->addError(Args[1].Range, Error->ET_RegistryValueNotFound)
855             << Args[1].Value.getString();
856       }
857       return VariantMatcher();
858     }
859     return outvalueToVariantMatcher(
860         WithFlags(ArgTypeTraits<StringRef>::get(Args[0].Value),
861                   ArgTypeTraits<llvm::Regex::RegexFlags>::get(Args[1].Value)));
862   }
863 
864 private:
865   ReturnType (*const WithFlags)(StringRef, llvm::Regex::RegexFlags);
866   ReturnType (*const NoFlags)(StringRef);
867   const std::vector<ASTNodeKind> RetKinds;
868 };
869 
870 /// Variadic operator marshaller function.
871 class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
872 public:
873   using VarOp = DynTypedMatcher::VariadicOperator;
874 
875   VariadicOperatorMatcherDescriptor(unsigned MinCount, unsigned MaxCount,
876                                     VarOp Op, StringRef MatcherName)
877       : MinCount(MinCount), MaxCount(MaxCount), Op(Op),
878         MatcherName(MatcherName) {}
879 
880   VariantMatcher create(SourceRange NameRange,
881                         ArrayRef<ParserValue> Args,
882                         Diagnostics *Error) const override {
883     if (Args.size() < MinCount || MaxCount < Args.size()) {
884       const std::string MaxStr =
885           (MaxCount == std::numeric_limits<unsigned>::max() ? ""
886                                                             : Twine(MaxCount))
887               .str();
888       Error->addError(NameRange, Error->ET_RegistryWrongArgCount)
889           << ("(" + Twine(MinCount) + ", " + MaxStr + ")") << Args.size();
890       return VariantMatcher();
891     }
892 
893     std::vector<VariantMatcher> InnerArgs;
894     for (size_t i = 0, e = Args.size(); i != e; ++i) {
895       const ParserValue &Arg = Args[i];
896       const VariantValue &Value = Arg.Value;
897       if (!Value.isMatcher()) {
898         Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
899             << (i + 1) << "Matcher<>" << Value.getTypeAsString();
900         return VariantMatcher();
901       }
902       InnerArgs.push_back(Value.getMatcher());
903     }
904     return VariantMatcher::VariadicOperatorMatcher(Op, std::move(InnerArgs));
905   }
906 
907   bool isVariadic() const override { return true; }
908   unsigned getNumArgs() const override { return 0; }
909 
910   void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
911                    std::vector<ArgKind> &Kinds) const override {
912     Kinds.push_back(ArgKind::MakeMatcherArg(ThisKind));
913   }
914 
915   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
916                        ASTNodeKind *LeastDerivedKind) const override {
917     if (Specificity)
918       *Specificity = 1;
919     if (LeastDerivedKind)
920       *LeastDerivedKind = Kind;
921     return true;
922   }
923 
924   bool isPolymorphic() const override { return true; }
925 
926 private:
927   const unsigned MinCount;
928   const unsigned MaxCount;
929   const VarOp Op;
930   const StringRef MatcherName;
931 };
932 
933 class MapAnyOfMatcherDescriptor : public MatcherDescriptor {
934   ASTNodeKind CladeNodeKind;
935   std::vector<ASTNodeKind> NodeKinds;
936 
937 public:
938   MapAnyOfMatcherDescriptor(ASTNodeKind CladeNodeKind,
939                             std::vector<ASTNodeKind> NodeKinds)
940       : CladeNodeKind(CladeNodeKind), NodeKinds(NodeKinds) {}
941 
942   VariantMatcher create(SourceRange NameRange, ArrayRef<ParserValue> Args,
943                         Diagnostics *Error) const override {
944 
945     std::vector<DynTypedMatcher> NodeArgs;
946 
947     for (auto NK : NodeKinds) {
948       std::vector<DynTypedMatcher> InnerArgs;
949 
950       for (const auto &Arg : Args) {
951         if (!Arg.Value.isMatcher())
952           return {};
953         const VariantMatcher &VM = Arg.Value.getMatcher();
954         if (VM.hasTypedMatcher(NK)) {
955           auto DM = VM.getTypedMatcher(NK);
956           InnerArgs.push_back(DM);
957         }
958       }
959 
960       if (InnerArgs.empty()) {
961         NodeArgs.push_back(
962             DynTypedMatcher::trueMatcher(NK).dynCastTo(CladeNodeKind));
963       } else {
964         NodeArgs.push_back(
965             DynTypedMatcher::constructVariadic(
966                 ast_matchers::internal::DynTypedMatcher::VO_AllOf, NK,
967                 InnerArgs)
968                 .dynCastTo(CladeNodeKind));
969       }
970     }
971 
972     auto Result = DynTypedMatcher::constructVariadic(
973         ast_matchers::internal::DynTypedMatcher::VO_AnyOf, CladeNodeKind,
974         NodeArgs);
975     Result.setAllowBind(true);
976     return VariantMatcher::SingleMatcher(Result);
977   }
978 
979   bool isVariadic() const override { return true; }
980   unsigned getNumArgs() const override { return 0; }
981 
982   void getArgKinds(ASTNodeKind ThisKind, unsigned,
983                    std::vector<ArgKind> &Kinds) const override {
984     Kinds.push_back(ArgKind::MakeMatcherArg(ThisKind));
985   }
986 
987   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
988                        ASTNodeKind *LeastDerivedKind) const override {
989     if (Specificity)
990       *Specificity = 1;
991     if (LeastDerivedKind)
992       *LeastDerivedKind = CladeNodeKind;
993     return true;
994   }
995 };
996 
997 class MapAnyOfBuilderDescriptor : public MatcherDescriptor {
998 public:
999   VariantMatcher create(SourceRange, ArrayRef<ParserValue>,
1000                         Diagnostics *) const override {
1001     return {};
1002   }
1003 
1004   bool isBuilderMatcher() const override { return true; }
1005 
1006   std::unique_ptr<MatcherDescriptor>
1007   buildMatcherCtor(SourceRange, ArrayRef<ParserValue> Args,
1008                    Diagnostics *) const override {
1009 
1010     std::vector<ASTNodeKind> NodeKinds;
1011     for (const auto &Arg : Args) {
1012       if (!Arg.Value.isNodeKind())
1013         return {};
1014       NodeKinds.push_back(Arg.Value.getNodeKind());
1015     }
1016 
1017     if (NodeKinds.empty())
1018       return {};
1019 
1020     ASTNodeKind CladeNodeKind = NodeKinds.front().getCladeKind();
1021 
1022     for (auto NK : NodeKinds)
1023     {
1024       if (!NK.getCladeKind().isSame(CladeNodeKind))
1025         return {};
1026     }
1027 
1028     return std::make_unique<MapAnyOfMatcherDescriptor>(CladeNodeKind,
1029                                                        NodeKinds);
1030   }
1031 
1032   bool isVariadic() const override { return true; }
1033 
1034   unsigned getNumArgs() const override { return 0; }
1035 
1036   void getArgKinds(ASTNodeKind ThisKind, unsigned,
1037                    std::vector<ArgKind> &ArgKinds) const override {
1038     ArgKinds.push_back(ArgKind::MakeNodeArg(ThisKind));
1039   }
1040   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity = nullptr,
1041                        ASTNodeKind *LeastDerivedKind = nullptr) const override {
1042     if (Specificity)
1043       *Specificity = 1;
1044     if (LeastDerivedKind)
1045       *LeastDerivedKind = Kind;
1046     return true;
1047   }
1048 
1049   bool isPolymorphic() const override { return false; }
1050 };
1051 
1052 /// Helper functions to select the appropriate marshaller functions.
1053 /// They detect the number of arguments, arguments types and return type.
1054 
1055 /// 0-arg overload
1056 template <typename ReturnType>
1057 std::unique_ptr<MatcherDescriptor>
1058 makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) {
1059   std::vector<ASTNodeKind> RetTypes;
1060   BuildReturnTypeVector<ReturnType>::build(RetTypes);
1061   return std::make_unique<FixedArgCountMatcherDescriptor>(
1062       matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
1063       MatcherName, RetTypes, std::nullopt);
1064 }
1065 
1066 /// 1-arg overload
1067 template <typename ReturnType, typename ArgType1>
1068 std::unique_ptr<MatcherDescriptor>
1069 makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1), StringRef MatcherName) {
1070   std::vector<ASTNodeKind> RetTypes;
1071   BuildReturnTypeVector<ReturnType>::build(RetTypes);
1072   ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
1073   return std::make_unique<FixedArgCountMatcherDescriptor>(
1074       matcherMarshall1<ReturnType, ArgType1>,
1075       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AK);
1076 }
1077 
1078 /// 2-arg overload
1079 template <typename ReturnType, typename ArgType1, typename ArgType2>
1080 std::unique_ptr<MatcherDescriptor>
1081 makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
1082                         StringRef MatcherName) {
1083   std::vector<ASTNodeKind> RetTypes;
1084   BuildReturnTypeVector<ReturnType>::build(RetTypes);
1085   ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
1086                     ArgTypeTraits<ArgType2>::getKind() };
1087   return std::make_unique<FixedArgCountMatcherDescriptor>(
1088       matcherMarshall2<ReturnType, ArgType1, ArgType2>,
1089       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AKs);
1090 }
1091 
1092 template <typename ReturnType>
1093 std::unique_ptr<MatcherDescriptor> makeMatcherRegexMarshall(
1094     ReturnType (*FuncFlags)(llvm::StringRef, llvm::Regex::RegexFlags),
1095     ReturnType (*Func)(llvm::StringRef)) {
1096   std::vector<ASTNodeKind> RetTypes;
1097   BuildReturnTypeVector<ReturnType>::build(RetTypes);
1098   return std::make_unique<RegexMatcherDescriptor<ReturnType>>(FuncFlags, Func,
1099                                                               RetTypes);
1100 }
1101 
1102 /// Variadic overload.
1103 template <typename ResultT, typename ArgT,
1104           ResultT (*Func)(ArrayRef<const ArgT *>)>
1105 std::unique_ptr<MatcherDescriptor> makeMatcherAutoMarshall(
1106     ast_matchers::internal::VariadicFunction<ResultT, ArgT, Func> VarFunc,
1107     StringRef MatcherName) {
1108   return std::make_unique<VariadicFuncMatcherDescriptor>(VarFunc, MatcherName);
1109 }
1110 
1111 /// Overload for VariadicDynCastAllOfMatchers.
1112 ///
1113 /// Not strictly necessary, but DynCastAllOfMatcherDescriptor gives us better
1114 /// completion results for that type of matcher.
1115 template <typename BaseT, typename DerivedT>
1116 std::unique_ptr<MatcherDescriptor> makeMatcherAutoMarshall(
1117     ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
1118         VarFunc,
1119     StringRef MatcherName) {
1120   return std::make_unique<DynCastAllOfMatcherDescriptor>(VarFunc, MatcherName);
1121 }
1122 
1123 /// Argument adaptative overload.
1124 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
1125           typename FromTypes, typename ToTypes>
1126 std::unique_ptr<MatcherDescriptor> makeMatcherAutoMarshall(
1127     ast_matchers::internal::ArgumentAdaptingMatcherFunc<ArgumentAdapterT,
1128                                                         FromTypes, ToTypes>,
1129     StringRef MatcherName) {
1130   std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
1131   AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>(MatcherName,
1132                                                                     Overloads);
1133   return std::make_unique<OverloadedMatcherDescriptor>(Overloads);
1134 }
1135 
1136 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
1137           typename FromTypes, typename ToTypes>
1138 template <typename FromTypeList>
1139 inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
1140                                         ToTypes>::collect(FromTypeList) {
1141   Out.push_back(makeMatcherAutoMarshall(
1142       &AdaptativeFunc::template create<typename FromTypeList::head>, Name));
1143   collect(typename FromTypeList::tail());
1144 }
1145 
1146 /// Variadic operator overload.
1147 template <unsigned MinCount, unsigned MaxCount>
1148 std::unique_ptr<MatcherDescriptor> makeMatcherAutoMarshall(
1149     ast_matchers::internal::VariadicOperatorMatcherFunc<MinCount, MaxCount>
1150         Func,
1151     StringRef MatcherName) {
1152   return std::make_unique<VariadicOperatorMatcherDescriptor>(
1153       MinCount, MaxCount, Func.Op, MatcherName);
1154 }
1155 
1156 template <typename CladeType, typename... MatcherT>
1157 std::unique_ptr<MatcherDescriptor> makeMatcherAutoMarshall(
1158     ast_matchers::internal::MapAnyOfMatcherImpl<CladeType, MatcherT...>,
1159     StringRef MatcherName) {
1160   return std::make_unique<MapAnyOfMatcherDescriptor>(
1161       ASTNodeKind::getFromNodeKind<CladeType>(),
1162       std::vector<ASTNodeKind>{ASTNodeKind::getFromNodeKind<MatcherT>()...});
1163 }
1164 
1165 } // namespace internal
1166 } // namespace dynamic
1167 } // namespace ast_matchers
1168 } // namespace clang
1169 
1170 #endif // LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
1171