doxygen/Registry_8cpp_source.html

//===- Registry.cpp - Matcher registry ------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

/// \file

/// Registry map populated at static initialization time.

//

//===----------------------------------------------------------------------===//


#include "clang/ASTMatchers/Dynamic/Registry.h"

#include "Marshallers.h"

#include "clang/AST/ASTTypeTraits.h"

#include "clang/ASTMatchers/ASTMatchers.h"

#include "clang/ASTMatchers/Dynamic/Diagnostics.h"

#include "clang/ASTMatchers/Dynamic/VariantValue.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/Support/ManagedStatic.h"

#include "llvm/Support/raw_ostream.h"

#include <cassert>

#include <iterator>

#include <memory>

#include <optional>

#include <set>

#include <string>

#include <utility>

#include <vector>


namespace clang {

namespace ast_matchers {

namespace dynamic {


namespace {


using internal::MatcherDescriptor;


using ConstructorMap =

    llvm::StringMap<std::unique_ptr<const MatcherDescriptor>>;


class RegistryMaps {

public:

  RegistryMaps();

  ~RegistryMaps();


  const ConstructorMap &constructors() const { return Constructors; }


private:

  void registerMatcher(StringRef MatcherName,

                       std::unique_ptr<MatcherDescriptor> Callback);


  ConstructorMap Constructors;

};


} // namespace


void RegistryMaps::registerMatcher(

    StringRef MatcherName, std::unique_ptr<MatcherDescriptor> Callback) {

  assert(!Constructors.contains(MatcherName));

  Constructors[MatcherName] = std::move(Callback);

}


#define REGISTER_MATCHER(name)                                                 \

  registerMatcher(#name, internal::makeMatcherAutoMarshall(                    \

                             ::clang::ast_matchers::name, #name));


#define REGISTER_MATCHER_OVERLOAD(name)                                        \

  registerMatcher(#name,                                                       \

      std::make_unique<internal::OverloadedMatcherDescriptor>(name##Callbacks))


#define SPECIFIC_MATCHER_OVERLOAD(name, Id)                                    \

  static_cast<::clang::ast_matchers::name##_Type##Id>(                         \

      ::clang::ast_matchers::name)


#define MATCHER_OVERLOAD_ENTRY(name, Id)                                       \

        internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, Id), \

                                          #name)


#define REGISTER_OVERLOADED_2(name)                                            \

  do {                                                                         \

    std::unique_ptr<MatcherDescriptor> name##Callbacks[] = {                   \

        MATCHER_OVERLOAD_ENTRY(name, 0),                                       \

        MATCHER_OVERLOAD_ENTRY(name, 1)};                                      \

    REGISTER_MATCHER_OVERLOAD(name);                                           \

  } while (false)


#define REGISTER_REGEX_MATCHER(name)                                           \

