clang 10.0.0git

Marshallers.h
Go to the documentation of this file.
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
45 namespace clang {
46 namespace ast_matchers {
47 namespace dynamic {
48 namespace 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.
53 template <class T> struct ArgTypeTraits;
54 template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
55 };
56
57 template <> 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
69 template <>
70 struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
71 };
72
73 template <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
87 template <> 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
99 template <> 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
111 template <> 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
123 template <> struct ArgTypeTraits<attr::Kind> {
124 private:
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
132 public:
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
146 template <> struct ArgTypeTraits<CastKind> {
147 private:
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
155 public:
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
169 template <> struct ArgTypeTraits<OpenMPClauseKind> {
170 private:
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
179 public:
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.
195 class MatcherDescriptor {
196 public:
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
233 inline 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.
253 class FixedArgCountMatcherDescriptor : public MatcherDescriptor {
254 public:
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
296 private:
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.
306 template <class PolyMatcher>
307 static void mergePolyMatchers(const PolyMatcher &Poly,
308 std::vector<DynTypedMatcher> &Out,
309 ast_matchers::internal::EmptyTypeList) {}
310
311 template <class PolyMatcher, class TypeList>
312 static 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.
324 static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
325 return VariantMatcher::SingleMatcher(Matcher);
326 }
327
328 template <typename T>
329 static 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
338 template <typename T>
339 inline 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
346 template <>
347 inline void
348 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
349 std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
350
351 template <typename T>
352 struct BuildReturnTypeVector {
353 static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
354 buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
355 }
356 };
357
358 template <typename T>
359 struct 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
365 template <typename T>
366 struct 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.
373 template <typename ResultT, typename ArgT,
374 ResultT (*Func)(ArrayRef<const ArgT *>)>
375 VariantMatcher
376 variadicMatcherDescriptor(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.
415 class VariadicFuncMatcherDescriptor : public MatcherDescriptor {
416 public:
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
454 private:
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.
462 class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
463 public:
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
491 private:
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.
512 template <typename ReturnType>
513 static 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.
523 template <typename ReturnType, typename ArgType1>
524 static 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.
536 template <typename ReturnType, typename ArgType1, typename ArgType2>
537 static 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.
555 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
556 typename FromTypes, typename ToTypes>
557 class AdaptativeOverloadCollector {
558 public:
559 AdaptativeOverloadCollector(
560 StringRef Name, std::vector<std::unique_ptr<MatcherDescriptor>> &Out)
561 : Name(Name), Out(Out) {
562 collect(FromTypes());
563 }
564
565 private:
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.
586 class OverloadedMatcherDescriptor : public MatcherDescriptor {
587 public:
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
656 private:
657 std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
658 };
659
660 /// Variadic operator marshaller function.
661 class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
662 public:
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
716 private:
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
727 template <typename ReturnType>
728 std::unique_ptr<MatcherDescriptor>
729 makeMatcherAutoMarshall(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
738 template <typename ReturnType, typename ArgType1>
739 std::unique_ptr<MatcherDescriptor>
740 makeMatcherAutoMarshall(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
750 template <typename ReturnType, typename ArgType1, typename ArgType2>
751 std::unique_ptr<MatcherDescriptor>
752 makeMatcherAutoMarshall(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.
764 template <typename ResultT, typename ArgT,
765 ResultT (*Func)(ArrayRef<const ArgT *>)>
766 std::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.
776 template <typename BaseT, typename DerivedT>
777 std::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.
785 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
786 typename FromTypes, typename ToTypes>
787 std::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
797 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
798 typename FromTypes, typename ToTypes>
799 template <typename FromTypeList>
800 inline 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.
808 template <unsigned MinCount, unsigned MaxCount>
809 std::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
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor
Variadic operator marshaller function.
Definition: Marshallers.h:661
clang::ast_matchers::dynamic::internal::ArgTypeTraits< unsigned >::getKind
static ArgKind getKind()
Definition: Marshallers.h:118
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::getArgKinds
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
Given that the matcher is being converted to type ThisKind, append the set of argument types accepted...
Definition: Marshallers.h:700
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::create
VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Definition: Marshallers.h:670
clang::ast_matchers::dynamic::VariantMatcher::hasTypedMatcher
bool hasTypedMatcher() const
Determines if the contained matcher can be converted to Matcher<T>.
Definition: VariantValue.h:176
clang::ast_matchers::dynamic::Diagnostics::ET_RegistryWrongArgCount
Definition: Diagnostics.h:63
clang::ast_matchers::dynamic::ArgKind::AK_Boolean
Definition: VariantValue.h:37
clang::ast_matchers::dynamic::ArgKind::AK_String
Definition: VariantValue.h:40
clang::ast_matchers::dynamic::internal::ArgTypeTraits< double >::getKind
static ArgKind getKind()
Definition: Marshallers.h:106
clang::ast_matchers::dynamic::internal::ArgTypeTraits< OpenMPClauseKind >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:180
clang::ast_matchers::dynamic::internal::variadicMatcherDescriptor
VariantMatcher variadicMatcherDescriptor(StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Variadic marshaller function.
Definition: Marshallers.h:376
OPENMP_CLAUSE
#define OPENMP_CLAUSE(TextualSpelling, Class)
clang::ast_type_traits::ASTNodeKind::isSame
bool isSame(ASTNodeKind Other) const
Returns true if this and Other represent the same kind.
Definition: ASTTypeTraits.h:77
clang::ast_matchers::dynamic::internal::ArgTypeTraits< unsigned >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:112
Value
Value
Definition: UninitializedValues.cpp:101
clang::ast_matchers::dynamic::internal::ArgTypeTraits< OpenMPClauseKind >::getKind
static ArgKind getKind()
Definition: Marshallers.h:188
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::isPolymorphic
bool isPolymorphic() const override
Returns whether the matcher will, given a matcher of any type T, yield a matcher of type T...
Definition: Marshallers.h:714
ASTMatchersInternal.h
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::RunFunc
VariantMatcher(*)(StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) RunFunc
Definition: Marshallers.h:420
clang::ast_matchers::dynamic::VariantMatcher::SingleMatcher
static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher)
Clones the provided matcher.
Definition: VariantValue.cpp:221
OperationKinds.h
clang::ast_matchers::dynamic::VariantValue::isBoolean
bool isBoolean() const
Boolean value functions.
Definition: VariantValue.cpp:319
clang::ast_matchers::dynamic::VariantValue::isUnsigned
bool isUnsigned() const
Unsigned value functions.
Definition: VariantValue.cpp:349
clang::ast_matchers::dynamic::internal::DynCastAllOfMatcherDescriptor::isConvertibleTo
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
Returns whether this matcher is convertible to the given type.
Definition: Marshallers.h:473
clang::ast_matchers::dynamic::VariantMatcher::VariadicOperatorMatcher
static VariantMatcher VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, std::vector< VariantMatcher > Args)
Creates a &#39;variadic&#39; operator matcher.
Definition: VariantValue.cpp:231
llvm::Optional
Definition: LLVM.h:37
clang::ast_matchers::dynamic::internal::ArgTypeTraits< bool >::getKind
static ArgKind getKind()
Definition: Marshallers.h:94
clang::ast_matchers::dynamic::Diagnostics::ET_RegistryAmbiguousOverload
Definition: Diagnostics.h:66
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::getNumArgs
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
Definition: Marshallers.h:282
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::create
VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Definition: Marshallers.h:275
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::FixedArgCountMatcherDescriptor
FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void(*Func)(), StringRef MatcherName, ArrayRef< ast_type_traits::ASTNodeKind > RetKinds, ArrayRef< ArgKind > ArgKinds)
Definition: Marshallers.h:267
std
Definition: Format.h:2445
clang::ast_matchers::dynamic::internal::BuildReturnTypeVector
Definition: Marshallers.h:352
AttrKinds.h
Defines the clang::attr::Kind enum.
OpenMPKinds.h
Defines some OpenMP-specific enums and functions.
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_device_functions.h:1628
clang::ast_matchers::dynamic::internal::MatcherDescriptor::isPolymorphic
virtual bool isPolymorphic() const
Returns whether the matcher will, given a matcher of any type T, yield a matcher of type T...
Definition: Marshallers.h:230
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::create
VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Definition: Marshallers.h:595
clang::ast_matchers::dynamic::internal::MatcherDescriptor
Matcher descriptor interface.
Definition: Marshallers.h:195
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::OverloadedMatcherDescriptor
OverloadedMatcherDescriptor(MutableArrayRef< std::unique_ptr< MatcherDescriptor >> Callbacks)
Definition: Marshallers.h:588
LLVM.h
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::VariadicOperatorMatcherDescriptor
VariadicOperatorMatcherDescriptor(unsigned MinCount, unsigned MaxCount, VarOp Op, StringRef MatcherName)
Definition: Marshallers.h:665
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:19
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::getNumArgs
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
Definition: Marshallers.h:440
clang::ast_matchers::dynamic::Diagnostics::OverloadContext::revertErrors
void revertErrors()
Revert all errors that happened within this context.
Definition: Diagnostics.cpp:55
clang::ast_matchers::dynamic::internal::ArgTypeTraits< ast_matchers::internal::Matcher< T > >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:74
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::isVariadic
bool isVariadic() const override
Returns whether the matcher is variadic.
Definition: Marshallers.h:618
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::isConvertibleTo
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
Returns whether this matcher is convertible to the given type.
Definition: Marshallers.h:447
llvm::ArrayRef
Definition: LLVM.h:31
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor
Matcher descriptor for variadic functions.
Definition: Marshallers.h:415
clang::ast_matchers::dynamic::ParserValue
A VariantValue instance annotated with its parser context.
Definition: Diagnostics.h:42
ASTTypeTraits.h
clang::CastKind
CastKind
CastKind - The kind of operation required for a conversion.
Definition: OperationKinds.h:20
clang::ast_matchers::dynamic::VariantValue::getTypeAsString
std::string getTypeAsString() const
String representation of the type of the value.
Definition: VariantValue.cpp:443
clang::ast_matchers::dynamic::internal::ArgTypeTraits< CastKind >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:156
clang::attr::Kind
Kind
Definition: AttrKinds.h:22
clang::ast_matchers::dynamic::internal::ArgTypeTraits< std::string >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:58
llvm::MutableArrayRef
Definition: LLVM.h:32
clang::ast_matchers::dynamic::internal::isRetKindConvertibleTo
bool isRetKindConvertibleTo(ArrayRef< ast_type_traits::ASTNodeKind > RetKinds, ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind)
Definition: Marshallers.h:233
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::getNumArgs
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
Definition: Marshallers.h:698
bool
#define bool
Definition: stdbool.h:15
clang::OpenMPClauseKind
OpenMPClauseKind
OpenMP clauses.
Definition: OpenMPKinds.h:65
clang::ast_matchers::dynamic::internal::BuildReturnTypeVector< ast_matchers::internal::Matcher< T > >::build
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
Definition: Marshallers.h:360
clang::ast_matchers::dynamic::internal::matcherMarshall2
static VariantMatcher matcherMarshall2(void(*Func)(), StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
2-arg marshaller function.
Definition: Marshallers.h:537
clang::ast_matchers::dynamic::internal::ArgTypeTraits< attr::Kind >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:133
Diagnostics.h
Diagnostics class to manage error messages.
clang::ast_matchers::dynamic::VariantValue::isDouble
bool isDouble() const
Double value functions.
Definition: VariantValue.cpp:334
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::VariadicFuncMatcherDescriptor
VariadicFuncMatcherDescriptor(ast_matchers::internal::VariadicFunction< ResultT, ArgT, F > Func, StringRef MatcherName)
Definition: Marshallers.h:424
clang::ast_matchers::dynamic::Diagnostics::ET_RegistryWrongArgType
Definition: Diagnostics.h:64
clang::ast_matchers::dynamic::internal::AdaptativeOverloadCollector::AdaptativeOverloadCollector
AdaptativeOverloadCollector(StringRef Name, std::vector< std::unique_ptr< MatcherDescriptor >> &Out)
Definition: Marshallers.h:559
clang::ast_matchers::dynamic::VariantValue
Variant value class.
Definition: VariantValue.h:250
clang::ast_matchers::dynamic::Diagnostics
Helper class to manage error messages.
Definition: Diagnostics.h:50
clang::syntax::NodeKind
NodeKind
A kind of a syntax node, used for implementing casts.
Definition: Nodes.h:37
ATTR
#define ATTR(X)
clang::ast_matchers::dynamic::internal::BuildReturnTypeVector< ast_matchers::internal::BindableMatcher< T > >::build
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
Definition: Marshallers.h:367
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::VarOp
DynTypedMatcher::VariadicOperator VarOp
Definition: Marshallers.h:663
clang::ast_matchers::dynamic::Diagnostics::addError
ArgStream addError(SourceRange Range, ErrorType Error)
Add an error to the diagnostics.
Definition: Diagnostics.cpp:65
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::isConvertibleTo
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
Returns whether this matcher is convertible to the given type.
Definition: Marshallers.h:289
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::ast_matchers::dynamic::SourceRange
Definition: Diagnostics.h:36
clang::ast_matchers::dynamic::internal::ArgTypeTraits< CastKind >::getKind
static ArgKind getKind()
Definition: Marshallers.h:164
clang::ast_matchers::dynamic::internal::ArgTypeTraits< std::string >::getKind
static ArgKind getKind()
Definition: Marshallers.h:64
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::isVariadic
bool isVariadic() const override
Returns whether the matcher is variadic.
Definition: Marshallers.h:697
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::getArgKinds
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
Given that the matcher is being converted to type ThisKind, append the set of argument types accepted...
Definition: Marshallers.h:284
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::getArgKinds
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
Given that the matcher is being converted to type ThisKind, append the set of argument types accepted...
Definition: Marshallers.h:638
clang::ast_matchers::dynamic::ParserValue::Value
VariantValue Value
Definition: Diagnostics.h:46
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::create
VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Definition: Marshallers.h:433
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor
Simple callback implementation.
Definition: Marshallers.h:253
clang::ast_matchers::dynamic::VariantValue::getMatcher
const VariantMatcher & getMatcher() const
Definition: VariantValue.cpp:383
clang::ast_matchers::dynamic::internal::DynCastAllOfMatcherDescriptor
Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
Definition: Marshallers.h:462
CHECK_ARG_COUNT
#define CHECK_ARG_COUNT(count)
Helper macros to check the arguments on all marshaller functions.
Definition: Marshallers.h:496
clang::ast_matchers::dynamic::internal::ArgTypeTraits< attr::Kind >::getKind
static ArgKind getKind()
Definition: Marshallers.h:141
clang::ast_matchers::dynamic::VariantValue::getString
const std::string & getString() const
Definition: VariantValue.cpp:368
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::isVariadic
bool isVariadic() const override
Returns whether the matcher is variadic.
Definition: Marshallers.h:281
clang::ast_type_traits::ASTNodeKind::isBaseOf
bool isBaseOf(ASTNodeKind Other, unsigned *Distance=nullptr) const
Returns true if this is a base kind of (or same as) Other.
Definition: ASTTypeTraits.cpp:47
clang::ast_matchers::dynamic::internal::ArgTypeTraits< ast_matchers::internal::Matcher< T > >::getKind
static ArgKind getKind()
Definition: Marshallers.h:82
clang::ast_matchers::dynamic::internal::ArgTypeTraits< bool >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:88
clang::MultiVersionKind::None
clang::ast_type_traits::ASTNodeKind
Kind identifier.
Definition: ASTTypeTraits.h:57
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor
MatcherDescriptor that wraps multiple "overloads" of the same matcher.
Definition: Marshallers.h:586
clang::ast_matchers::dynamic::internal::makeMatcherAutoMarshall
std::unique_ptr< MatcherDescriptor > makeMatcherAutoMarshall(ReturnType(*Func)(), StringRef MatcherName)
Helper functions to select the appropriate marshaller functions.
Definition: Marshallers.h:729
clang::ast_matchers::dynamic::ParserValue::Range
SourceRange Range
Definition: Diagnostics.h:45
clang::ast_matchers::dynamic::ArgKind::AK_Double
Definition: VariantValue.h:38
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::ast_matchers::dynamic::internal::VariadicOperatorMatcherDescriptor::isConvertibleTo
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
Returns whether this matcher is convertible to the given type.
Definition: Marshallers.h:705
ast_matchers
clang::ast_matchers::dynamic::VariantValue::isMatcher
bool isMatcher() const
Matcher value functions.
Definition: VariantValue.cpp:379
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:298
clang::ast_matchers::dynamic::internal::matcherMarshall0
static VariantMatcher matcherMarshall0(void(*Func)(), StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
0-arg marshaller function.
Definition: Marshallers.h:513
clang::ast_matchers::dynamic::VariantMatcher::isNull
bool isNull() const
Whether the matcher is null.
Definition: VariantValue.h:158
clang::ast_matchers::dynamic::VariantMatcher::PolymorphicMatcher
static VariantMatcher PolymorphicMatcher(std::vector< DynTypedMatcher > Matchers)
Clones the provided matchers.
Definition: VariantValue.cpp:226
clang::ast_matchers::dynamic::internal::ArgTypeTraits< double >::is
static bool is(const VariantValue &Value)
Definition: Marshallers.h:100
clang::ast_matchers::dynamic::internal::FixedArgCountMatcherDescriptor::MarshallerType
VariantMatcher(*)(void(*Func)(), StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) MarshallerType
Definition: Marshallers.h:259
clang::ast_matchers::dynamic::internal::mergePolyMatchers
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:307
clang::ast_matchers::dynamic::internal::ArgTypeTraits
Helper template class to just from argument type to the right is/get functions in VariantValue...
Definition: Marshallers.h:53
clang::ast_matchers::dynamic::Diagnostics::OverloadContext
Context for overloaded matcher construction.
Definition: Diagnostics.h:121
clang::ast_matchers::dynamic::VariantMatcher
A variant matcher object.
Definition: VariantValue.h:92
clang::ast_matchers::dynamic::ArgKind::AK_Unsigned
Definition: VariantValue.h:39
CHECK_ARG_TYPE
#define CHECK_ARG_TYPE(index, type)
Definition: Marshallers.h:503
X
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:14780
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::getArgKinds
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
Given that the matcher is being converted to type ThisKind, append the set of argument types accepted...
Definition: Marshallers.h:442
clang::ast_matchers::dynamic::internal::DynCastAllOfMatcherDescriptor::DynCastAllOfMatcherDescriptor
DynCastAllOfMatcherDescriptor(ast_matchers::internal::VariadicDynCastAllOfMatcher< BaseT, DerivedT > Func, StringRef MatcherName)
Definition: Marshallers.h:465
clang::ast_matchers::dynamic::internal::BuildReturnTypeVector::build
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
Definition: Marshallers.h:353
CAST_OPERATION
#define CAST_OPERATION(Name)
getKind
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:947
VariantValue.h
Polymorphic value type.
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::isConvertibleTo
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
Returns whether this matcher is convertible to the given type.
Definition: Marshallers.h:646
clang::ast_matchers::dynamic::internal::outvalueToVariantMatcher
static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher)
Convert the return values of the functions into a VariantMatcher.
Definition: Marshallers.h:324
clang::ast_matchers::dynamic::internal::AdaptativeOverloadCollector
Helper class used to collect all the possible overloads of an argument adaptative matcher function...
Definition: Marshallers.h:557
clang::ast_matchers::dynamic::internal::OverloadedMatcherDescriptor::getNumArgs
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
Definition: Marshallers.h:628
clang::ast_matchers::dynamic::ArgKind
Kind identifier.
Definition: VariantValue.h:33
clang::ast_matchers::dynamic::VariantValue::isString
bool isString() const
String value functions.
Definition: VariantValue.cpp:364
clang::ast_matchers::dynamic::internal::matcherMarshall1
static VariantMatcher matcherMarshall1(void(*Func)(), StringRef MatcherName, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
1-arg marshaller function.
Definition: Marshallers.h:524
clang::ast_matchers::dynamic::internal::buildReturnTypeVectorFromTypeList
void buildReturnTypeVectorFromTypeList(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
Definition: Marshallers.h:339
clang::ast_matchers::dynamic::internal::VariadicFuncMatcherDescriptor::isVariadic
bool isVariadic() const override
Returns whether the matcher is variadic.
Definition: Marshallers.h:439