clang 19.0.0git
Registry.cpp
Go to the documentation of this file.
1//===- Registry.cpp - Matcher registry ------------------------------------===//
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/// Registry map populated at static initialization time.
11//
12//===----------------------------------------------------------------------===//
13
15#include "Marshallers.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringMap.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/Support/ManagedStatic.h"
24#include "llvm/Support/raw_ostream.h"
25#include <cassert>
26#include <iterator>
27#include <memory>
28#include <optional>
29#include <set>
30#include <string>
31#include <utility>
32#include <vector>
33
34namespace clang {
35namespace ast_matchers {
36namespace dynamic {
37
38namespace {
39
40using internal::MatcherDescriptor;
41
42using ConstructorMap =
43 llvm::StringMap<std::unique_ptr<const MatcherDescriptor>>;
44
45class RegistryMaps {
46public:
47 RegistryMaps();
48 ~RegistryMaps();
49
50 const ConstructorMap &constructors() const { return Constructors; }
51
52private:
53 void registerMatcher(StringRef MatcherName,
54 std::unique_ptr<MatcherDescriptor> Callback);
55
56 ConstructorMap Constructors;
57};
58
59} // namespace
60
61void RegistryMaps::registerMatcher(
62 StringRef MatcherName, std::unique_ptr<MatcherDescriptor> Callback) {
63 assert(!Constructors.contains(MatcherName));
64 Constructors[MatcherName] = std::move(Callback);
65}
66
67#define REGISTER_MATCHER(name) \
68 registerMatcher(#name, internal::makeMatcherAutoMarshall( \
69 ::clang::ast_matchers::name, #name));
70
71#define REGISTER_MATCHER_OVERLOAD(name) \
72 registerMatcher(#name, \
73 std::make_unique<internal::OverloadedMatcherDescriptor>(name##Callbacks))
74
75#define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
76 static_cast<::clang::ast_matchers::name##_Type##Id>( \
77 ::clang::ast_matchers::name)
78
79#define MATCHER_OVERLOAD_ENTRY(name, Id) \
80 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, Id), \
81 #name)
82
83#define REGISTER_OVERLOADED_2(name) \
84 do { \
85 std::unique_ptr<MatcherDescriptor> name##Callbacks[] = { \
86 MATCHER_OVERLOAD_ENTRY(name, 0), \
87 MATCHER_OVERLOAD_ENTRY(name, 1)}; \
88 REGISTER_MATCHER_OVERLOAD(name); \
89 } while (false)
90
91#define REGISTER_REGEX_MATCHER(name) \
92 registerMatcher(#name, internal::makeMatcherRegexMarshall(name, name))
93
94/// Generate a registry map with all the known matchers.
95/// Please keep sorted alphabetically!
96RegistryMaps::RegistryMaps() {
97 // TODO: Here is the list of the missing matchers, grouped by reason.
98 //
99 // Polymorphic + argument overload:
100 // findAll
101 //
102 // Other:
103 // equalsNode
104
105 registerMatcher("mapAnyOf",
106 std::make_unique<internal::MapAnyOfBuilderDescriptor>());
107
108 REGISTER_OVERLOADED_2(callee);
109 REGISTER_OVERLOADED_2(hasPrefix);
110 REGISTER_OVERLOADED_2(hasType);
111 REGISTER_OVERLOADED_2(ignoringParens);
112 REGISTER_OVERLOADED_2(isDerivedFrom);
113 REGISTER_OVERLOADED_2(isDirectlyDerivedFrom);
114 REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
116 REGISTER_OVERLOADED_2(pointsTo);
117 REGISTER_OVERLOADED_2(references);
118 REGISTER_OVERLOADED_2(thisPointerType);
119
120 std::unique_ptr<MatcherDescriptor> equalsCallbacks[] = {
124 };
126
127 REGISTER_REGEX_MATCHER(isExpansionInFileMatching);
128 REGISTER_REGEX_MATCHER(matchesName);
129 REGISTER_REGEX_MATCHER(matchesSelector);
130
139 REGISTER_MATCHER(argumentCountIs);
140 REGISTER_MATCHER(argumentCountAtLeast);
143 REGISTER_MATCHER(asString);
157 REGISTER_MATCHER(booleanType);
162 REGISTER_MATCHER(capturesThis);
163 REGISTER_MATCHER(capturesVar);
179 REGISTER_MATCHER(containsDeclaration);
223 REGISTER_MATCHER(declCountIs);
234 REGISTER_MATCHER(designatorCountIs);
243 REGISTER_MATCHER(equalsBoundNode);
244 REGISTER_MATCHER(equalsIntegralValue);
251 REGISTER_MATCHER(forCallable);
252 REGISTER_MATCHER(forDecomposition);
254 REGISTER_MATCHER(forEachArgumentWithParam);
255 REGISTER_MATCHER(forEachArgumentWithParamType);
256 REGISTER_MATCHER(forEachConstructorInitializer);
258 REGISTER_MATCHER(forEachLambdaCapture);
259 REGISTER_MATCHER(forEachOverridden);
260 REGISTER_MATCHER(forEachSwitchCase);
261 REGISTER_MATCHER(forEachTemplateArgument);
262 REGISTER_MATCHER(forField);
263 REGISTER_MATCHER(forFunction);
275 REGISTER_MATCHER(hasAnyArgument);
276 REGISTER_MATCHER(hasAnyBase);
277 REGISTER_MATCHER(hasAnyBinding);
278 REGISTER_MATCHER(hasAnyBody);
279 REGISTER_MATCHER(hasAnyCapture);
280 REGISTER_MATCHER(hasAnyClause);
281 REGISTER_MATCHER(hasAnyConstructorInitializer);
282 REGISTER_MATCHER(hasAnyDeclaration);
286 REGISTER_MATCHER(hasAnyParameter);
287 REGISTER_MATCHER(hasAnyPlacementArg);
289 REGISTER_MATCHER(hasAnySubstatement);
290 REGISTER_MATCHER(hasAnyTemplateArgument);
291 REGISTER_MATCHER(hasAnyTemplateArgumentLoc);
292 REGISTER_MATCHER(hasAnyUsingShadowDecl);
293 REGISTER_MATCHER(hasArgument);
294 REGISTER_MATCHER(hasArgumentOfType);
295 REGISTER_MATCHER(hasArraySize);
297 REGISTER_MATCHER(hasAutomaticStorageDuration);
298 REGISTER_MATCHER(hasBase);
299 REGISTER_MATCHER(hasBinding);
300 REGISTER_MATCHER(hasBitWidth);
301 REGISTER_MATCHER(hasBody);
302 REGISTER_MATCHER(hasCanonicalType);
303 REGISTER_MATCHER(hasCaseConstant);
304 REGISTER_MATCHER(hasCastKind);
305 REGISTER_MATCHER(hasCondition);
306 REGISTER_MATCHER(hasConditionVariableStatement);
307 REGISTER_MATCHER(hasDecayedType);
308 REGISTER_MATCHER(hasDeclContext);
310 REGISTER_MATCHER(hasDeducedType);
311 REGISTER_MATCHER(hasDefaultArgument);
314 REGISTER_MATCHER(hasDestinationType);
315 REGISTER_MATCHER(hasDirectBase);
316 REGISTER_MATCHER(hasDynamicExceptionSpec);
317 REGISTER_MATCHER(hasEitherOperand);
318 REGISTER_MATCHER(hasElementType);
319 REGISTER_MATCHER(hasElse);
320 REGISTER_MATCHER(hasExplicitSpecifier);
321 REGISTER_MATCHER(hasExternalFormalLinkage);
322 REGISTER_MATCHER(hasFalseExpression);
323 REGISTER_MATCHER(hasFoldInit);
324 REGISTER_MATCHER(hasGlobalStorage);
325 REGISTER_MATCHER(hasImplicitDestinationType);
326 REGISTER_MATCHER(hasInClassInitializer);
327 REGISTER_MATCHER(hasIncrement);
328 REGISTER_MATCHER(hasIndex);
329 REGISTER_MATCHER(hasInit);
330 REGISTER_MATCHER(hasInitializer);
331 REGISTER_MATCHER(hasInitStatement);
332 REGISTER_MATCHER(hasKeywordSelector);
333 REGISTER_MATCHER(hasLHS);
334 REGISTER_MATCHER(hasLocalQualifiers);
335 REGISTER_MATCHER(hasLocalStorage);
336 REGISTER_MATCHER(hasLoopInit);
337 REGISTER_MATCHER(hasLoopVariable);
338 REGISTER_MATCHER(hasMemberName);
339 REGISTER_MATCHER(hasMethod);
341 REGISTER_MATCHER(hasNamedTypeLoc);
342 REGISTER_MATCHER(hasNullSelector);
343 REGISTER_MATCHER(hasObjectExpression);
344 REGISTER_MATCHER(hasOperands);
345 REGISTER_MATCHER(hasOperatorName);
347 REGISTER_MATCHER(hasParameter);
349 REGISTER_MATCHER(hasPattern);
350 REGISTER_MATCHER(hasPointeeLoc);
351 REGISTER_MATCHER(hasQualifier);
352 REGISTER_MATCHER(hasRHS);
353 REGISTER_MATCHER(hasRangeInit);
354 REGISTER_MATCHER(hasReceiver);
355 REGISTER_MATCHER(hasReceiverType);
356 REGISTER_MATCHER(hasReferentLoc);
357 REGISTER_MATCHER(hasReplacementType);
358 REGISTER_MATCHER(hasReturnTypeLoc);
359 REGISTER_MATCHER(hasReturnValue);
360 REGISTER_MATCHER(hasPlacementArg);
361 REGISTER_MATCHER(hasSelector);
362 REGISTER_MATCHER(hasSingleDecl);
363 REGISTER_MATCHER(hasSize);
364 REGISTER_MATCHER(hasSizeExpr);
365 REGISTER_MATCHER(hasSourceExpression);
366 REGISTER_MATCHER(hasSpecializedTemplate);
367 REGISTER_MATCHER(hasStaticStorageDuration);
368 REGISTER_MATCHER(hasStructuredBlock);
369 REGISTER_MATCHER(hasSyntacticForm);
370 REGISTER_MATCHER(hasTargetDecl);
371 REGISTER_MATCHER(hasTemplateArgument);
372 REGISTER_MATCHER(hasTemplateArgumentLoc);
373 REGISTER_MATCHER(hasThen);
374 REGISTER_MATCHER(hasThreadStorageDuration);
375 REGISTER_MATCHER(hasTrailingReturn);
376 REGISTER_MATCHER(hasTrueExpression);
377 REGISTER_MATCHER(hasTypeLoc);
378 REGISTER_MATCHER(hasUnaryOperand);
379 REGISTER_MATCHER(hasUnarySelector);
380 REGISTER_MATCHER(hasUnderlyingDecl);
381 REGISTER_MATCHER(hasUnderlyingType);
382 REGISTER_MATCHER(hasUnqualifiedDesugaredType);
383 REGISTER_MATCHER(hasUnqualifiedLoc);
384 REGISTER_MATCHER(hasValueType);
386 REGISTER_MATCHER(ignoringElidableConstructorCall);
387 REGISTER_MATCHER(ignoringImpCasts);
388 REGISTER_MATCHER(ignoringImplicit);
389 REGISTER_MATCHER(ignoringParenCasts);
390 REGISTER_MATCHER(ignoringParenImpCasts);
398 REGISTER_MATCHER(innerType);
401 REGISTER_MATCHER(isAllowedToContainClauseKind);
402 REGISTER_MATCHER(isAnonymous);
403 REGISTER_MATCHER(isAnyCharacter);
404 REGISTER_MATCHER(isAnyPointer);
405 REGISTER_MATCHER(isArray);
406 REGISTER_MATCHER(isArrow);
407 REGISTER_MATCHER(isAssignmentOperator);
408 REGISTER_MATCHER(isAtPosition);
409 REGISTER_MATCHER(isBaseInitializer);
410 REGISTER_MATCHER(isBinaryFold);
411 REGISTER_MATCHER(isBitField);
412 REGISTER_MATCHER(isCatchAll);
413 REGISTER_MATCHER(isClass);
414 REGISTER_MATCHER(isClassMessage);
415 REGISTER_MATCHER(isClassMethod);
416 REGISTER_MATCHER(isComparisonOperator);
417 REGISTER_MATCHER(isConst);
418 REGISTER_MATCHER(isConstQualified);
419 REGISTER_MATCHER(isConsteval);
420 REGISTER_MATCHER(isConstexpr);
421 REGISTER_MATCHER(isConstinit);
422 REGISTER_MATCHER(isCopyAssignmentOperator);
423 REGISTER_MATCHER(isCopyConstructor);
424 REGISTER_MATCHER(isDefaultConstructor);
425 REGISTER_MATCHER(isDefaulted);
426 REGISTER_MATCHER(isDefinition);
427 REGISTER_MATCHER(isDelegatingConstructor);
428 REGISTER_MATCHER(isDeleted);
429 REGISTER_MATCHER(isEnum);
430 REGISTER_MATCHER(isExceptionVariable);
431 REGISTER_MATCHER(isExpandedFromMacro);
432 REGISTER_MATCHER(isExpansionInMainFile);
433 REGISTER_MATCHER(isExpansionInSystemHeader);
434 REGISTER_MATCHER(isExplicit);
435 REGISTER_MATCHER(isExplicitObjectMemberFunction);
436 REGISTER_MATCHER(isExplicitTemplateSpecialization);
437 REGISTER_MATCHER(isExpr);
439 REGISTER_MATCHER(isFinal);
440 REGISTER_MATCHER(isPrivateKind);
441 REGISTER_MATCHER(isFirstPrivateKind);
442 REGISTER_MATCHER(isImplicit);
443 REGISTER_MATCHER(isInAnonymousNamespace);
444 REGISTER_MATCHER(isInStdNamespace);
445 REGISTER_MATCHER(isInTemplateInstantiation);
446 REGISTER_MATCHER(isInitCapture);
447 REGISTER_MATCHER(isInline);
448 REGISTER_MATCHER(isInstanceMessage);
450 REGISTER_MATCHER(isInstantiated);
451 REGISTER_MATCHER(isInstantiationDependent);
452 REGISTER_MATCHER(isInteger);
453 REGISTER_MATCHER(isIntegral);
454 REGISTER_MATCHER(isLambda);
455 REGISTER_MATCHER(isLeftFold);
456 REGISTER_MATCHER(isListInitialization);
457 REGISTER_MATCHER(isMain);
458 REGISTER_MATCHER(isMemberInitializer);
459 REGISTER_MATCHER(isMoveAssignmentOperator);
460 REGISTER_MATCHER(isMoveConstructor);
461 REGISTER_MATCHER(isNoReturn);
462 REGISTER_MATCHER(isNoThrow);
463 REGISTER_MATCHER(isNoneKind);
464 REGISTER_MATCHER(isOverride);
465 REGISTER_MATCHER(isPrivate);
466 REGISTER_MATCHER(isProtected);
467 REGISTER_MATCHER(isPublic);
468 REGISTER_MATCHER(isPure);
469 REGISTER_MATCHER(isRightFold);
470 REGISTER_MATCHER(isScoped);
471 REGISTER_MATCHER(isSharedKind);
472 REGISTER_MATCHER(isSignedInteger);
473 REGISTER_MATCHER(isStandaloneDirective);
474 REGISTER_MATCHER(isStaticLocal);
475 REGISTER_MATCHER(isStaticStorageClass);
476 REGISTER_MATCHER(isStruct);
478 REGISTER_MATCHER(isTypeDependent);
479 REGISTER_MATCHER(isUnaryFold);
480 REGISTER_MATCHER(isUnion);
481 REGISTER_MATCHER(isUnsignedInteger);
482 REGISTER_MATCHER(isUserProvided);
483 REGISTER_MATCHER(isValueDependent);
484 REGISTER_MATCHER(isVariadic);
485 REGISTER_MATCHER(isVirtual);
486 REGISTER_MATCHER(isVirtualAsWritten);
487 REGISTER_MATCHER(isVolatileQualified);
488 REGISTER_MATCHER(isWeak);
489 REGISTER_MATCHER(isWritten);
498 REGISTER_MATCHER(member);
500 REGISTER_MATCHER(memberHasSameNameAsBoundNode);
503 REGISTER_MATCHER(namesType);
509 REGISTER_MATCHER(nullPointerConstant);
511 REGISTER_MATCHER(numSelectorArgs);
528 REGISTER_MATCHER(ofClass);
529 REGISTER_MATCHER(ofKind);
533 REGISTER_MATCHER(onImplicitObjectArgument);
536 REGISTER_MATCHER(parameterCountIs);
541 REGISTER_MATCHER(pointee);
548 REGISTER_MATCHER(realFloatingPointType);
553 REGISTER_MATCHER(refersToDeclaration);
554 REGISTER_MATCHER(refersToIntegralType);
555 REGISTER_MATCHER(refersToTemplate);
556 REGISTER_MATCHER(refersToType);
557 REGISTER_MATCHER(requiresZeroInitialization);
559 REGISTER_MATCHER(returns);
561 REGISTER_MATCHER(specifiesNamespace);
562 REGISTER_MATCHER(specifiesType);
563 REGISTER_MATCHER(specifiesTypeLoc);
564 REGISTER_MATCHER(statementCountIs);
576 REGISTER_MATCHER(templateArgumentCountIs);
584 REGISTER_MATCHER(throughUsingDecl);
603 REGISTER_MATCHER(usesADL);
610 REGISTER_MATCHER(voidType);
612 REGISTER_MATCHER(withInitializer);
613}
614
615RegistryMaps::~RegistryMaps() = default;
616
617static llvm::ManagedStatic<RegistryMaps> RegistryData;
618
620 return Ctor->nodeMatcherType();
621}
622
624 : Ptr(Ptr) {}
625
627
629 return Ctor->isBuilderMatcher();
630}
631
634 ArrayRef<ParserValue> Args, Diagnostics *Error) {
636 Ctor->buildMatcherCtor(NameRange, Args, Error).release());
637}
638
639// static
640std::optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
641 auto it = RegistryData->constructors().find(MatcherName);
642 return it == RegistryData->constructors().end() ? std::optional<MatcherCtor>()
643 : it->second.get();
644}
645
646static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
647 const std::set<ASTNodeKind> &KS) {
648 unsigned Count = 0;
649 for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
650 I != E; ++I) {
651 if (I != KS.begin())
652 OS << "|";
653 if (Count++ == 3) {
654 OS << "...";
655 break;
656 }
657 OS << *I;
658 }
659 return OS;
660}
661
663 ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
664 ASTNodeKind InitialTypes[] = {
665 ASTNodeKind::getFromNodeKind<Decl>(),
666 ASTNodeKind::getFromNodeKind<QualType>(),
667 ASTNodeKind::getFromNodeKind<Type>(),
668 ASTNodeKind::getFromNodeKind<Stmt>(),
669 ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
670 ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
671 ASTNodeKind::getFromNodeKind<TypeLoc>()};
672
673 // Starting with the above seed of acceptable top-level matcher types, compute
674 // the acceptable type set for the argument indicated by each context element.
675 std::set<ArgKind> TypeSet;
676 for (auto IT : InitialTypes) {
677 TypeSet.insert(ArgKind::MakeMatcherArg(IT));
678 }
679 for (const auto &CtxEntry : Context) {
680 MatcherCtor Ctor = CtxEntry.first;
681 unsigned ArgNumber = CtxEntry.second;
682 std::vector<ArgKind> NextTypeSet;
683 for (const ArgKind &Kind : TypeSet) {
684 if (Kind.getArgKind() == Kind.AK_Matcher &&
685 Ctor->isConvertibleTo(Kind.getMatcherKind()) &&
686 (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))
687 Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);
688 }
689 TypeSet.clear();
690 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());
691 }
692 return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());
693}
694
695std::vector<MatcherCompletion>
697 std::vector<MatcherCompletion> Completions;
698
699 // Search the registry for acceptable matchers.
700 for (const auto &M : RegistryData->constructors()) {
701 const MatcherDescriptor& Matcher = *M.getValue();
702 StringRef Name = M.getKey();
703
704 std::set<ASTNodeKind> RetKinds;
705 unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs();
706 bool IsPolymorphic = Matcher.isPolymorphic();
707 std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);
708 unsigned MaxSpecificity = 0;
709 bool NodeArgs = false;
710 for (const ArgKind& Kind : AcceptedTypes) {
711 if (Kind.getArgKind() != Kind.AK_Matcher &&
712 Kind.getArgKind() != Kind.AK_Node) {
713 continue;
714 }
715
716 if (Kind.getArgKind() == Kind.AK_Node) {
717 NodeArgs = true;
718 unsigned Specificity;
719 ASTNodeKind LeastDerivedKind;
720 if (Matcher.isConvertibleTo(Kind.getNodeKind(), &Specificity,
721 &LeastDerivedKind)) {
722 if (MaxSpecificity < Specificity)
723 MaxSpecificity = Specificity;
724 RetKinds.insert(LeastDerivedKind);
725 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
726 Matcher.getArgKinds(Kind.getNodeKind(), Arg, ArgsKinds[Arg]);
727 if (IsPolymorphic)
728 break;
729 }
730 } else {
731 unsigned Specificity;
732 ASTNodeKind LeastDerivedKind;
733 if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity,
734 &LeastDerivedKind)) {
735 if (MaxSpecificity < Specificity)
736 MaxSpecificity = Specificity;
737 RetKinds.insert(LeastDerivedKind);
738 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
739 Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);
740 if (IsPolymorphic)
741 break;
742 }
743 }
744 }
745
746 if (!RetKinds.empty() && MaxSpecificity > 0) {
747 std::string Decl;
748 llvm::raw_string_ostream OS(Decl);
749
750 std::string TypedText = std::string(Name);
751
752 if (NodeArgs) {
753 OS << Name;
754 } else {
755
756 if (IsPolymorphic) {
757 OS << "Matcher<T> " << Name << "(Matcher<T>";
758 } else {
759 OS << "Matcher<" << RetKinds << "> " << Name << "(";
760 for (const std::vector<ArgKind> &Arg : ArgsKinds) {
761 if (&Arg != &ArgsKinds[0])
762 OS << ", ";
763
764 bool FirstArgKind = true;
765 std::set<ASTNodeKind> MatcherKinds;
766 // Two steps. First all non-matchers, then matchers only.
767 for (const ArgKind &AK : Arg) {
768 if (AK.getArgKind() == ArgKind::AK_Matcher) {
769 MatcherKinds.insert(AK.getMatcherKind());
770 } else {
771 if (!FirstArgKind)
772 OS << "|";
773 FirstArgKind = false;
774 OS << AK.asString();
775 }
776 }
777 if (!MatcherKinds.empty()) {
778 if (!FirstArgKind) OS << "|";
779 OS << "Matcher<" << MatcherKinds << ">";
780 }
781 }
782 }
783 if (Matcher.isVariadic())
784 OS << "...";
785 OS << ")";
786
787 TypedText += "(";
788 if (ArgsKinds.empty())
789 TypedText += ")";
790 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)
791 TypedText += "\"";
792 }
793
794 Completions.emplace_back(TypedText, OS.str(), MaxSpecificity);
795 }
796 }
797
798 return Completions;
799}
800
802 SourceRange NameRange,
804 Diagnostics *Error) {
805 return Ctor->create(NameRange, Args, Error);
806}
807
809 SourceRange NameRange,
810 StringRef BindID,
812 Diagnostics *Error) {
813 VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
814 if (Out.isNull()) return Out;
815
816 std::optional<DynTypedMatcher> Result = Out.getSingleMatcher();
817 if (Result) {
818 std::optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
819 if (Bound) {
820 return VariantMatcher::SingleMatcher(*Bound);
821 }
822 }
823 Error->addError(NameRange, Error->ET_RegistryNotBindable);
824 return VariantMatcher();
825}
826
827} // namespace dynamic
828} // namespace ast_matchers
829} // namespace clang
Diagnostics class to manage error messages.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:58
Functions templates and classes to wrap matcher construct functions.
#define MATCHER_OVERLOAD_ENTRY(name, Id)
Definition: Registry.cpp:79
#define REGISTER_MATCHER_OVERLOAD(name)
Definition: Registry.cpp:71
#define REGISTER_MATCHER(name)
Definition: Registry.cpp:67
#define REGISTER_REGEX_MATCHER(name)
Definition: Registry.cpp:91
#define REGISTER_OVERLOADED_2(name)
Definition: Registry.cpp:83
Registry of all known matchers.
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
Definition: SemaCUDA.cpp:111
Polymorphic value type.
Kind identifier.
Definition: ASTTypeTraits.h:51
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
static ArgKind MakeMatcherArg(ASTNodeKind MatcherKind)
Constructor for matcher types.
Definition: VariantValue.h:48
Helper class to manage error messages.
Definition: Diagnostics.h:50
static std::vector< ArgKind > getAcceptedCompletionTypes(llvm::ArrayRef< std::pair< MatcherCtor, unsigned > > Context)
Compute the list of completion types for Context.
Definition: Registry.cpp:662
static bool isBuilderMatcher(MatcherCtor Ctor)
Definition: Registry.cpp:628
static ASTNodeKind nodeMatcherType(MatcherCtor)
Definition: Registry.cpp:619
static std::optional< MatcherCtor > lookupMatcherCtor(StringRef MatcherName)
Look up a matcher in the registry by name,.
Definition: Registry.cpp:640
static internal::MatcherDescriptorPtr buildMatcherCtor(MatcherCtor, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Definition: Registry.cpp:633
static std::vector< MatcherCompletion > getMatcherCompletions(ArrayRef< ArgKind > AcceptedTypes)
Compute the list of completions that match any of AcceptedTypes.
Definition: Registry.cpp:696
static VariantMatcher constructBoundMatcher(MatcherCtor Ctor, SourceRange NameRange, StringRef BindID, ArrayRef< ParserValue > Args, Diagnostics *Error)
Construct a matcher from the registry and bind it.
Definition: Registry.cpp:808
static VariantMatcher constructMatcher(MatcherCtor Ctor, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Construct a matcher from the registry.
Definition: Registry.cpp:801
static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher)
Clones the provided matcher.
A smart (owning) pointer for MatcherDescriptor.
Definition: Registry.h:38
virtual bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity=nullptr, ASTNodeKind *LeastDerivedKind=nullptr) const =0
Returns whether this matcher is convertible to the given type.
virtual void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &ArgKinds) const =0
Given that the matcher is being converted to type ThisKind, append the set of argument types accepted...
virtual std::unique_ptr< MatcherDescriptor > buildMatcherCtor(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const
Definition: Marshallers.h:317
virtual bool isVariadic() const =0
Returns whether the matcher is variadic.
virtual VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const =0
static llvm::ManagedStatic< RegistryMaps > RegistryData
Definition: Registry.cpp:617
static llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const std::set< ASTNodeKind > &KS)
Definition: Registry.cpp:646
const internal::VariadicDynCastAllOfMatcher< Stmt, FixedPointLiteral > fixedPointLiteral
Matches fixed point literals.
const internal::VariadicDynCastAllOfMatcher< Stmt, CStyleCastExpr > cStyleCastExpr
Matches a C-style cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, TagDecl > tagDecl
Matches tag declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXReinterpretCastExpr > cxxReinterpretCastExpr
Matches a reinterpret_cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl
Matches variable declarations.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ElaboratedTypeLoc > elaboratedTypeLoc
Matches C or C++ elaborated TypeLocs.
const internal::VariadicDynCastAllOfMatcher< Stmt, StmtExpr > stmtExpr
Matches statement expression (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, ExprWithCleanups > exprWithCleanups
Matches expressions that introduce cleanups to be run at the end of the sub-expression's evaluation.
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclRefExpr > declRefExpr
Matches expressions that refer to declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefNameDecl > typedefNameDecl
Matches typedef name declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCIvarDecl > objcIvarDecl
Matches Objective-C instance variable declarations.
const AstTypeMatcher< EnumType > enumType
Matches enum types.
const AstTypeMatcher< FunctionProtoType > functionProtoType
Matches FunctionProtoType nodes.
const AstTypeMatcher< ElaboratedType > elaboratedType
Matches types specified with an elaborated type keyword or with a qualified name.
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasDecl > typeAliasDecl
Matches type alias declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingEnumDecl > usingEnumDecl
Matches using-enum declarations.
const AstTypeMatcher< ObjCObjectPointerType > objcObjectPointerType
Matches an Objective-C object pointer type, which is different from a pointer type,...
const internal::VariadicDynCastAllOfMatcher< Stmt, ConstantExpr > constantExpr
Matches a constant expression wrapper.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitLoopExpr > arrayInitLoopExpr
Matches a loop initializing the elements of an array in a number of contexts:
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCIvarRefExpr > objcIvarRefExpr
Matches a reference to an ObjCIvar.
const AstTypeMatcher< BuiltinType > builtinType
Matches builtin Types.
const internal::VariadicOperatorMatcherFunc< 1, 1 > unless
Matches if the provided matcher does not match.
const internal::VariadicDynCastAllOfMatcher< Decl, ConceptDecl > conceptDecl
Matches concept declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoyieldExpr > coyieldExpr
Matches co_yield expressions.
const AstTypeMatcher< DependentSizedExtVectorType > dependentSizedExtVectorType
Matches C++ extended vector type where either the type or size is dependent.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDeleteExpr > cxxDeleteExpr
Matches delete expressions.
const internal::VariadicAllOfMatcher< TemplateName > templateName
Matches template name.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCProtocolDecl > objcProtocolDecl
Matches Objective-C protocol declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitCastExpr > implicitCastExpr
Matches the implicit cast nodes of Clang's AST.
const internal::VariadicOperatorMatcherFunc< 1, 1 > optionally
Matches any node regardless of the submatcher.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDecl > usingDecl
Matches using declarations.
const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > hasDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCPropertyDecl > objcPropertyDecl
Matches Objective-C property declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, StringLiteral > stringLiteral
Matches string literals (also matches wide string literals).
const internal::VariadicAllOfMatcher< CXXCtorInitializer > cxxCtorInitializer
Matches constructor initializers.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtFinallyStmt > objcFinallyStmt
Matches Objective-C @finally statements.
const AstTypeMatcher< DependentSizedArrayType > dependentSizedArrayType
Matches C++ arrays whose size is a value-dependent expression.
const AstTypeMatcher< TemplateSpecializationType > templateSpecializationType
Matches template specialization types.
const internal::VariadicDynCastAllOfMatcher< Stmt, AtomicExpr > atomicExpr
Matches atomic builtins.
const AstTypeMatcher< DeducedTemplateSpecializationType > deducedTemplateSpecializationType
Matches C++17 deduced template specialization types, e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoawaitExpr > coawaitExpr
Matches co_await expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, EnumDecl > enumDecl
Matches enum declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, ConvertVectorExpr > convertVectorExpr
Matches builtin function __builtin_convertvector.
const internal::VariadicDynCastAllOfMatcher< Stmt, AddrLabelExpr > addrLabelExpr
Matches address of label statements (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDependentScopeMemberExpr > cxxDependentScopeMemberExpr
Matches member expressions where the actual member referenced could not be resolved because the base ...
const internal::VariadicDynCastAllOfMatcher< Stmt, PredefinedExpr > predefinedExpr
Matches predefined identifier expressions [C99 6.4.2.2].
const internal::VariadicAllOfMatcher< NestedNameSpecifier > nestedNameSpecifier
Matches nested name specifiers.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicDynCastAllOfMatcher< Stmt, DependentCoawaitExpr > dependentCoawaitExpr
Matches co_await expressions where the type of the promise is dependent.
const internal::VariadicDynCastAllOfMatcher< Stmt, BreakStmt > breakStmt
Matches break statements.
const internal::VariadicDynCastAllOfMatcher< Decl, BindingDecl > bindingDecl
Matches binding declarations Example matches foo and bar (matcher = bindingDecl()
const internal::VariadicDynCastAllOfMatcher< Stmt, UnresolvedLookupExpr > unresolvedLookupExpr
Matches reference to a name that can be looked up during parsing but could not be resolved to a speci...
const internal::VariadicDynCastAllOfMatcher< Stmt, OMPExecutableDirective > ompExecutableDirective
Matches any #pragma omp executable directive.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCStringLiteral > objcStringLiteral
Matches ObjectiveC String literal expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCMethodDecl > objcMethodDecl
Matches Objective-C method declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, ParmVarDecl > parmVarDecl
Matches parameter variable declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXRewrittenBinaryOperator > cxxRewrittenBinaryOperator
Matches rewritten binary operators.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, GenericSelectionExpr > genericSelectionExpr
Matches C11 _Generic expression.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDeductionGuideDecl > cxxDeductionGuideDecl
Matches user-defined and implicitly generated deduction guide.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBoolLiteralExpr > cxxBoolLiteral
Matches bool literals.
const internal::VariadicDynCastAllOfMatcher< Stmt, ReturnStmt > returnStmt
Matches return statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, AsmStmt > asmStmt
Matches asm statements.
internal::Matcher< NamedDecl > hasName(StringRef Name)
Matches NamedDecl nodes that have the specified name.
Definition: ASTMatchers.h:3079
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDynamicCastExpr > cxxDynamicCastExpr
Matches a dynamic_cast expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoreturnStmt > coreturnStmt
Matches co_return statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, LambdaExpr > lambdaExpr
Matches lambda expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundStmt > compoundStmt
Matches compound statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, FloatingLiteral > floatLiteral
Matches float literals of all sizes / encodings, e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAutoreleasePoolStmt > autoreleasePoolStmt
Matches an Objective-C autorelease pool statement.
const internal::VariadicFunction< internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > >, StringRef, internal::hasAnyOverloadedOperatorNameFunc > hasAnyOverloadedOperatorName
Matches overloaded operator names.
const internal::VariadicDynCastAllOfMatcher< Decl, NonTypeTemplateParmDecl > nonTypeTemplateParmDecl
Matches non-type template parameter declarations.
const AstTypeMatcher< VariableArrayType > variableArrayType
Matches C arrays with a specified size that is not an integer-constant-expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryExprOrTypeTraitExpr > unaryExprOrTypeTraitExpr
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
const internal::VariadicDynCastAllOfMatcher< Stmt, NullStmt > nullStmt
Matches null statements.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, TemplateSpecializationTypeLoc > templateSpecializationTypeLoc
Matches template specialization TypeLocs.
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachDescendantMatcher > forEachDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
const internal::VariadicAllOfMatcher< CXXBaseSpecifier > cxxBaseSpecifier
Matches class bases.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDefaultArgExpr > cxxDefaultArgExpr
Matches the value of a default argument at the call site.
const internal::VariadicAllOfMatcher< TemplateArgument > templateArgument
Matches template arguments.
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachMatcher > forEach
Matches AST nodes that have child AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, CaseStmt > caseStmt
Matches case statements inside switch statements.
const internal::VariadicAllOfMatcher< NestedNameSpecifierLoc > nestedNameSpecifierLoc
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
const internal::VariadicDynCastAllOfMatcher< Decl, NamedDecl > namedDecl
Matches a declaration of anything that could have a name.
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingTypenameDecl > unresolvedUsingTypenameDecl
Matches unresolved using value declarations that involve the typename.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< DecltypeType > decltypeType
Matches types nodes representing C++11 decltype(<expr>) types.
const internal::VariadicAllOfMatcher< TypeLoc > typeLoc
Matches TypeLocs in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenListExpr > parenListExpr
Matches paren list expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplatePartialSpecializationDecl > classTemplatePartialSpecializationDecl
Matches C++ class template partial specializations.
const internal::VariadicDynCastAllOfMatcher< Stmt, WhileStmt > whileStmt
Matches while statements.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryDecl > objcCategoryDecl
Matches Objective-C category declarations.
internal::TrueMatcher anything()
Matches any node.
Definition: ASTMatchers.h:171
const internal::VariadicFunction< internal::Matcher< ObjCMessageExpr >, StringRef, internal::hasAnySelectorFunc > hasAnySelector
Matches when at least one of the supplied string equals to the Selector.getAsString()
const AstTypeMatcher< AutoType > autoType
Matches types nodes representing C++11 auto types.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConversionDecl > cxxConversionDecl
Matches conversion operator declarations.
const AstTypeMatcher< ParenType > parenType
Matches ParenType nodes.
const internal::VariadicDynCastAllOfMatcher< Decl, LabelDecl > labelDecl
Matches a declaration of label.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFunctionalCastExpr > cxxFunctionalCastExpr
Matches functional cast expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstCastExpr > cxxConstCastExpr
Matches a const_cast expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTemporaryObjectExpr > cxxTemporaryObjectExpr
Matches functional cast expressions having N != 1 arguments.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryOperator > unaryOperator
Matches unary operator expressions.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ReferenceTypeLoc > referenceTypeLoc
Matches reference TypeLocs.
const internal::VariadicFunction< internal::Matcher< NamedDecl >, StringRef, internal::hasAnyNameFunc > hasAnyName
Matches NamedDecl nodes that have any of the specified names.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCMessageExpr > objcMessageExpr
Matches ObjectiveC Message invocation expressions.
const internal::MapAnyOfMatcher< BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator > binaryOperation
Matches nodes which can be used with binary operators.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArraySubscriptExpr > arraySubscriptExpr
Matches array subscript expressions.
const internal::VariadicDynCastAllOfMatcher< OMPClause, OMPDefaultClause > ompDefaultClause
Matches OpenMP default clause.
const internal::VariadicDynCastAllOfMatcher< Decl, AccessSpecDecl > accessSpecDecl
Matches C++ access specifier declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, LinkageSpecDecl > linkageSpecDecl
Matches a declaration of a linkage specification.
const AstTypeMatcher< InjectedClassNameType > injectedClassNameType
Matches injected class name types.
const internal::VariadicDynCastAllOfMatcher< Stmt, GNUNullExpr > gnuNullExpr
Matches GNU __null expression.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, PointerTypeLoc > pointerTypeLoc
Matches pointer TypeLocs.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXForRangeStmt > cxxForRangeStmt
Matches range-based for statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > cxxMemberCallExpr
Matches member call expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConstructorDecl > cxxConstructorDecl
Matches C++ constructor declarations.
const AstTypeMatcher< BlockPointerType > blockPointerType
Matches block pointer types, i.e.
internal::BindableMatcher< Stmt > sizeOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching sizeof.
Definition: ASTMatchers.h:3058
const internal::VariadicDynCastAllOfMatcher< Stmt, InitListExpr > initListExpr
Matches init list expressions.
const AstTypeMatcher< AtomicType > atomicType
Matches atomic types.
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasTemplateDecl > typeAliasTemplateDecl
Matches type alias template declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNoexceptExpr > cxxNoexceptExpr
Matches noexcept expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitIndexExpr > arrayInitIndexExpr
The arrayInitIndexExpr consists of two subexpressions: a common expression (the source array) that is...
const AstTypeMatcher< UsingType > usingType
Matches types specified through a using declaration.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNewExpr > cxxNewExpr
Matches new expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, EnumConstantDecl > enumConstantDecl
Matches enum constants.
const internal::VariadicDynCastAllOfMatcher< Stmt, ForStmt > forStmt
Matches for statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, GotoStmt > gotoStmt
Matches goto statements.
const internal::VariadicDynCastAllOfMatcher< Decl, DeclaratorDecl > declaratorDecl
Matches declarator declarations (field, variable, function and non-type template parameter declaratio...
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtCatchStmt > objcCatchStmt
Matches Objective-C @catch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryOperator > binaryOperator
Matches binary operator expressions.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, QualifiedTypeLoc > qualifiedTypeLoc
Matches QualifiedTypeLocs in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTypeParmDecl > templateTypeParmDecl
Matches template type parameter declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, BlockExpr > blockExpr
Matches a reference to a block.
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionTemplateDecl > functionTemplateDecl
Matches C++ function template declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenExpr > parenExpr
Matches parentheses used in expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, StaticAssertDecl > staticAssertDecl
Matches a C++ static_assert declaration.
const internal::ArgumentAdaptingMatcherFunc< internal::HasMatcher > has
Matches AST nodes that have child AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoroutineBodyStmt > coroutineBodyStmt
Matches coroutine body statements.
const AstTypeMatcher< MacroQualifiedType > macroQualifiedType
Matches qualified types when the qualifier is applied via a macro.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryImplDecl > objcCategoryImplDecl
Matches Objective-C category definitions.
const AstTypeMatcher< TypedefType > typedefType
Matches typedef types.
const internal::VariadicDynCastAllOfMatcher< Stmt, MaterializeTemporaryExpr > materializeTemporaryExpr
Matches nodes where temporaries are materialized.
const AstTypeMatcher< TagType > tagType
Matches tag types (record and enum types).
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryConditionalOperator > binaryConditionalOperator
Matches binary conditional operator expressions (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtTryStmt > objcTryStmt
Matches Objective-C @try statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, ExplicitCastExpr > explicitCastExpr
Matches explicit cast expressions.
internal::PolymorphicMatcher< internal::ValueEqualsMatcher, void(internal::AllNodeBaseTypes), ValueT > equals(const ValueT &Value)
Matches literals that are equal to the given value of type ValueT.
Definition: ASTMatchers.h:5848
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStaticCastExpr > cxxStaticCastExpr
Matches a C++ static_cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, ValueDecl > valueDecl
Matches any value declaration.
const internal::VariadicDynCastAllOfMatcher< Decl, TranslationUnitDecl > translationUnitDecl
Matches the top declaration context.
const AstTypeMatcher< TemplateTypeParmType > templateTypeParmType
Matches template type parameter types.
const AstTypeMatcher< ConstantArrayType > constantArrayType
Matches C arrays with a specified constant size.
const internal::VariadicAllOfMatcher< LambdaCapture > lambdaCapture
Matches lambda captures.
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> eachOf
Matches if any of the given matchers matches.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstructExpr > cxxConstructExpr
Matches constructor call expressions (including implicit ones).
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCInterfaceDecl > objcInterfaceDecl
Matches Objective-C interface declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTemplateParmDecl > templateTemplateParmDecl
Matches template template parameter declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, FieldDecl > fieldDecl
Matches field declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, UserDefinedLiteral > userDefinedLiteral
Matches user defined literal operator call.
const internal::VariadicDynCastAllOfMatcher< Stmt, ChooseExpr > chooseExpr
Matches GNU __builtin_choose_expr.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > cxxOperatorCallExpr
Matches overloaded operator calls.
internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > > hasOverloadedOperatorName(StringRef Name)
Matches overloaded operator names.
Definition: ASTMatchers.h:3142
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceAliasDecl > namespaceAliasDecl
Matches a declaration of a namespace alias.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBindTemporaryExpr > cxxBindTemporaryExpr
Matches nodes where temporaries are created.
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchCase > switchCase
Matches case and default statements inside switch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, DefaultStmt > defaultStmt
Matches default statements inside switch statements.
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> allOf
Matches if all given matchers match.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateSpecializationDecl > classTemplateSpecializationDecl
Matches C++ class template specializations.
const internal::VariadicDynCastAllOfMatcher< Decl, DecompositionDecl > decompositionDecl
Matches decomposition-declarations.
const AstTypeMatcher< SubstTemplateTypeParmType > substTemplateTypeParmType
Matches types that represent the result of substituting a type for a template type parameter.
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl
Matches function declarations.
const AstTypeMatcher< UnaryTransformType > unaryTransformType
Matches types nodes representing unary type transformations.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnresolvedMemberExpr > unresolvedMemberExpr
Matches unresolved member expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtThrowStmt > objcThrowStmt
Matches Objective-C @throw statements.
const internal::MapAnyOfMatcher< CallExpr, CXXConstructExpr > invocation
Matches function calls and constructor calls.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThrowExpr > cxxThrowExpr
Matches throw expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchStmt > switchStmt
Matches switch statements.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, MemberExpr > memberExpr
Matches member expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > cxxRecordDecl
Matches C++ class declarations.
const internal::VariadicAllOfMatcher< TemplateArgumentLoc > templateArgumentLoc
Matches template arguments (with location info).
const AstTypeMatcher< ReferenceType > referenceType
Matches both lvalue and rvalue reference types.
const internal::VariadicDynCastAllOfMatcher< Stmt, DesignatedInitExpr > designatedInitExpr
Matches C99 designated initializer expressions [C99 6.7.8].
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDestructorDecl > cxxDestructorDecl
Matches explicit C++ destructor declarations.
internal::BindableMatcher< Stmt > alignOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching alignof.
Definition: ASTMatchers.h:3049
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXUnresolvedConstructExpr > cxxUnresolvedConstructExpr
Matches unresolved constructor call expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCImplementationDecl > objcImplementationDecl
Matches Objective-C implementation declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, IntegerLiteral > integerLiteral
Matches integer literals of all sizes / encodings, e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitValueInitExpr > implicitValueInitExpr
Matches implicit initializers of init list expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, DoStmt > doStmt
Matches do statements.
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceDecl > namespaceDecl
Matches a declaration of a namespace.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNullPtrLiteralExpr > cxxNullPtrLiteralExpr
Matches nullptr literal.
internal::PolymorphicMatcher< internal::HasDeclarationMatcher, void(internal::HasDeclarationSupportedTypes), internal::Matcher< Decl > > hasDeclaration(const internal::Matcher< Decl > &InnerMatcher)
Matches a node if the declaration associated with that node matches the given matcher.
Definition: ASTMatchers.h:3653
const AstTypeMatcher< DecayedType > decayedType
Matches decayed type Example matches i[] in declaration of f.
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclStmt > declStmt
Matches declaration statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundLiteralExpr > compoundLiteralExpr
Matches compound (i.e.
const AstTypeMatcher< MemberPointerType > memberPointerType
Matches member pointer types.
const internal::VariadicDynCastAllOfMatcher< Stmt, LabelStmt > labelStmt
Matches label statements.
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
const internal::VariadicDynCastAllOfMatcher< Decl, FriendDecl > friendDecl
Matches friend declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const AstTypeMatcher< IncompleteArrayType > incompleteArrayType
Matches C arrays with unspecified size.
const internal::VariadicDynCastAllOfMatcher< Stmt, CharacterLiteral > characterLiteral
Matches character literals (also matches wchar_t).
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFoldExpr > cxxFoldExpr
Matches C++17 fold expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ConditionalOperator > conditionalOperator
Matches conditional operator expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStdInitializerListExpr > cxxStdInitializerListExpr
Matches C++ initializer list expressions.
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> anyOf
Matches if any of the given matchers matches.
const internal::VariadicFunction< internal::PolymorphicMatcher< internal::HasAnyOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator, UnaryOperator), std::vector< std::string > >, StringRef, internal::hasAnyOperatorNameFunc > hasAnyOperatorName
Matches operator expressions (binary or unary) that have any of the specified names.
const internal::VariadicDynCastAllOfMatcher< Stmt, OpaqueValueExpr > opaqueValueExpr
Matches opaque value expressions.
const AstTypeMatcher< ComplexType > complexType
Matches C99 complex types.
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > cudaKernelCallExpr
Matches CUDA kernel call expression.
const internal::VariadicDynCastAllOfMatcher< Decl, IndirectFieldDecl > indirectFieldDecl
Matches indirect field declarations.
const AstTypeMatcher< FunctionType > functionType
Matches FunctionType nodes.
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > cxxMethodDecl
Matches method declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXCatchStmt > cxxCatchStmt
Matches catch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
const internal::VariadicAllOfMatcher< QualType > qualType
Matches QualTypes in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTryStmt > cxxTryStmt
Matches try statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, SubstNonTypeTemplateParmExpr > substNonTypeTemplateParmExpr
Matches substitutions of non-type template parameters.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDirectiveDecl > usingDirectiveDecl
Matches using namespace declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingValueDecl > unresolvedUsingValueDecl
Matches unresolved using value declarations.
const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr >, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr > > hasAncestor
Matches AST nodes that have an ancestor that matches the provided matcher.
const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr >, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr > > hasParent
Matches AST nodes that have a parent that matches the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, IfStmt > ifStmt
Matches if statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThisExpr > cxxThisExpr
Matches implicit and explicit this expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImaginaryLiteral > imaginaryLiteral
Matches imaginary literals, which are based on integer and floating point literals e....
const AstTypeMatcher< RValueReferenceType > rValueReferenceType
Matches rvalue reference types.
const internal::VariadicDynCastAllOfMatcher< Stmt, ContinueStmt > continueStmt
Matches continue statements.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateDecl > classTemplateDecl
Matches C++ class template declarations.
const AstTypeMatcher< LValueReferenceType > lValueReferenceType
Matches lvalue reference types.
The JSON file list parser is used to communicate input to InstallAPI.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:209
bool isInstanceMethod(const Decl *D)
Definition: Attr.h:120
@ Result
The result type of a method or function.