  registerMatcher(#name, internal::makeMatcherRegexMarshall(name, name))


/// Generate a registry map with all the known matchers.

/// Please keep sorted alphabetically!

RegistryMaps::RegistryMaps() {

  // TODO: Here is the list of the missing matchers, grouped by reason.

  //

  // Polymorphic + argument overload:

  // findAll

  //

  // Other:

  // equalsNode


  registerMatcher("mapAnyOf",

                  std::make_unique<internal::MapAnyOfBuilderDescriptor>());


  REGISTER_OVERLOADED_2(callee);

  REGISTER_OVERLOADED_2(hasPrefix);

  REGISTER_OVERLOADED_2(hasType);

  REGISTER_OVERLOADED_2(ignoringParens);

  REGISTER_OVERLOADED_2(isDerivedFrom);

  REGISTER_OVERLOADED_2(isDirectlyDerivedFrom);

  REGISTER_OVERLOADED_2(isSameOrDerivedFrom);

  REGISTER_OVERLOADED_2(loc);

  REGISTER_OVERLOADED_2(pointsTo);

  REGISTER_OVERLOADED_2(references);

  REGISTER_OVERLOADED_2(thisPointerType);


  std::unique_ptr<MatcherDescriptor> equalsCallbacks[] = {

      MATCHER_OVERLOAD_ENTRY(equals, 0),

      MATCHER_OVERLOAD_ENTRY(equals, 1),

      MATCHER_OVERLOAD_ENTRY(equals, 2),

  };

  REGISTER_MATCHER_OVERLOAD(equals);


  REGISTER_REGEX_MATCHER(isExpansionInFileMatching);

  REGISTER_REGEX_MATCHER(matchesName);

  REGISTER_REGEX_MATCHER(matchesSelector);


  REGISTER_MATCHER(accessSpecDecl);

  REGISTER_MATCHER(addrLabelExpr);

  REGISTER_MATCHER(alignOfExpr);

  REGISTER_MATCHER(allOf);

  REGISTER_MATCHER(anyOf);

  REGISTER_MATCHER(anything);

  REGISTER_MATCHER(arrayInitIndexExpr);

  REGISTER_MATCHER(arrayInitLoopExpr);

  REGISTER_MATCHER(argumentCountIs);

  REGISTER_MATCHER(argumentCountAtLeast);

  REGISTER_MATCHER(arraySubscriptExpr);

  REGISTER_MATCHER(arrayType);

  REGISTER_MATCHER(asString);

  REGISTER_MATCHER(asmStmt);

  REGISTER_MATCHER(atomicExpr);

  REGISTER_MATCHER(atomicType);

  REGISTER_MATCHER(attr);

  REGISTER_MATCHER(autoType);

  REGISTER_MATCHER(autoreleasePoolStmt)

  REGISTER_MATCHER(binaryConditionalOperator);

  REGISTER_MATCHER(binaryOperator);

  REGISTER_MATCHER(binaryOperation);

  REGISTER_MATCHER(bindingDecl);

  REGISTER_MATCHER(blockDecl);

  REGISTER_MATCHER(blockExpr);

  REGISTER_MATCHER(blockPointerType);

  REGISTER_MATCHER(booleanType);

  REGISTER_MATCHER(breakStmt);

  REGISTER_MATCHER(builtinType);

  REGISTER_MATCHER(cStyleCastExpr);

  REGISTER_MATCHER(callExpr);

  REGISTER_MATCHER(capturesThis);

  REGISTER_MATCHER(capturesVar);

  REGISTER_MATCHER(caseStmt);

  REGISTER_MATCHER(castExpr);

  REGISTER_MATCHER(characterLiteral);

  REGISTER_MATCHER(chooseExpr);

  REGISTER_MATCHER(classTemplateDecl);

  REGISTER_MATCHER(classTemplatePartialSpecializationDecl);

  REGISTER_MATCHER(classTemplateSpecializationDecl);

  REGISTER_MATCHER(complexType);

  REGISTER_MATCHER(compoundLiteralExpr);

  REGISTER_MATCHER(compoundStmt);

  REGISTER_MATCHER(coawaitExpr);

  REGISTER_MATCHER(conceptDecl);

  REGISTER_MATCHER(conditionalOperator);

  REGISTER_MATCHER(constantArrayType);

  REGISTER_MATCHER(constantExpr);

  REGISTER_MATCHER(containsDeclaration);

  REGISTER_MATCHER(continueStmt);

  REGISTER_MATCHER(convertVectorExpr);

  REGISTER_MATCHER(coreturnStmt);

  REGISTER_MATCHER(coroutineBodyStmt);

  REGISTER_MATCHER(coyieldExpr);

  REGISTER_MATCHER(cudaKernelCallExpr);

  REGISTER_MATCHER(cxxBaseSpecifier);

  REGISTER_MATCHER(cxxBindTemporaryExpr);

  REGISTER_MATCHER(cxxBoolLiteral);

  REGISTER_MATCHER(cxxCatchStmt);

  REGISTER_MATCHER(cxxConstCastExpr);

  REGISTER_MATCHER(cxxConstructExpr);

  REGISTER_MATCHER(cxxConstructorDecl);

  REGISTER_MATCHER(cxxConversionDecl);

  REGISTER_MATCHER(cxxCtorInitializer);

  REGISTER_MATCHER(cxxDeductionGuideDecl);

  REGISTER_MATCHER(cxxDefaultArgExpr);

  REGISTER_MATCHER(cxxDeleteExpr);

  REGISTER_MATCHER(cxxDependentScopeMemberExpr);

  REGISTER_MATCHER(cxxDestructorDecl);

  REGISTER_MATCHER(cxxDynamicCastExpr);

  REGISTER_MATCHER(cxxFoldExpr);

  REGISTER_MATCHER(cxxForRangeStmt);

  REGISTER_MATCHER(cxxFunctionalCastExpr);

  REGISTER_MATCHER(cxxMemberCallExpr);

  REGISTER_MATCHER(cxxMethodDecl);

  REGISTER_MATCHER(cxxNewExpr);

  REGISTER_MATCHER(cxxNoexceptExpr);

  REGISTER_MATCHER(cxxNullPtrLiteralExpr);

  REGISTER_MATCHER(cxxOperatorCallExpr);

  REGISTER_MATCHER(cxxRecordDecl);

  REGISTER_MATCHER(cxxReinterpretCastExpr);

  REGISTER_MATCHER(cxxRewrittenBinaryOperator);

  REGISTER_MATCHER(cxxStaticCastExpr);

  REGISTER_MATCHER(cxxStdInitializerListExpr);

  REGISTER_MATCHER(cxxTemporaryObjectExpr);

  REGISTER_MATCHER(cxxThisExpr);

  REGISTER_MATCHER(cxxThrowExpr);

  REGISTER_MATCHER(cxxTryStmt);

  REGISTER_MATCHER(cxxUnresolvedConstructExpr);

  REGISTER_MATCHER(decayedType);

  REGISTER_MATCHER(decl);

  REGISTER_MATCHER(decompositionDecl);

  REGISTER_MATCHER(declCountIs);

  REGISTER_MATCHER(declRefExpr);

  REGISTER_MATCHER(dependentNameType);

  REGISTER_MATCHER(dependentScopeDeclRefExpr);

  REGISTER_MATCHER(dependentTemplateSpecializationType);

  REGISTER_MATCHER(declStmt);

  REGISTER_MATCHER(declaratorDecl);

  REGISTER_MATCHER(decltypeType);

  REGISTER_MATCHER(deducedTemplateSpecializationType);

  REGISTER_MATCHER(defaultStmt);

  REGISTER_MATCHER(dependentCoawaitExpr);

  REGISTER_MATCHER(dependentSizedArrayType);

  REGISTER_MATCHER(dependentSizedExtVectorType);

  REGISTER_MATCHER(designatedInitExpr);

  REGISTER_MATCHER(designatorCountIs);

  REGISTER_MATCHER(doStmt);

  REGISTER_MATCHER(eachOf);

  REGISTER_MATCHER(elaboratedType);

  REGISTER_MATCHER(elaboratedTypeLoc);

  REGISTER_MATCHER(usingType);

  REGISTER_MATCHER(enumConstantDecl);

  REGISTER_MATCHER(enumDecl);

  REGISTER_MATCHER(enumType);

  REGISTER_MATCHER(equalsBoundNode);

  REGISTER_MATCHER(equalsIntegralValue);

  REGISTER_MATCHER(explicitCastExpr);

  REGISTER_MATCHER(exportDecl);

  REGISTER_MATCHER(expr);

  REGISTER_MATCHER(exprWithCleanups);

  REGISTER_MATCHER(fieldDecl);

  REGISTER_MATCHER(fixedPointLiteral);

  REGISTER_MATCHER(floatLiteral);

  REGISTER_MATCHER(forCallable);

  REGISTER_MATCHER(forDecomposition);

  REGISTER_MATCHER(forEach);

  REGISTER_MATCHER(forEachArgumentWithParam);

  REGISTER_MATCHER(forEachArgumentWithParamType);

  REGISTER_MATCHER(forEachConstructorInitializer);

  REGISTER_MATCHER(forEachDescendant);

  REGISTER_MATCHER(forEachLambdaCapture);

  REGISTER_MATCHER(forEachOverridden);

  REGISTER_MATCHER(forEachSwitchCase);

  REGISTER_MATCHER(forEachTemplateArgument);

  REGISTER_MATCHER(forField);

  REGISTER_MATCHER(forFunction);

  REGISTER_MATCHER(forStmt);

  REGISTER_MATCHER(friendDecl);

  REGISTER_MATCHER(functionDecl);

  REGISTER_MATCHER(functionProtoType);

  REGISTER_MATCHER(functionTemplateDecl);

  REGISTER_MATCHER(functionType);

  REGISTER_MATCHER(genericSelectionExpr);

  REGISTER_MATCHER(gnuNullExpr);

  REGISTER_MATCHER(gotoStmt);

  REGISTER_MATCHER(has);

  REGISTER_MATCHER(hasAncestor);

  REGISTER_MATCHER(hasAnyArgument);

  REGISTER_MATCHER(hasAnyBase);

  REGISTER_MATCHER(hasAnyBinding);

  REGISTER_MATCHER(hasAnyBody);

  REGISTER_MATCHER(hasAnyCapture);

  REGISTER_MATCHER(hasAnyClause);

  REGISTER_MATCHER(hasAnyConstructorInitializer);

  REGISTER_MATCHER(hasAnyDeclaration);

  REGISTER_MATCHER(hasAnyName);

  REGISTER_MATCHER(hasAnyOperatorName);

  REGISTER_MATCHER(hasAnyOverloadedOperatorName);

  REGISTER_MATCHER(hasAnyParameter);

  REGISTER_MATCHER(hasAnyPlacementArg);

  REGISTER_MATCHER(hasAnySelector);

  REGISTER_MATCHER(hasAnySubstatement);

  REGISTER_MATCHER(hasAnyTemplateArgument);

  REGISTER_MATCHER(hasAnyTemplateArgumentLoc);

  REGISTER_MATCHER(hasAnyUsingShadowDecl);

  REGISTER_MATCHER(hasArgument);

  REGISTER_MATCHER(hasArgumentOfType);

  REGISTER_MATCHER(hasArraySize);

  REGISTER_MATCHER(hasAttr);

  REGISTER_MATCHER(hasAutomaticStorageDuration);

  REGISTER_MATCHER(hasBase);

  REGISTER_MATCHER(hasBinding);

  REGISTER_MATCHER(hasBitWidth);

  REGISTER_MATCHER(hasBody);

  REGISTER_MATCHER(hasCanonicalType);

  REGISTER_MATCHER(hasCaseConstant);

  REGISTER_MATCHER(hasCastKind);

  REGISTER_MATCHER(hasCondition);

  REGISTER_MATCHER(hasConditionVariableStatement);

  REGISTER_MATCHER(hasDecayedType);

  REGISTER_MATCHER(hasDeclContext);

  REGISTER_MATCHER(hasDeclaration);

  REGISTER_MATCHER(hasDeducedType);

  REGISTER_MATCHER(hasDefaultArgument);

  REGISTER_MATCHER(hasDefinition);

  REGISTER_MATCHER(hasDependentName);

  REGISTER_MATCHER(hasDescendant);

  REGISTER_MATCHER(hasDestinationType);

  REGISTER_MATCHER(hasDirectBase);

  REGISTER_MATCHER(hasDynamicExceptionSpec);

  REGISTER_MATCHER(hasEitherOperand);

  REGISTER_MATCHER(hasElementType);

  REGISTER_MATCHER(hasElse);

  REGISTER_MATCHER(hasExplicitSpecifier);

  REGISTER_MATCHER(hasExternalFormalLinkage);

  REGISTER_MATCHER(hasFalseExpression);

  REGISTER_MATCHER(hasFoldInit);

  REGISTER_MATCHER(hasGlobalStorage);

  REGISTER_MATCHER(hasImplicitDestinationType);

  REGISTER_MATCHER(hasInClassInitializer);

  REGISTER_MATCHER(hasIncrement);

  REGISTER_MATCHER(hasIndex);

  REGISTER_MATCHER(hasInit);

  REGISTER_MATCHER(hasInitializer);

  REGISTER_MATCHER(hasInitStatement);

  REGISTER_MATCHER(hasKeywordSelector);

  REGISTER_MATCHER(hasLHS);

  REGISTER_MATCHER(hasLocalQualifiers);

  REGISTER_MATCHER(hasLocalStorage);

  REGISTER_MATCHER(hasLoopInit);

  REGISTER_MATCHER(hasLoopVariable);

  REGISTER_MATCHER(hasMemberName);

  REGISTER_MATCHER(hasMethod);

  REGISTER_MATCHER(hasName);

  REGISTER_MATCHER(hasNamedTypeLoc);

  REGISTER_MATCHER(hasNullSelector);

  REGISTER_MATCHER(hasObjectExpression);

  REGISTER_MATCHER(hasOperands);

  REGISTER_MATCHER(hasOperatorName);

  REGISTER_MATCHER(hasOverloadedOperatorName);

  REGISTER_MATCHER(hasParameter);

  REGISTER_MATCHER(hasParent);

  REGISTER_MATCHER(hasPattern);

  REGISTER_MATCHER(hasPointeeLoc);

  REGISTER_MATCHER(hasQualifier);

  REGISTER_MATCHER(hasRHS);

  REGISTER_MATCHER(hasRangeInit);

  REGISTER_MATCHER(hasReceiver);

  REGISTER_MATCHER(hasReceiverType);

  REGISTER_MATCHER(hasReferentLoc);

  REGISTER_MATCHER(hasReplacementType);

  REGISTER_MATCHER(hasReturnTypeLoc);

  REGISTER_MATCHER(hasReturnValue);

  REGISTER_MATCHER(hasPlacementArg);

  REGISTER_MATCHER(hasSelector);

  REGISTER_MATCHER(hasSingleDecl);

  REGISTER_MATCHER(hasSize);

  REGISTER_MATCHER(hasSizeExpr);

  REGISTER_MATCHER(hasSourceExpression);

  REGISTER_MATCHER(hasSpecializedTemplate);

  REGISTER_MATCHER(hasStaticStorageDuration);

  REGISTER_MATCHER(hasStructuredBlock);

  REGISTER_MATCHER(hasSyntacticForm);

  REGISTER_MATCHER(hasTargetDecl);

  REGISTER_MATCHER(hasTemplateArgument);

  REGISTER_MATCHER(hasTemplateArgumentLoc);

  REGISTER_MATCHER(hasThen);

  REGISTER_MATCHER(hasThreadStorageDuration);

  REGISTER_MATCHER(hasTrailingReturn);

  REGISTER_MATCHER(hasTrueExpression);

  REGISTER_MATCHER(hasTypeLoc);

  REGISTER_MATCHER(hasUnaryOperand);

  REGISTER_MATCHER(hasUnarySelector);

  REGISTER_MATCHER(hasUnderlyingDecl);

  REGISTER_MATCHER(hasUnderlyingType);

  REGISTER_MATCHER(hasUnqualifiedDesugaredType);

  REGISTER_MATCHER(hasUnqualifiedLoc);

  REGISTER_MATCHER(hasValueType);

  REGISTER_MATCHER(ifStmt);

  REGISTER_MATCHER(ignoringElidableConstructorCall);

  REGISTER_MATCHER(ignoringImpCasts);

  REGISTER_MATCHER(ignoringImplicit);

  REGISTER_MATCHER(ignoringParenCasts);

  REGISTER_MATCHER(ignoringParenImpCasts);

  REGISTER_MATCHER(imaginaryLiteral);

  REGISTER_MATCHER(implicitCastExpr);

  REGISTER_MATCHER(implicitValueInitExpr);

  REGISTER_MATCHER(incompleteArrayType);

  REGISTER_MATCHER(indirectFieldDecl);

  REGISTER_MATCHER(initListExpr);

  REGISTER_MATCHER(injectedClassNameType);

  REGISTER_MATCHER(innerType);

  REGISTER_MATCHER(integerLiteral);

  REGISTER_MATCHER(invocation);

  REGISTER_MATCHER(isAllowedToContainClauseKind);

  REGISTER_MATCHER(isAnonymous);

  REGISTER_MATCHER(isAnyCharacter);

  REGISTER_MATCHER(isAnyPointer);

  REGISTER_MATCHER(isArray);

  REGISTER_MATCHER(isArrow);

  REGISTER_MATCHER(isAssignmentOperator);

  REGISTER_MATCHER(isAtPosition);

  REGISTER_MATCHER(isBaseInitializer);

  REGISTER_MATCHER(isBinaryFold);

  REGISTER_MATCHER(isBitField);

  REGISTER_MATCHER(isCatchAll);

  REGISTER_MATCHER(isClass);

  REGISTER_MATCHER(isClassMessage);

  REGISTER_MATCHER(isClassMethod);

  REGISTER_MATCHER(isComparisonOperator);

  REGISTER_MATCHER(isConst);

  REGISTER_MATCHER(isConstQualified);

  REGISTER_MATCHER(isConsteval);

  REGISTER_MATCHER(isConstexpr);

  REGISTER_MATCHER(isConstinit);

  REGISTER_MATCHER(isCopyAssignmentOperator);

  REGISTER_MATCHER(isCopyConstructor);

  REGISTER_MATCHER(isDefaultConstructor);

  REGISTER_MATCHER(isDefaulted);

  REGISTER_MATCHER(isDefinition);

  REGISTER_MATCHER(isDelegatingConstructor);

  REGISTER_MATCHER(isDeleted);

  REGISTER_MATCHER(isEnum);

  REGISTER_MATCHER(isExceptionVariable);

  REGISTER_MATCHER(isExpandedFromMacro);

  REGISTER_MATCHER(isExpansionInMainFile);

  REGISTER_MATCHER(isExpansionInSystemHeader);

  REGISTER_MATCHER(isExplicit);

  REGISTER_MATCHER(isExplicitObjectMemberFunction);

  REGISTER_MATCHER(isExplicitTemplateSpecialization);

  REGISTER_MATCHER(isExpr);

  REGISTER_MATCHER(isExternC);

  REGISTER_MATCHER(isFinal);

  REGISTER_MATCHER(isPrivateKind);

  REGISTER_MATCHER(isFirstPrivateKind);

  REGISTER_MATCHER(isImplicit);

  REGISTER_MATCHER(isInAnonymousNamespace);

  REGISTER_MATCHER(isInStdNamespace);

  REGISTER_MATCHER(isInTemplateInstantiation);

  REGISTER_MATCHER(isInitCapture);

  REGISTER_MATCHER(isInline);

  REGISTER_MATCHER(isInstanceMessage);

  REGISTER_MATCHER(isInstanceMethod);

  REGISTER_MATCHER(isInstantiated);

  REGISTER_MATCHER(isInstantiationDependent);

  REGISTER_MATCHER(isInteger);

  REGISTER_MATCHER(isIntegral);

  REGISTER_MATCHER(isLambda);

  REGISTER_MATCHER(isLeftFold);

  REGISTER_MATCHER(isListInitialization);

  REGISTER_MATCHER(isMain);

  REGISTER_MATCHER(isMemberInitializer);

  REGISTER_MATCHER(isMoveAssignmentOperator);

  REGISTER_MATCHER(isMoveConstructor);

  REGISTER_MATCHER(isNoReturn);

  REGISTER_MATCHER(isNoThrow);

  REGISTER_MATCHER(isNoneKind);

  REGISTER_MATCHER(isOverride);

  REGISTER_MATCHER(isPrivate);

  REGISTER_MATCHER(isProtected);

  REGISTER_MATCHER(isPublic);

  REGISTER_MATCHER(isPure);

  REGISTER_MATCHER(isRightFold);

  REGISTER_MATCHER(isScoped);

  REGISTER_MATCHER(isSharedKind);

  REGISTER_MATCHER(isSignedInteger);

  REGISTER_MATCHER(isStandaloneDirective);

  REGISTER_MATCHER(isStaticLocal);

  REGISTER_MATCHER(isStaticStorageClass);

  REGISTER_MATCHER(isStruct);

  REGISTER_MATCHER(isTemplateInstantiation);

  REGISTER_MATCHER(isTypeDependent);

  REGISTER_MATCHER(isUnaryFold);

  REGISTER_MATCHER(isUnion);

  REGISTER_MATCHER(isUnsignedInteger);

  REGISTER_MATCHER(isUserProvided);

  REGISTER_MATCHER(isValueDependent);

  REGISTER_MATCHER(isVariadic);

  REGISTER_MATCHER(isVirtual);

  REGISTER_MATCHER(isVirtualAsWritten);

  REGISTER_MATCHER(isVolatileQualified);

  REGISTER_MATCHER(isWeak);

  REGISTER_MATCHER(isWritten);

  REGISTER_MATCHER(lValueReferenceType);

  REGISTER_MATCHER(labelDecl);

  REGISTER_MATCHER(labelStmt);

  REGISTER_MATCHER(lambdaCapture);

  REGISTER_MATCHER(lambdaExpr);

  REGISTER_MATCHER(linkageSpecDecl);

  REGISTER_MATCHER(macroQualifiedType);

  REGISTER_MATCHER(materializeTemporaryExpr);

  REGISTER_MATCHER(member);

  REGISTER_MATCHER(memberExpr);

  REGISTER_MATCHER(memberHasSameNameAsBoundNode);

  REGISTER_MATCHER(memberPointerType);

  REGISTER_MATCHER(namedDecl);

  REGISTER_MATCHER(namesType);

  REGISTER_MATCHER(namespaceAliasDecl);

  REGISTER_MATCHER(namespaceDecl);

  REGISTER_MATCHER(nestedNameSpecifier);

  REGISTER_MATCHER(nestedNameSpecifierLoc);

  REGISTER_MATCHER(nonTypeTemplateParmDecl);

  REGISTER_MATCHER(nullPointerConstant);

  REGISTER_MATCHER(nullStmt);

  REGISTER_MATCHER(numSelectorArgs);

  REGISTER_MATCHER(objcCatchStmt);

  REGISTER_MATCHER(objcCategoryDecl);

  REGISTER_MATCHER(objcCategoryImplDecl);

  REGISTER_MATCHER(objcFinallyStmt);

  REGISTER_MATCHER(objcImplementationDecl);

  REGISTER_MATCHER(objcInterfaceDecl);

  REGISTER_MATCHER(objcIvarDecl);

  REGISTER_MATCHER(objcIvarRefExpr);

  REGISTER_MATCHER(objcMessageExpr);

  REGISTER_MATCHER(objcMethodDecl);

  REGISTER_MATCHER(objcObjectPointerType);

  REGISTER_MATCHER(objcPropertyDecl);

  REGISTER_MATCHER(objcProtocolDecl);

  REGISTER_MATCHER(objcStringLiteral);

  REGISTER_MATCHER(objcThrowStmt);

  REGISTER_MATCHER(objcTryStmt);

  REGISTER_MATCHER(ofClass);

  REGISTER_MATCHER(ofKind);

  REGISTER_MATCHER(ompDefaultClause);

  REGISTER_MATCHER(ompExecutableDirective);

  REGISTER_MATCHER(on);

  REGISTER_MATCHER(onImplicitObjectArgument);

  REGISTER_MATCHER(opaqueValueExpr);

  REGISTER_MATCHER(optionally);

  REGISTER_MATCHER(parameterCountIs);

  REGISTER_MATCHER(parenExpr);

  REGISTER_MATCHER(parenListExpr);

  REGISTER_MATCHER(parenType);

  REGISTER_MATCHER(parmVarDecl);

  REGISTER_MATCHER(pointee);

  REGISTER_MATCHER(pointerType);

  REGISTER_MATCHER(pointerTypeLoc);

  REGISTER_MATCHER(predefinedExpr);

  REGISTER_MATCHER(qualType);

  REGISTER_MATCHER(qualifiedTypeLoc);

  REGISTER_MATCHER(rValueReferenceType);

  REGISTER_MATCHER(realFloatingPointType);

  REGISTER_MATCHER(recordDecl);

  REGISTER_MATCHER(recordType);

  REGISTER_MATCHER(referenceType);

  REGISTER_MATCHER(referenceTypeLoc);

  REGISTER_MATCHER(refersToDeclaration);

  REGISTER_MATCHER(refersToIntegralType);

  REGISTER_MATCHER(refersToTemplate);

  REGISTER_MATCHER(refersToType);

  REGISTER_MATCHER(requiresZeroInitialization);

  REGISTER_MATCHER(returnStmt);

  REGISTER_MATCHER(returns);

  REGISTER_MATCHER(sizeOfExpr);

  REGISTER_MATCHER(specifiesNamespace);

  REGISTER_MATCHER(specifiesType);

  REGISTER_MATCHER(specifiesTypeLoc);

  REGISTER_MATCHER(statementCountIs);

  REGISTER_MATCHER(staticAssertDecl);

  REGISTER_MATCHER(stmt);

  REGISTER_MATCHER(stmtExpr);

  REGISTER_MATCHER(stringLiteral);

  REGISTER_MATCHER(substNonTypeTemplateParmExpr);

  REGISTER_MATCHER(substTemplateTypeParmType);

  REGISTER_MATCHER(switchCase);

  REGISTER_MATCHER(switchStmt);

  REGISTER_MATCHER(tagDecl);

  REGISTER_MATCHER(tagType);

  REGISTER_MATCHER(templateArgument);

  REGISTER_MATCHER(templateArgumentCountIs);

  REGISTER_MATCHER(templateArgumentLoc);

  REGISTER_MATCHER(templateName);

  REGISTER_MATCHER(templateSpecializationType);

  REGISTER_MATCHER(templateSpecializationTypeLoc);

  REGISTER_MATCHER(templateTemplateParmDecl);

  REGISTER_MATCHER(templateTypeParmDecl);

  REGISTER_MATCHER(templateTypeParmType);

  REGISTER_MATCHER(throughUsingDecl);

  REGISTER_MATCHER(to);

  REGISTER_MATCHER(translationUnitDecl);

  REGISTER_MATCHER(type);

  REGISTER_MATCHER(typeAliasDecl);

  REGISTER_MATCHER(typeAliasTemplateDecl);

  REGISTER_MATCHER(typeLoc);

  REGISTER_MATCHER(typedefDecl);

  REGISTER_MATCHER(typedefNameDecl);

  REGISTER_MATCHER(typedefType);

  REGISTER_MATCHER(unaryExprOrTypeTraitExpr);

  REGISTER_MATCHER(unaryOperator);

  REGISTER_MATCHER(unaryTransformType);

  REGISTER_MATCHER(unless);

  REGISTER_MATCHER(unresolvedLookupExpr);

  REGISTER_MATCHER(unresolvedMemberExpr);

  REGISTER_MATCHER(unresolvedUsingTypenameDecl);

  REGISTER_MATCHER(unresolvedUsingValueDecl);

  REGISTER_MATCHER(userDefinedLiteral);

  REGISTER_MATCHER(usesADL);

  REGISTER_MATCHER(usingDecl);

  REGISTER_MATCHER(usingEnumDecl);

  REGISTER_MATCHER(usingDirectiveDecl);

  REGISTER_MATCHER(valueDecl);

  REGISTER_MATCHER(varDecl);

  REGISTER_MATCHER(variableArrayType);

  REGISTER_MATCHER(voidType);

  REGISTER_MATCHER(whileStmt);

  REGISTER_MATCHER(withInitializer);

}


RegistryMaps::~RegistryMaps() = default;


static llvm::ManagedStatic<RegistryMaps> RegistryData;


ASTNodeKind Registry::nodeMatcherType(MatcherCtor Ctor) {

  return Ctor->nodeMatcherType();

}


internal::MatcherDescriptorPtr::MatcherDescriptorPtr(MatcherDescriptor *Ptr)

    : Ptr(Ptr) {}


internal::MatcherDescriptorPtr::~MatcherDescriptorPtr() { delete Ptr; }


bool Registry::isBuilderMatcher(MatcherCtor Ctor) {

  return Ctor->isBuilderMatcher();

}


internal::MatcherDescriptorPtr

Registry::buildMatcherCtor(MatcherCtor Ctor, SourceRange NameRange,

                           ArrayRef<ParserValue> Args, Diagnostics *Error) {

  return internal::MatcherDescriptorPtr(

      Ctor->buildMatcherCtor(NameRange, Args, Error).release());

}


// static

std::optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {

  auto it = RegistryData->constructors().find(MatcherName);

  return it == RegistryData->constructors().end() ? std::optional<MatcherCtor>()

                                                  : it->second.get();

}


static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,

                                     const std::set<ASTNodeKind> &KS) {

  unsigned Count = 0;

  for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();

       I != E; ++I) {

    if (I != KS.begin())

      OS << "|";

    if (Count++ == 3) {

      OS << "...";

      break;

    }

    OS << *I;

  }

  return OS;

}


std::vector<ArgKind> Registry::getAcceptedCompletionTypes(

    ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {

  ASTNodeKind InitialTypes[] = {

      ASTNodeKind::getFromNodeKind<Decl>(),

      ASTNodeKind::getFromNodeKind<QualType>(),

      ASTNodeKind::getFromNodeKind<Type>(),

      ASTNodeKind::getFromNodeKind<Stmt>(),

      ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),

      ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),

      ASTNodeKind::getFromNodeKind<TypeLoc>()};


  // Starting with the above seed of acceptable top-level matcher types, compute

  // the acceptable type set for the argument indicated by each context element.

  std::set<ArgKind> TypeSet;

  for (auto IT : InitialTypes) {

    TypeSet.insert(ArgKind::MakeMatcherArg(IT));

  }

  for (const auto &CtxEntry : Context) {

    MatcherCtor Ctor = CtxEntry.first;

    unsigned ArgNumber = CtxEntry.second;

    std::vector<ArgKind> NextTypeSet;

    for (const ArgKind &Kind : TypeSet) {

      if (Kind.getArgKind() == Kind.AK_Matcher &&

          Ctor->isConvertibleTo(Kind.getMatcherKind()) &&

          (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))

        Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);

    }

    TypeSet.clear();

    TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());

  }

  return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());

}


std::vector<MatcherCompletion>

Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {

  std::vector<MatcherCompletion> Completions;


  // Search the registry for acceptable matchers.

  for (const auto &M : RegistryData->constructors()) {

    const MatcherDescriptor& Matcher = *M.getValue();

    StringRef Name = M.getKey();


    std::set<ASTNodeKind> RetKinds;

    unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs();

    bool IsPolymorphic = Matcher.isPolymorphic();

    std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);

    unsigned MaxSpecificity = 0;

    bool NodeArgs = false;

    for (const ArgKind& Kind : AcceptedTypes) {

      if (Kind.getArgKind() != Kind.AK_Matcher &&

          Kind.getArgKind() != Kind.AK_Node) {

        continue;

      }


      if (Kind.getArgKind() == Kind.AK_Node) {

        NodeArgs = true;

        unsigned Specificity;

        ASTNodeKind LeastDerivedKind;

        if (Matcher.isConvertibleTo(Kind.getNodeKind(), &Specificity,

                                    &LeastDerivedKind)) {

          if (MaxSpecificity < Specificity)

            MaxSpecificity = Specificity;

          RetKinds.insert(LeastDerivedKind);

          for (unsigned Arg = 0; Arg != NumArgs; ++Arg)

            Matcher.getArgKinds(Kind.getNodeKind(), Arg, ArgsKinds[Arg]);

          if (IsPolymorphic)

            break;

        }

      } else {

        unsigned Specificity;

        ASTNodeKind LeastDerivedKind;

        if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity,

                                    &LeastDerivedKind)) {

          if (MaxSpecificity < Specificity)

            MaxSpecificity = Specificity;

          RetKinds.insert(LeastDerivedKind);

          for (unsigned Arg = 0; Arg != NumArgs; ++Arg)

            Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);

          if (IsPolymorphic)

            break;

        }

      }

    }


    if (!RetKinds.empty() && MaxSpecificity > 0) {

      std::string Decl;

      llvm::raw_string_ostream OS(Decl);


      std::string TypedText = std::string(Name);


      if (NodeArgs) {

        OS << Name;

      } else {


        if (IsPolymorphic) {

          OS << "Matcher<T> " << Name << "(Matcher<T>";

        } else {

          OS << "Matcher<" << RetKinds << "> " << Name << "(";

          for (const std::vector<ArgKind> &Arg : ArgsKinds) {

            if (&Arg != &ArgsKinds[0])

              OS << ", ";


            bool FirstArgKind = true;

            std::set<ASTNodeKind> MatcherKinds;

            // Two steps. First all non-matchers, then matchers only.

            for (const ArgKind &AK : Arg) {

              if (AK.getArgKind() == ArgKind::AK_Matcher) {

                MatcherKinds.insert(AK.getMatcherKind());

              } else {

                if (!FirstArgKind)

                  OS << "|";

                FirstArgKind = false;

                OS << AK.asString();

              }

            }

            if (!MatcherKinds.empty()) {

              if (!FirstArgKind) OS << "|";

              OS << "Matcher<" << MatcherKinds << ">";

            }

          }

        }

        if (Matcher.isVariadic())

          OS << "...";

        OS << ")";


        TypedText += "(";

        if (ArgsKinds.empty())

          TypedText += ")";

        else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)

          TypedText += "\"";

      }


      Completions.emplace_back(TypedText, Decl, MaxSpecificity);

    }

  }


  return Completions;

}


VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,

                                          SourceRange NameRange,

                                          ArrayRef<ParserValue> Args,

                                          Diagnostics *Error) {

  return Ctor->create(NameRange, Args, Error);

}


VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,

                                               SourceRange NameRange,

                                               StringRef BindID,

                                               ArrayRef<ParserValue> Args,

                                               Diagnostics *Error) {

  VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);

  if (Out.isNull()) return Out;


  std::optional<DynTypedMatcher> Result = Out.getSingleMatcher();

  if (Result) {

    std::optional<DynTypedMatcher> Bound = Result->tryBind(BindID);

    if (Bound) {

      return VariantMatcher::SingleMatcher(*Bound);

    }

  }

  Error->addError(NameRange, Error->ET_RegistryNotBindable);

  return VariantMatcher();

}


} // namespace dynamic

} // namespace ast_matchers

} // namespace clang

ASTMatchers.h

ASTTypeTraits.h

Kind
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind

E
Expr * E
Definition: CheckExprLifetime.cpp:209

Diagnostics.h
Diagnostics class to manage error messages.

hasDefinition
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Definition: DynamicTypeChecker.cpp:139

isExternC
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:57

Marshallers.h
Functions templates and classes to wrap matcher construct functions.

MATCHER_OVERLOAD_ENTRY
#define MATCHER_OVERLOAD_ENTRY(name, Id)
Definition: Registry.cpp:79

REGISTER_MATCHER_OVERLOAD
#define REGISTER_MATCHER_OVERLOAD(name)
Definition: Registry.cpp:71

REGISTER_MATCHER
#define REGISTER_MATCHER(name)
Definition: Registry.cpp:67

REGISTER_REGEX_MATCHER
#define REGISTER_REGEX_MATCHER(name)
Definition: Registry.cpp:91

REGISTER_OVERLOADED_2
#define REGISTER_OVERLOADED_2(name)
Definition: Registry.cpp:83

Registry.h
Registry of all known matchers.

hasAttr
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
Definition: SemaCUDA.cpp:109

VariantValue.h
Polymorphic value type.

clang::ASTNodeKind
Kind identifier.
Definition: ASTTypeTraits.h:51

clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86

clang::ast_matchers::dynamic::ArgKind
Kind identifier.
Definition: VariantValue.h:34

clang::ast_matchers::dynamic::ArgKind::MakeMatcherArg
static ArgKind MakeMatcherArg(ASTNodeKind MatcherKind)
Constructor for matcher types.
Definition: VariantValue.h:48

clang::ast_matchers::dynamic::ArgKind::AK_String
@ AK_String
Definition: VariantValue.h:42

clang::ast_matchers::dynamic::ArgKind::AK_Matcher
@ AK_Matcher
Definition: VariantValue.h:37

clang::ast_matchers::dynamic::Diagnostics
Helper class to manage error messages.
Definition: Diagnostics.h:50

clang::ast_matchers::dynamic::Registry::getAcceptedCompletionTypes
static std::vector< ArgKind > getAcceptedCompletionTypes(llvm::ArrayRef< std::pair< MatcherCtor, unsigned > > Context)
Compute the list of completion types for Context.
Definition: Registry.cpp:667

clang::ast_matchers::dynamic::Registry::isBuilderMatcher
static bool isBuilderMatcher(MatcherCtor Ctor)
Definition: Registry.cpp:633

clang::ast_matchers::dynamic::Registry::nodeMatcherType
static ASTNodeKind nodeMatcherType(MatcherCtor)
Definition: Registry.cpp:624

clang::ast_matchers::dynamic::Registry::lookupMatcherCtor
static std::optional< MatcherCtor > lookupMatcherCtor(StringRef MatcherName)
Look up a matcher in the registry by name,.
Definition: Registry.cpp:645

clang::ast_matchers::dynamic::Registry::buildMatcherCtor
static internal::MatcherDescriptorPtr buildMatcherCtor(MatcherCtor, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Definition: Registry.cpp:638

clang::ast_matchers::dynamic::Registry::getMatcherCompletions
static std::vector< MatcherCompletion > getMatcherCompletions(ArrayRef< ArgKind > AcceptedTypes)
Compute the list of completions that match any of AcceptedTypes.
Definition: Registry.cpp:701

clang::ast_matchers::dynamic::Registry::constructBoundMatcher
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:813

clang::ast_matchers::dynamic::Registry::constructMatcher
static VariantMatcher constructMatcher(MatcherCtor Ctor, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Construct a matcher from the registry.
Definition: Registry.cpp:806

clang::ast_matchers::dynamic::VariantMatcher
A variant matcher object.
Definition: VariantValue.h:105

clang::ast_matchers::dynamic::VariantMatcher::SingleMatcher
static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher)
Clones the provided matcher.
Definition: VariantValue.cpp:227

clang::ast_matchers::dynamic::internal::MatcherDescriptorPtr
A smart (owning) pointer for MatcherDescriptor.
Definition: Registry.h:38

clang::ast_matchers::dynamic::internal::MatcherDescriptorPtr::MatcherDescriptorPtr
MatcherDescriptorPtr(MatcherDescriptor *)
Definition: Registry.cpp:628

clang::ast_matchers::dynamic::internal::MatcherDescriptorPtr::~MatcherDescriptorPtr
~MatcherDescriptorPtr()
Definition: Registry.cpp:631

clang::ast_matchers::dynamic::internal::MatcherDescriptor
Matcher descriptor interface.
Definition: Marshallers.h:304

clang::ast_matchers::dynamic::internal::MatcherDescriptor::isConvertibleTo
virtual bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity=nullptr, ASTNodeKind *LeastDerivedKind=nullptr) const =0
Returns whether this matcher is convertible to the given type.

clang::ast_matchers::dynamic::internal::MatcherDescriptor::isBuilderMatcher
virtual bool isBuilderMatcher() const
Definition: Marshallers.h:314

clang::ast_matchers::dynamic::internal::MatcherDescriptor::getArgKinds
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...

clang::ast_matchers::dynamic::internal::MatcherDescriptor::buildMatcherCtor
virtual std::unique_ptr< MatcherDescriptor > buildMatcherCtor(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const
Definition: Marshallers.h:317

clang::ast_matchers::dynamic::internal::MatcherDescriptor::isVariadic
virtual bool isVariadic() const =0
Returns whether the matcher is variadic.

clang::ast_matchers::dynamic::internal::MatcherDescriptor::nodeMatcherType
virtual ASTNodeKind nodeMatcherType() const
Definition: Marshallers.h:312

clang::ast_matchers::dynamic::internal::MatcherDescriptor::create
virtual VariantMatcher create(SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const =0

llvm::ArrayRef
Definition: LLVM.h:31

clang::ast_matchers::dynamic::RegistryData
static llvm::ManagedStatic< RegistryMaps > RegistryData
Definition: Registry.cpp:622

clang::ast_matchers::dynamic::operator<<
static llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const std::set< ASTNodeKind > &KS)
Definition: Registry.cpp:651

clang::ast_matchers::fixedPointLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, FixedPointLiteral > fixedPointLiteral
Matches fixed point literals.
Definition: ASTMatchersInternal.cpp:967

clang::ast_matchers::cStyleCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CStyleCastExpr > cStyleCastExpr
Matches a C-style cast expression.
Definition: ASTMatchersInternal.cpp:1012

clang::ast_matchers::tagDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TagDecl > tagDecl
Matches tag declarations.
Definition: ASTMatchersInternal.cpp:827

clang::ast_matchers::cxxReinterpretCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXReinterpretCastExpr > cxxReinterpretCastExpr
Matches a reinterpret_cast expression.
Definition: ASTMatchersInternal.cpp:1004

clang::ast_matchers::varDecl
const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl
Matches variable declarations.
Definition: ASTMatchersInternal.cpp:832

clang::ast_matchers::elaboratedTypeLoc
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ElaboratedTypeLoc > elaboratedTypeLoc
Matches C or C++ elaborated TypeLocs.
Definition: ASTMatchersInternal.cpp:814

clang::ast_matchers::stmtExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, StmtExpr > stmtExpr
Matches statement expression (GNU extension).
Definition: ASTMatchersInternal.cpp:987

clang::ast_matchers::exprWithCleanups
const internal::VariadicDynCastAllOfMatcher< Stmt, ExprWithCleanups > exprWithCleanups
Matches expressions that introduce cleanups to be run at the end of the sub-expression's evaluation.
Definition: ASTMatchersInternal.cpp:878

clang::ast_matchers::declRefExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclRefExpr > declRefExpr
Matches expressions that refer to declarations.
Definition: ASTMatchersInternal.cpp:926

clang::ast_matchers::typedefNameDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefNameDecl > typedefNameDecl
Matches typedef name declarations.
Definition: ASTMatchersInternal.cpp:758

clang::ast_matchers::objcIvarDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCIvarDecl > objcIvarDecl
Matches Objective-C instance variable declarations.
Definition: ASTMatchersInternal.cpp:867

clang::ast_matchers::enumType
const AstTypeMatcher< EnumType > enumType
Matches enum types.
Definition: ASTMatchersInternal.cpp:1100

clang::ast_matchers::functionProtoType
const AstTypeMatcher< FunctionProtoType > functionProtoType
Matches FunctionProtoType nodes.
Definition: ASTMatchersInternal.cpp:1089

clang::ast_matchers::elaboratedType
const AstTypeMatcher< ElaboratedType > elaboratedType
Matches types specified with an elaborated type keyword or with a qualified name.
Definition: ASTMatchersInternal.cpp:1105

clang::ast_matchers::typeAliasDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasDecl > typeAliasDecl
Matches type alias declarations.
Definition: ASTMatchersInternal.cpp:759

clang::ast_matchers::usingEnumDecl
const internal::VariadicDynCastAllOfMatcher< Decl, UsingEnumDecl > usingEnumDecl
Matches using-enum declarations.
Definition: ASTMatchersInternal.cpp:888

clang::ast_matchers::objcObjectPointerType
const AstTypeMatcher< ObjCObjectPointerType > objcObjectPointerType
Matches an Objective-C object pointer type, which is different from a pointer type,...
Definition: ASTMatchersInternal.cpp:1095

clang::ast_matchers::constantExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ConstantExpr > constantExpr
Matches a constant expression wrapper.
Definition: ASTMatchersInternal.cpp:897

clang::ast_matchers::arrayInitLoopExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitLoopExpr > arrayInitLoopExpr
Matches a loop initializing the elements of an array in a number of contexts:
Definition: ASTMatchersInternal.cpp:917

clang::ast_matchers::objcIvarRefExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCIvarRefExpr > objcIvarRefExpr
Matches a reference to an ObjCIvar.
Definition: ASTMatchersInternal.cpp:929

clang::ast_matchers::builtinType
const AstTypeMatcher< BuiltinType > builtinType
Matches builtin Types.
Definition: ASTMatchersInternal.cpp:1075

clang::ast_matchers::unless
const internal::VariadicOperatorMatcherFunc< 1, 1 > unless
Matches if the provided matcher does not match.
Definition: ASTMatchersInternal.cpp:1067

clang::ast_matchers::conceptDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ConceptDecl > conceptDecl
Matches concept declarations.
Definition: ASTMatchersInternal.cpp:831

clang::ast_matchers::coyieldExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CoyieldExpr > coyieldExpr
Matches co_yield expressions.
Definition: ASTMatchersInternal.cpp:982

clang::ast_matchers::dependentSizedExtVectorType
const AstTypeMatcher< DependentSizedExtVectorType > dependentSizedExtVectorType
Matches C++ extended vector type where either the type or size is dependent.
Definition: ASTMatchersInternal.cpp:1082

clang::ast_matchers::cxxDeleteExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDeleteExpr > cxxDeleteExpr
Matches delete expressions.
Definition: ASTMatchersInternal.cpp:909

clang::ast_matchers::templateName
const internal::VariadicAllOfMatcher< TemplateName > templateName
Matches template name.
Definition: ASTMatchersInternal.cpp:791

clang::ast_matchers::objcProtocolDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCProtocolDecl > objcProtocolDecl
Matches Objective-C protocol declarations.
Definition: ASTMatchersInternal.cpp:858

clang::ast_matchers::dependentTemplateSpecializationType
const AstTypeMatcher< DependentTemplateSpecializationType > dependentTemplateSpecializationType
Matches a dependent template specialization type.
Definition: ASTMatchersInternal.cpp:1113

clang::ast_matchers::implicitCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitCastExpr > implicitCastExpr
Matches the implicit cast nodes of Clang's AST.
Definition: ASTMatchersInternal.cpp:1016

clang::ast_matchers::optionally
const internal::VariadicOperatorMatcherFunc< 1, 1 > optionally
Matches any node regardless of the submatcher.
Definition: ASTMatchersInternal.cpp:1035

clang::ast_matchers::usingDecl
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDecl > usingDecl
Matches using declarations.
Definition: ASTMatchersInternal.cpp:887

clang::ast_matchers::hasDescendant
const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > hasDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
Definition: ASTMatchersInternal.cpp:1052

clang::ast_matchers::objcPropertyDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCPropertyDecl > objcPropertyDecl
Matches Objective-C property declarations.
Definition: ASTMatchersInternal.cpp:869

clang::ast_matchers::stringLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, StringLiteral > stringLiteral
Matches string literals (also matches wide string literals).
Definition: ASTMatchersInternal.cpp:958

clang::ast_matchers::cxxCtorInitializer
const internal::VariadicAllOfMatcher< CXXCtorInitializer > cxxCtorInitializer
Matches constructor initializers.
Definition: ASTMatchersInternal.cpp:788

clang::ast_matchers::objcFinallyStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtFinallyStmt > objcFinallyStmt
Matches Objective-C @finally statements.
Definition: ASTMatchersInternal.cpp:876

clang::ast_matchers::dependentSizedArrayType
const AstTypeMatcher< DependentSizedArrayType > dependentSizedArrayType
Matches C++ arrays whose size is a value-dependent expression.
Definition: ASTMatchersInternal.cpp:1081

clang::ast_matchers::templateSpecializationType
const AstTypeMatcher< TemplateSpecializationType > templateSpecializationType
Matches template specialization types.
Definition: ASTMatchersInternal.cpp:1101

clang::ast_matchers::atomicExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, AtomicExpr > atomicExpr
Matches atomic builtins.
Definition: ASTMatchersInternal.cpp:986

clang::ast_matchers::deducedTemplateSpecializationType
const AstTypeMatcher< DeducedTemplateSpecializationType > deducedTemplateSpecializationType
Matches C++17 deduced template specialization types, e.g.
Definition: ASTMatchersInternal.cpp:1080

clang::ast_matchers::coawaitExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CoawaitExpr > coawaitExpr
Matches co_await expressions.
Definition: ASTMatchersInternal.cpp:978

clang::ast_matchers::enumDecl
const internal::VariadicDynCastAllOfMatcher< Decl, EnumDecl > enumDecl
Matches enum declarations.
Definition: ASTMatchersInternal.cpp:824

clang::ast_matchers::convertVectorExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ConvertVectorExpr > convertVectorExpr
Matches builtin function __builtin_convertvector.
Definition: ASTMatchersInternal.cpp:976

clang::ast_matchers::addrLabelExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, AddrLabelExpr > addrLabelExpr
Matches address of label statements (GNU extension).
Definition: ASTMatchersInternal.cpp:943

clang::ast_matchers::cxxDependentScopeMemberExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDependentScopeMemberExpr > cxxDependentScopeMemberExpr
Matches member expressions where the actual member referenced could not be resolved because the base ...
Definition: ASTMatchersInternal.cpp:846

clang::ast_matchers::predefinedExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, PredefinedExpr > predefinedExpr
Matches predefined identifier expressions [C99 6.4.2.2].
Definition: ASTMatchersInternal.cpp:1023

clang::ast_matchers::nestedNameSpecifier
const internal::VariadicAllOfMatcher< NestedNameSpecifier > nestedNameSpecifier
Matches nested name specifiers.
Definition: ASTMatchersInternal.cpp:1069

clang::ast_matchers::pointerType
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
Definition: ASTMatchersInternal.cpp:1094

clang::ast_matchers::dependentCoawaitExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, DependentCoawaitExpr > dependentCoawaitExpr
Matches co_await expressions where the type of the promise is dependent.
Definition: ASTMatchersInternal.cpp:980

clang::ast_matchers::breakStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, BreakStmt > breakStmt
Matches break statements.
Definition: ASTMatchersInternal.cpp:937

clang::ast_matchers::bindingDecl
const internal::VariadicDynCastAllOfMatcher< Decl, BindingDecl > bindingDecl
Matches binding declarations Example matches foo and bar (matcher = bindingDecl()
Definition: ASTMatchersInternal.cpp:764

clang::ast_matchers::unresolvedLookupExpr
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...
Definition: ASTMatchersInternal.cpp:892

clang::ast_matchers::ompExecutableDirective
const internal::VariadicDynCastAllOfMatcher< Stmt, OMPExecutableDirective > ompExecutableDirective
Matches any #pragma omp executable directive.
Definition: ASTMatchersInternal.cpp:1126

clang::ast_matchers::objcStringLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCStringLiteral > objcStringLiteral
Matches ObjectiveC String literal expressions.
Definition: ASTMatchersInternal.cpp:959

clang::ast_matchers::objcMethodDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCMethodDecl > objcMethodDecl
Matches Objective-C method declarations.
Definition: ASTMatchersInternal.cpp:864

clang::ast_matchers::parmVarDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ParmVarDecl > parmVarDecl
Matches parameter variable declarations.
Definition: ASTMatchersInternal.cpp:784

clang::ast_matchers::cxxRewrittenBinaryOperator
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXRewrittenBinaryOperator > cxxRewrittenBinaryOperator
Matches rewritten binary operators.
Definition: ASTMatchersInternal.cpp:923

clang::ast_matchers::typedefDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
Definition: ASTMatchersInternal.cpp:756

clang::ast_matchers::genericSelectionExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, GenericSelectionExpr > genericSelectionExpr
Matches C11 _Generic expression.
Definition: ASTMatchersInternal.cpp:985

clang::ast_matchers::cxxDeductionGuideDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDeductionGuideDecl > cxxDeductionGuideDecl
Matches user-defined and implicitly generated deduction guide.
Definition: ASTMatchersInternal.cpp:1130

clang::ast_matchers::cxxBoolLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBoolLiteralExpr > cxxBoolLiteral
Matches bool literals.
Definition: ASTMatchersInternal.cpp:957

clang::ast_matchers::dependentNameType
const AstTypeMatcher< DependentNameType > dependentNameType
Matches a dependent name type.
Definition: ASTMatchersInternal.cpp:1111

clang::ast_matchers::returnStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ReturnStmt > returnStmt
Matches return statements.
Definition: ASTMatchersInternal.cpp:940

clang::ast_matchers::asmStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, AsmStmt > asmStmt
Matches asm statements.
Definition: ASTMatchersInternal.cpp:955

clang::ast_matchers::attr
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
Definition: ASTMatchersInternal.cpp:1072

clang::ast_matchers::cxxDynamicCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDynamicCastExpr > cxxDynamicCastExpr
Matches a dynamic_cast expression.
Definition: ASTMatchersInternal.cpp:1008

clang::ast_matchers::coreturnStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CoreturnStmt > coreturnStmt
Matches co_return statements.
Definition: ASTMatchersInternal.cpp:939

clang::ast_matchers::callExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
Definition: ASTMatchersInternal.cpp:847

clang::ast_matchers::lambdaExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, LambdaExpr > lambdaExpr
Matches lambda expressions.
Definition: ASTMatchersInternal.cpp:848

clang::ast_matchers::compoundStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundStmt > compoundStmt
Matches compound statements.
Definition: ASTMatchersInternal.cpp:948

clang::ast_matchers::floatLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, FloatingLiteral > floatLiteral
Matches float literals of all sizes / encodings, e.g.
Definition: ASTMatchersInternal.cpp:964

clang::ast_matchers::autoreleasePoolStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAutoreleasePoolStmt > autoreleasePoolStmt
Matches an Objective-C autorelease pool statement.
Definition: ASTMatchersInternal.cpp:753

clang::ast_matchers::hasAnyOverloadedOperatorName
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.
Definition: ASTMatchersInternal.cpp:1046

clang::ast_matchers::nonTypeTemplateParmDecl
const internal::VariadicDynCastAllOfMatcher< Decl, NonTypeTemplateParmDecl > nonTypeTemplateParmDecl
Matches non-type template parameter declarations.
Definition: ASTMatchersInternal.cpp:793

clang::ast_matchers::variableArrayType
const AstTypeMatcher< VariableArrayType > variableArrayType
Matches C arrays with a specified size that is not an integer-constant-expression.
Definition: ASTMatchersInternal.cpp:1084

clang::ast_matchers::unaryExprOrTypeTraitExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryExprOrTypeTraitExpr > unaryExprOrTypeTraitExpr
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
Definition: ASTMatchersInternal.cpp:817

clang::ast_matchers::nullStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, NullStmt > nullStmt
Matches null statements.
Definition: ASTMatchersInternal.cpp:954

clang::ast_matchers::templateSpecializationTypeLoc
const internal::VariadicDynCastAllOfMatcher< TypeLoc, TemplateSpecializationTypeLoc > templateSpecializationTypeLoc
Matches template specialization TypeLocs.
Definition: ASTMatchersInternal.cpp:812

clang::ast_matchers::forEachDescendant
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachDescendantMatcher > forEachDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
Definition: ASTMatchersInternal.cpp:1056

clang::ast_matchers::cxxBaseSpecifier
const internal::VariadicAllOfMatcher< CXXBaseSpecifier > cxxBaseSpecifier
Matches class bases.
Definition: ASTMatchersInternal.cpp:787

clang::ast_matchers::cxxDefaultArgExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDefaultArgExpr > cxxDefaultArgExpr
Matches the value of a default argument at the call site.
Definition: ASTMatchersInternal.cpp:919

clang::ast_matchers::templateArgument
const internal::VariadicAllOfMatcher< TemplateArgument > templateArgument
Matches template arguments.
Definition: ASTMatchersInternal.cpp:789

clang::ast_matchers::forEach
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachMatcher > forEach
Matches AST nodes that have child AST nodes that match the provided matcher.
Definition: ASTMatchersInternal.cpp:1053

clang::ast_matchers::caseStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CaseStmt > caseStmt
Matches case statements inside switch statements.
Definition: ASTMatchersInternal.cpp:946

clang::ast_matchers::nestedNameSpecifierLoc
const internal::VariadicAllOfMatcher< NestedNameSpecifierLoc > nestedNameSpecifierLoc
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
Definition: ASTMatchersInternal.cpp:1071

clang::ast_matchers::namedDecl
const internal::VariadicDynCastAllOfMatcher< Decl, NamedDecl > namedDecl
Matches a declaration of anything that could have a name.
Definition: ASTMatchersInternal.cpp:767

clang::ast_matchers::unresolvedUsingTypenameDecl
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingTypenameDecl > unresolvedUsingTypenameDecl
Matches unresolved using value declarations that involve the typename.
Definition: ASTMatchersInternal.cpp:896

clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:801

clang::ast_matchers::decltypeType
const AstTypeMatcher< DecltypeType > decltypeType
Matches types nodes representing C++11 decltype(<expr>) types.
Definition: ASTMatchersInternal.cpp:1087

clang::ast_matchers::typeLoc
const internal::VariadicAllOfMatcher< TypeLoc > typeLoc
Matches TypeLocs in the clang AST.
Definition: ASTMatchersInternal.cpp:802

clang::ast_matchers::parenListExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenListExpr > parenListExpr
Matches paren list expressions.
Definition: ASTMatchersInternal.cpp:884

clang::ast_matchers::classTemplatePartialSpecializationDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplatePartialSpecializationDecl > classTemplatePartialSpecializationDecl
Matches C++ class template partial specializations.
Definition: ASTMatchersInternal.cpp:781

clang::ast_matchers::whileStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, WhileStmt > whileStmt
Matches while statements.
Definition: ASTMatchersInternal.cpp:935

clang::ast_matchers::objcCategoryDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryDecl > objcCategoryDecl
Matches Objective-C category declarations.
Definition: ASTMatchersInternal.cpp:860

clang::ast_matchers::anything
internal::TrueMatcher anything()
Matches any node.
Definition: ASTMatchers.h:171

clang::ast_matchers::hasAnySelector
const internal::VariadicFunction< internal::Matcher< ObjCMessageExpr >, StringRef, internal::hasAnySelectorFunc > hasAnySelector
Matches when at least one of the supplied string equals to the Selector.getAsString()
Definition: ASTMatchersInternal.cpp:1049

clang::ast_matchers::autoType
const AstTypeMatcher< AutoType > autoType
Matches types nodes representing C++11 auto types.
Definition: ASTMatchersInternal.cpp:1086

clang::ast_matchers::arrayType
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
Definition: ASTMatchersInternal.cpp:1076

clang::ast_matchers::cxxConversionDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConversionDecl > cxxConversionDecl
Matches conversion operator declarations.
Definition: ASTMatchersInternal.cpp:830

clang::ast_matchers::parenType
const AstTypeMatcher< ParenType > parenType
Matches ParenType nodes.
Definition: ASTMatchersInternal.cpp:1090

clang::ast_matchers::labelDecl
const internal::VariadicDynCastAllOfMatcher< Decl, LabelDecl > labelDecl
Matches a declaration of label.
Definition: ASTMatchersInternal.cpp:768

clang::ast_matchers::cxxFunctionalCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFunctionalCastExpr > cxxFunctionalCastExpr
Matches functional cast expressions.
Definition: ASTMatchersInternal.cpp:1019

clang::ast_matchers::cxxConstCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstCastExpr > cxxConstCastExpr
Matches a const_cast expression.
Definition: ASTMatchersInternal.cpp:1010

clang::ast_matchers::cxxTemporaryObjectExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTemporaryObjectExpr > cxxTemporaryObjectExpr
Matches functional cast expressions having N != 1 arguments.
Definition: ASTMatchersInternal.cpp:1021

clang::ast_matchers::unaryOperator
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryOperator > unaryOperator
Matches unary operator expressions.
Definition: ASTMatchersInternal.cpp:994

clang::ast_matchers::referenceTypeLoc
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ReferenceTypeLoc > referenceTypeLoc
Matches reference TypeLocs.
Definition: ASTMatchersInternal.cpp:809

clang::ast_matchers::hasAnyName
const internal::VariadicFunction< internal::Matcher< NamedDecl >, StringRef, internal::hasAnyNameFunc > hasAnyName
Matches NamedDecl nodes that have any of the specified names.
Definition: ASTMatchersInternal.cpp:1039

clang::ast_matchers::objcMessageExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCMessageExpr > objcMessageExpr
Matches ObjectiveC Message invocation expressions.
Definition: ASTMatchersInternal.cpp:852

clang::ast_matchers::binaryOperation
const internal::MapAnyOfMatcher< BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator > binaryOperation
Matches nodes which can be used with binary operators.
Definition: ASTMatchersInternal.cpp:992

clang::ast_matchers::arraySubscriptExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ArraySubscriptExpr > arraySubscriptExpr
Matches array subscript expressions.
Definition: ASTMatchersInternal.cpp:913

clang::ast_matchers::ompDefaultClause
const internal::VariadicDynCastAllOfMatcher< OMPClause, OMPDefaultClause > ompDefaultClause
Matches OpenMP default clause.
Definition: ASTMatchersInternal.cpp:1128

clang::ast_matchers::accessSpecDecl
const internal::VariadicDynCastAllOfMatcher< Decl, AccessSpecDecl > accessSpecDecl
Matches C++ access specifier declarations.
Definition: ASTMatchersInternal.cpp:786

clang::ast_matchers::linkageSpecDecl
const internal::VariadicDynCastAllOfMatcher< Decl, LinkageSpecDecl > linkageSpecDecl
Matches a declaration of a linkage specification.
Definition: ASTMatchersInternal.cpp:766

clang::ast_matchers::injectedClassNameType
const AstTypeMatcher< InjectedClassNameType > injectedClassNameType
Matches injected class name types.
Definition: ASTMatchersInternal.cpp:1109

clang::ast_matchers::gnuNullExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, GNUNullExpr > gnuNullExpr
Matches GNU __null expression.
Definition: ASTMatchersInternal.cpp:983

clang::ast_matchers::pointerTypeLoc
const internal::VariadicDynCastAllOfMatcher< TypeLoc, PointerTypeLoc > pointerTypeLoc
Matches pointer TypeLocs.
Definition: ASTMatchersInternal.cpp:807

clang::ast_matchers::cxxForRangeStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXForRangeStmt > cxxForRangeStmt
Matches range-based for statements.
Definition: ASTMatchersInternal.cpp:934

clang::ast_matchers::cxxMemberCallExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > cxxMemberCallExpr
Matches member call expressions.
Definition: ASTMatchersInternal.cpp:850

clang::ast_matchers::cxxConstructorDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConstructorDecl > cxxConstructorDecl
Matches C++ constructor declarations.
Definition: ASTMatchersInternal.cpp:821

clang::ast_matchers::dependentScopeDeclRefExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, DependentScopeDeclRefExpr > dependentScopeDeclRefExpr
Matches expressions that refer to dependent scope declarations.
Definition: ASTMatchersInternal.cpp:928

clang::ast_matchers::blockPointerType
const AstTypeMatcher< BlockPointerType > blockPointerType
Matches block pointer types, i.e.
Definition: ASTMatchersInternal.cpp:1091

clang::ast_matchers::sizeOfExpr
internal::BindableMatcher< Stmt > sizeOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching sizeof.
Definition: ASTMatchers.h:3078

clang::ast_matchers::initListExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, InitListExpr > initListExpr
Matches init list expressions.
Definition: ASTMatchersInternal.cpp:879

clang::ast_matchers::atomicType
const AstTypeMatcher< AtomicType > atomicType
Matches atomic types.
Definition: ASTMatchersInternal.cpp:1085

clang::ast_matchers::typeAliasTemplateDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasTemplateDecl > typeAliasTemplateDecl
Matches type alias template declarations.
Definition: ASTMatchersInternal.cpp:761

clang::ast_matchers::cxxNoexceptExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNoexceptExpr > cxxNoexceptExpr
Matches noexcept expressions.
Definition: ASTMatchersInternal.cpp:911

clang::ast_matchers::arrayInitIndexExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitIndexExpr > arrayInitIndexExpr
The arrayInitIndexExpr consists of two subexpressions: a common expression (the source array) that is...
Definition: ASTMatchersInternal.cpp:915

clang::ast_matchers::usingType
const AstTypeMatcher< UsingType > usingType
Matches types specified through a using declaration.
Definition: ASTMatchersInternal.cpp:1106

clang::ast_matchers::cxxNewExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNewExpr > cxxNewExpr
Matches new expressions.
Definition: ASTMatchersInternal.cpp:908

clang::ast_matchers::enumConstantDecl
const internal::VariadicDynCastAllOfMatcher< Decl, EnumConstantDecl > enumConstantDecl
Matches enum constants.
Definition: ASTMatchersInternal.cpp:826

clang::ast_matchers::forStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ForStmt > forStmt
Matches for statements.
Definition: ASTMatchersInternal.cpp:932

clang::ast_matchers::gotoStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, GotoStmt > gotoStmt
Matches goto statements.
Definition: ASTMatchersInternal.cpp:941

clang::ast_matchers::declaratorDecl
const internal::VariadicDynCastAllOfMatcher< Decl, DeclaratorDecl > declaratorDecl
Matches declarator declarations (field, variable, function and non-type template parameter declaratio...
Definition: ASTMatchersInternal.cpp:783

clang::ast_matchers::objcCatchStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtCatchStmt > objcCatchStmt
Matches Objective-C @catch statements.
Definition: ASTMatchersInternal.cpp:874

clang::ast_matchers::binaryOperator
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryOperator > binaryOperator
Matches binary operator expressions.
Definition: ASTMatchersInternal.cpp:989

clang::ast_matchers::qualifiedTypeLoc
const internal::VariadicDynCastAllOfMatcher< TypeLoc, QualifiedTypeLoc > qualifiedTypeLoc
Matches QualifiedTypeLocs in the clang AST.
Definition: ASTMatchersInternal.cpp:805

clang::ast_matchers::templateTypeParmDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTypeParmDecl > templateTypeParmDecl
Matches template type parameter declarations.
Definition: ASTMatchersInternal.cpp:795

clang::ast_matchers::blockExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, BlockExpr > blockExpr
Matches a reference to a block.
Definition: ASTMatchersInternal.cpp:930

clang::ast_matchers::functionTemplateDecl
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionTemplateDecl > functionTemplateDecl
Matches C++ function template declarations.
Definition: ASTMatchersInternal.cpp:838

clang::ast_matchers::parenExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenExpr > parenExpr
Matches parentheses used in expressions.
Definition: ASTMatchersInternal.cpp:898

clang::ast_matchers::staticAssertDecl
const internal::VariadicDynCastAllOfMatcher< Decl, StaticAssertDecl > staticAssertDecl
Matches a C++ static_assert declaration.
Definition: ASTMatchersInternal.cpp:1002

clang::ast_matchers::has
const internal::ArgumentAdaptingMatcherFunc< internal::HasMatcher > has
Matches AST nodes that have child AST nodes that match the provided matcher.
Definition: ASTMatchersInternal.cpp:1050

clang::ast_matchers::coroutineBodyStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CoroutineBodyStmt > coroutineBodyStmt
Matches coroutine body statements.
Definition: ASTMatchersInternal.cpp:950

clang::ast_matchers::macroQualifiedType
const AstTypeMatcher< MacroQualifiedType > macroQualifiedType
Matches qualified types when the qualifier is applied via a macro.
Definition: ASTMatchersInternal.cpp:1092

clang::ast_matchers::objcCategoryImplDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryImplDecl > objcCategoryImplDecl
Matches Objective-C category definitions.
Definition: ASTMatchersInternal.cpp:862

clang::ast_matchers::typedefType
const AstTypeMatcher< TypedefType > typedefType
Matches typedef types.
Definition: ASTMatchersInternal.cpp:1099

clang::ast_matchers::materializeTemporaryExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, MaterializeTemporaryExpr > materializeTemporaryExpr
Matches nodes where temporaries are materialized.
Definition: ASTMatchersInternal.cpp:907

clang::ast_matchers::tagType
const AstTypeMatcher< TagType > tagType
Matches tag types (record and enum types).
Definition: ASTMatchersInternal.cpp:1104

clang::ast_matchers::binaryConditionalOperator
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryConditionalOperator > binaryConditionalOperator
Matches binary conditional operator expressions (GNU extension).
Definition: ASTMatchersInternal.cpp:998

clang::ast_matchers::objcTryStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtTryStmt > objcTryStmt
Matches Objective-C @try statements.
Definition: ASTMatchersInternal.cpp:872

clang::ast_matchers::explicitCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ExplicitCastExpr > explicitCastExpr
Matches explicit cast expressions.
Definition: ASTMatchersInternal.cpp:1014

clang::ast_matchers::equals
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:5891

clang::ast_matchers::cxxStaticCastExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStaticCastExpr > cxxStaticCastExpr
Matches a C++ static_cast expression.
Definition: ASTMatchersInternal.cpp:1006

clang::ast_matchers::valueDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ValueDecl > valueDecl
Matches any value declaration.
Definition: ASTMatchersInternal.cpp:819

clang::ast_matchers::translationUnitDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TranslationUnitDecl > translationUnitDecl
Matches the top declaration context.
Definition: ASTMatchersInternal.cpp:755

clang::ast_matchers::templateTypeParmType
const AstTypeMatcher< TemplateTypeParmType > templateTypeParmType
Matches template type parameter types.
Definition: ASTMatchersInternal.cpp:1108

clang::ast_matchers::constantArrayType
const AstTypeMatcher< ConstantArrayType > constantArrayType
Matches C arrays with a specified constant size.
Definition: ASTMatchersInternal.cpp:1078

clang::ast_matchers::lambdaCapture
const internal::VariadicAllOfMatcher< LambdaCapture > lambdaCapture
Matches lambda captures.
Definition: ASTMatchersInternal.cpp:799

clang::ast_matchers::eachOf
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> eachOf
Matches if any of the given matchers matches.
Definition: ASTMatchersInternal.cpp:1028

clang::ast_matchers::cxxConstructExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstructExpr > cxxConstructExpr
Matches constructor call expressions (including implicit ones).
Definition: ASTMatchersInternal.cpp:900

clang::ast_matchers::objcInterfaceDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCInterfaceDecl > objcInterfaceDecl
Matches Objective-C interface declarations.
Definition: ASTMatchersInternal.cpp:854

clang::ast_matchers::templateTemplateParmDecl
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTemplateParmDecl > templateTemplateParmDecl
Matches template template parameter declarations.
Definition: ASTMatchersInternal.cpp:797

clang::ast_matchers::fieldDecl
const internal::VariadicDynCastAllOfMatcher< Decl, FieldDecl > fieldDecl
Matches field declarations.
Definition: ASTMatchersInternal.cpp:833

clang::ast_matchers::userDefinedLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, UserDefinedLiteral > userDefinedLiteral
Matches user defined literal operator call.
Definition: ASTMatchersInternal.cpp:969

clang::ast_matchers::chooseExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ChooseExpr > chooseExpr
Matches GNU __builtin_choose_expr.
Definition: ASTMatchersInternal.cpp:974

clang::ast_matchers::cxxOperatorCallExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > cxxOperatorCallExpr
Matches overloaded operator calls.
Definition: ASTMatchersInternal.cpp:921

clang::ast_matchers::namespaceAliasDecl
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceAliasDecl > namespaceAliasDecl
Matches a declaration of a namespace alias.
Definition: ASTMatchersInternal.cpp:771

clang::ast_matchers::cxxBindTemporaryExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBindTemporaryExpr > cxxBindTemporaryExpr
Matches nodes where temporaries are created.
Definition: ASTMatchersInternal.cpp:905

clang::ast_matchers::switchCase
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchCase > switchCase
Matches case and default statements inside switch statements.
Definition: ASTMatchersInternal.cpp:945

clang::ast_matchers::defaultStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, DefaultStmt > defaultStmt
Matches default statements inside switch statements.
Definition: ASTMatchersInternal.cpp:947

clang::ast_matchers::allOf
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> allOf
Matches if all given matchers match.
Definition: ASTMatchersInternal.cpp:1034

clang::ast_matchers::classTemplateSpecializationDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateSpecializationDecl > classTemplateSpecializationDecl
Matches C++ class template specializations.
Definition: ASTMatchersInternal.cpp:778

clang::ast_matchers::decompositionDecl
const internal::VariadicDynCastAllOfMatcher< Decl, DecompositionDecl > decompositionDecl
Matches decomposition-declarations.
Definition: ASTMatchersInternal.cpp:763

clang::ast_matchers::substTemplateTypeParmType
const AstTypeMatcher< SubstTemplateTypeParmType > substTemplateTypeParmType
Matches types that represent the result of substituting a type for a template type parameter.
Definition: ASTMatchersInternal.cpp:1107

clang::ast_matchers::functionDecl
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl
Matches function declarations.
Definition: ASTMatchersInternal.cpp:836

clang::ast_matchers::unaryTransformType
const AstTypeMatcher< UnaryTransformType > unaryTransformType
Matches types nodes representing unary type transformations.
Definition: ASTMatchersInternal.cpp:1102

clang::ast_matchers::unresolvedMemberExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, UnresolvedMemberExpr > unresolvedMemberExpr
Matches unresolved member expressions.
Definition: ASTMatchersInternal.cpp:844

clang::ast_matchers::objcThrowStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtThrowStmt > objcThrowStmt
Matches Objective-C @throw statements.
Definition: ASTMatchersInternal.cpp:871

clang::ast_matchers::invocation
const internal::MapAnyOfMatcher< CallExpr, CXXConstructExpr > invocation
Matches function calls and constructor calls.
Definition: ASTMatchersInternal.cpp:993

clang::ast_matchers::cxxThrowExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThrowExpr > cxxThrowExpr
Matches throw expressions.
Definition: ASTMatchersInternal.cpp:953

clang::ast_matchers::switchStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchStmt > switchStmt
Matches switch statements.
Definition: ASTMatchersInternal.cpp:944

clang::ast_matchers::recordType
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
Definition: ASTMatchersInternal.cpp:1103

clang::ast_matchers::memberExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, MemberExpr > memberExpr
Matches member expressions.
Definition: ASTMatchersInternal.cpp:842

clang::ast_matchers::cxxRecordDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > cxxRecordDecl
Matches C++ class declarations.
Definition: ASTMatchersInternal.cpp:773

clang::ast_matchers::templateArgumentLoc
const internal::VariadicAllOfMatcher< TemplateArgumentLoc > templateArgumentLoc
Matches template arguments (with location info).
Definition: ASTMatchersInternal.cpp:790

clang::ast_matchers::referenceType
const AstTypeMatcher< ReferenceType > referenceType
Matches both lvalue and rvalue reference types.
Definition: ASTMatchersInternal.cpp:1096

clang::ast_matchers::designatedInitExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, DesignatedInitExpr > designatedInitExpr
Matches C99 designated initializer expressions [C99 6.7.8].
Definition: ASTMatchersInternal.cpp:1025

clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:762

clang::ast_matchers::cxxDestructorDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDestructorDecl > cxxDestructorDecl
Matches explicit C++ destructor declarations.
Definition: ASTMatchersInternal.cpp:823

clang::ast_matchers::alignOfExpr
internal::BindableMatcher< Stmt > alignOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching alignof.
Definition: ASTMatchers.h:3069

clang::ast_matchers::cxxUnresolvedConstructExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXUnresolvedConstructExpr > cxxUnresolvedConstructExpr
Matches unresolved constructor call expressions.
Definition: ASTMatchersInternal.cpp:902

clang::ast_matchers::objcImplementationDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCImplementationDecl > objcImplementationDecl
Matches Objective-C implementation declarations.
Definition: ASTMatchersInternal.cpp:856

clang::ast_matchers::recordDecl
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
Definition: ASTMatchersInternal.cpp:772

clang::ast_matchers::integerLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, IntegerLiteral > integerLiteral
Matches integer literals of all sizes / encodings, e.g.
Definition: ASTMatchersInternal.cpp:963

clang::ast_matchers::exportDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ExportDecl > exportDecl
Matches any export declaration.
Definition: ASTMatchersInternal.cpp:818

clang::ast_matchers::implicitValueInitExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitValueInitExpr > implicitValueInitExpr
Matches implicit initializers of init list expressions.
Definition: ASTMatchersInternal.cpp:883

clang::ast_matchers::doStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, DoStmt > doStmt
Matches do statements.
Definition: ASTMatchersInternal.cpp:936

clang::ast_matchers::namespaceDecl
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceDecl > namespaceDecl
Matches a declaration of a namespace.
Definition: ASTMatchersInternal.cpp:769

clang::ast_matchers::cxxNullPtrLiteralExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNullPtrLiteralExpr > cxxNullPtrLiteralExpr
Matches nullptr literal.
Definition: ASTMatchersInternal.cpp:973

clang::ast_matchers::hasDeclaration
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:3696

clang::ast_matchers::decayedType
const AstTypeMatcher< DecayedType > decayedType
Matches decayed type Example matches i[] in declaration of f.
Definition: ASTMatchersInternal.cpp:1110

clang::ast_matchers::declStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclStmt > declStmt
Matches declaration statements.
Definition: ASTMatchersInternal.cpp:841

clang::ast_matchers::compoundLiteralExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundLiteralExpr > compoundLiteralExpr
Matches compound (i.e.
Definition: ASTMatchersInternal.cpp:971

clang::ast_matchers::memberPointerType
const AstTypeMatcher< MemberPointerType > memberPointerType
Matches member pointer types.
Definition: ASTMatchersInternal.cpp:1093

clang::ast_matchers::labelStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, LabelStmt > labelStmt
Matches label statements.
Definition: ASTMatchersInternal.cpp:942

clang::ast_matchers::stmt
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
Definition: ASTMatchersInternal.cpp:840

clang::ast_matchers::friendDecl
const internal::VariadicDynCastAllOfMatcher< Decl, FriendDecl > friendDecl
Matches friend declarations.
Definition: ASTMatchersInternal.cpp:839

clang::ast_matchers::expr
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchersInternal.cpp:925

clang::ast_matchers::incompleteArrayType
const AstTypeMatcher< IncompleteArrayType > incompleteArrayType
Matches C arrays with unspecified size.
Definition: ASTMatchersInternal.cpp:1083

clang::ast_matchers::characterLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, CharacterLiteral > characterLiteral
Matches character literals (also matches wchar_t).
Definition: ASTMatchersInternal.cpp:961

clang::ast_matchers::cxxFoldExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFoldExpr > cxxFoldExpr
Matches C++17 fold expressions.
Definition: ASTMatchersInternal.cpp:924

clang::ast_matchers::conditionalOperator
const internal::VariadicDynCastAllOfMatcher< Stmt, ConditionalOperator > conditionalOperator
Matches conditional operator expressions.
Definition: ASTMatchersInternal.cpp:996

clang::ast_matchers::cxxStdInitializerListExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStdInitializerListExpr > cxxStdInitializerListExpr
Matches C++ initializer list expressions.
Definition: ASTMatchersInternal.cpp:881

clang::ast_matchers::anyOf
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> anyOf
Matches if any of the given matchers matches.
Definition: ASTMatchersInternal.cpp:1031

clang::ast_matchers::hasAnyOperatorName
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.
Definition: ASTMatchersInternal.cpp:1043

clang::ast_matchers::opaqueValueExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, OpaqueValueExpr > opaqueValueExpr
Matches opaque value expressions.
Definition: ASTMatchersInternal.cpp:1000

clang::ast_matchers::complexType
const AstTypeMatcher< ComplexType > complexType
Matches C99 complex types.
Definition: ASTMatchersInternal.cpp:1077

clang::ast_matchers::cudaKernelCallExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > cudaKernelCallExpr
Matches CUDA kernel call expression.
Definition: ASTMatchersInternal.cpp:1074

clang::ast_matchers::indirectFieldDecl
const internal::VariadicDynCastAllOfMatcher< Decl, IndirectFieldDecl > indirectFieldDecl
Matches indirect field declarations.
Definition: ASTMatchersInternal.cpp:835

clang::ast_matchers::functionType
const AstTypeMatcher< FunctionType > functionType
Matches FunctionType nodes.
Definition: ASTMatchersInternal.cpp:1088

clang::ast_matchers::blockDecl
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
Definition: ASTMatchersInternal.cpp:866

clang::ast_matchers::cxxMethodDecl
const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > cxxMethodDecl
Matches method declarations.
Definition: ASTMatchersInternal.cpp:828

clang::ast_matchers::cxxCatchStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXCatchStmt > cxxCatchStmt
Matches catch statements.
Definition: ASTMatchersInternal.cpp:951

clang::ast_matchers::castExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
Definition: ASTMatchersInternal.cpp:1017

clang::ast_matchers::qualType
const internal::VariadicAllOfMatcher< QualType > qualType
Matches QualTypes in the clang AST.
Definition: ASTMatchersInternal.cpp:800

clang::ast_matchers::cxxTryStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTryStmt > cxxTryStmt
Matches try statements.
Definition: ASTMatchersInternal.cpp:952

clang::ast_matchers::substNonTypeTemplateParmExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, SubstNonTypeTemplateParmExpr > substNonTypeTemplateParmExpr
Matches substitutions of non-type template parameters.
Definition: ASTMatchersInternal.cpp:886

clang::ast_matchers::usingDirectiveDecl
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDirectiveDecl > usingDirectiveDecl
Matches using namespace declarations.
Definition: ASTMatchersInternal.cpp:890

clang::ast_matchers::unresolvedUsingValueDecl
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingValueDecl > unresolvedUsingValueDecl
Matches unresolved using value declarations.
Definition: ASTMatchersInternal.cpp:894

clang::ast_matchers::hasAncestor
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.
Definition: ASTMatchersInternal.cpp:1066

clang::ast_matchers::hasParent
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.
Definition: ASTMatchersInternal.cpp:1061

clang::ast_matchers::ifStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, IfStmt > ifStmt
Matches if statements.
Definition: ASTMatchersInternal.cpp:931

clang::ast_matchers::cxxThisExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThisExpr > cxxThisExpr
Matches implicit and explicit this expressions.
Definition: ASTMatchersInternal.cpp:903

clang::ast_matchers::imaginaryLiteral
const internal::VariadicDynCastAllOfMatcher< Stmt, ImaginaryLiteral > imaginaryLiteral
Matches imaginary literals, which are based on integer and floating point literals e....
Definition: ASTMatchersInternal.cpp:965

clang::ast_matchers::rValueReferenceType
const AstTypeMatcher< RValueReferenceType > rValueReferenceType
Matches rvalue reference types.
Definition: ASTMatchersInternal.cpp:1098

clang::ast_matchers::continueStmt
const internal::VariadicDynCastAllOfMatcher< Stmt, ContinueStmt > continueStmt
Matches continue statements.
Definition: ASTMatchersInternal.cpp:938

clang::ast_matchers::classTemplateDecl
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateDecl > classTemplateDecl
Matches C++ class template declarations.
Definition: ASTMatchersInternal.cpp:775

clang::ast_matchers::lValueReferenceType
const AstTypeMatcher< LValueReferenceType > lValueReferenceType
Matches lvalue reference types.
Definition: ASTMatchersInternal.cpp:1097

clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition: CalledOnceCheck.h:17

clang::isTemplateInstantiation
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:212

clang::isInstanceMethod
bool isInstanceMethod(const Decl *D)
Definition: Attr.h:120

clang::ObjCSubstitutionContext::Result
@ Result
The result type of a method or function.

clang::ast_matchers::dynamic::SourceRange
Definition: Diagnostics.h:36