diff options
Diffstat (limited to 'clang/lib/ASTMatchers/Dynamic/Registry.cpp')
| -rw-r--r-- | clang/lib/ASTMatchers/Dynamic/Registry.cpp | 693 |
1 files changed, 693 insertions, 0 deletions
diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp new file mode 100644 index 000000000000..8c11e069cb05 --- /dev/null +++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp @@ -0,0 +1,693 @@ +//===- 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/Optional.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 <set> +#include <string> +#include <utility> +#include <vector> + +using namespace clang::ast_type_traits; + +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.find(MatcherName) == Constructors.end()); + 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) + +/// 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. + // + // Need Variant/Parser fixes: + // ofKind + // + // Polymorphic + argument overload: + // findAll + // + // Other: + // equalsNode + + 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_MATCHER(accessSpecDecl); + REGISTER_MATCHER(addrLabelExpr); + REGISTER_MATCHER(alignOfExpr); + REGISTER_MATCHER(allOf); + REGISTER_MATCHER(anyOf); + REGISTER_MATCHER(anything); + REGISTER_MATCHER(argumentCountIs); + REGISTER_MATCHER(arraySubscriptExpr); + REGISTER_MATCHER(arrayType); + REGISTER_MATCHER(asString); + REGISTER_MATCHER(asmStmt); + REGISTER_MATCHER(atomicExpr); + REGISTER_MATCHER(atomicType); + REGISTER_MATCHER(autoType); + REGISTER_MATCHER(autoreleasePoolStmt) + REGISTER_MATCHER(binaryConditionalOperator); + REGISTER_MATCHER(binaryOperator); + 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(caseStmt); + REGISTER_MATCHER(castExpr); + REGISTER_MATCHER(characterLiteral); + REGISTER_MATCHER(chooseExpr); + REGISTER_MATCHER(classTemplateDecl); + REGISTER_MATCHER(classTemplateSpecializationDecl); + REGISTER_MATCHER(complexType); + REGISTER_MATCHER(compoundLiteralExpr); + REGISTER_MATCHER(compoundStmt); + REGISTER_MATCHER(conditionalOperator); + REGISTER_MATCHER(constantArrayType); + REGISTER_MATCHER(constantExpr); + REGISTER_MATCHER(containsDeclaration); + REGISTER_MATCHER(continueStmt); + REGISTER_MATCHER(cudaKernelCallExpr); + 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(cxxForRangeStmt); + REGISTER_MATCHER(cxxFunctionalCastExpr); + REGISTER_MATCHER(cxxMemberCallExpr); + REGISTER_MATCHER(cxxMethodDecl); + REGISTER_MATCHER(cxxNewExpr); + REGISTER_MATCHER(cxxNullPtrLiteralExpr); + REGISTER_MATCHER(cxxOperatorCallExpr); + REGISTER_MATCHER(cxxRecordDecl); + REGISTER_MATCHER(cxxReinterpretCastExpr); + 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(declCountIs); + REGISTER_MATCHER(declRefExpr); + REGISTER_MATCHER(declStmt); + REGISTER_MATCHER(declaratorDecl); + REGISTER_MATCHER(decltypeType); + REGISTER_MATCHER(defaultStmt); + REGISTER_MATCHER(dependentSizedArrayType); + REGISTER_MATCHER(designatedInitExpr); + REGISTER_MATCHER(designatorCountIs); + REGISTER_MATCHER(doStmt); + REGISTER_MATCHER(eachOf); + REGISTER_MATCHER(elaboratedType); + REGISTER_MATCHER(enumConstantDecl); + REGISTER_MATCHER(enumDecl); + REGISTER_MATCHER(enumType); + REGISTER_MATCHER(equalsBoundNode); + REGISTER_MATCHER(equalsIntegralValue); + REGISTER_MATCHER(explicitCastExpr); + REGISTER_MATCHER(expr); + REGISTER_MATCHER(exprWithCleanups); + REGISTER_MATCHER(fieldDecl); + REGISTER_MATCHER(floatLiteral); + REGISTER_MATCHER(forEach); + REGISTER_MATCHER(forEachArgumentWithParam); + REGISTER_MATCHER(forEachConstructorInitializer); + REGISTER_MATCHER(forEachDescendant); + REGISTER_MATCHER(forEachOverridden); + REGISTER_MATCHER(forEachSwitchCase); + 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(gnuNullExpr); + REGISTER_MATCHER(gotoStmt); + REGISTER_MATCHER(has); + REGISTER_MATCHER(hasAncestor); + REGISTER_MATCHER(hasAnyArgument); + REGISTER_MATCHER(hasAnyClause); + REGISTER_MATCHER(hasAnyConstructorInitializer); + REGISTER_MATCHER(hasAnyDeclaration); + REGISTER_MATCHER(hasAnyName); + REGISTER_MATCHER(hasAnyParameter); + REGISTER_MATCHER(hasAnySelector); + REGISTER_MATCHER(hasAnySubstatement); + REGISTER_MATCHER(hasAnyTemplateArgument); + REGISTER_MATCHER(hasAnyUsingShadowDecl); + REGISTER_MATCHER(hasArgument); + REGISTER_MATCHER(hasArgumentOfType); + REGISTER_MATCHER(hasArraySize); + REGISTER_MATCHER(hasAttr); + REGISTER_MATCHER(hasAutomaticStorageDuration); + REGISTER_MATCHER(hasBase); + 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(hasDescendant); + REGISTER_MATCHER(hasDestinationType); + REGISTER_MATCHER(hasDynamicExceptionSpec); + REGISTER_MATCHER(hasEitherOperand); + REGISTER_MATCHER(hasElementType); + REGISTER_MATCHER(hasElse); + REGISTER_MATCHER(hasExplicitSpecifier); + REGISTER_MATCHER(hasExternalFormalLinkage); + REGISTER_MATCHER(hasFalseExpression); + REGISTER_MATCHER(hasGlobalStorage); + REGISTER_MATCHER(hasImplicitDestinationType); + REGISTER_MATCHER(hasInClassInitializer); + REGISTER_MATCHER(hasIncrement); + REGISTER_MATCHER(hasIndex); + REGISTER_MATCHER(hasInit); + REGISTER_MATCHER(hasInitializer); + REGISTER_MATCHER(hasKeywordSelector); + REGISTER_MATCHER(hasLHS); + REGISTER_MATCHER(hasLocalQualifiers); + REGISTER_MATCHER(hasLocalStorage); + REGISTER_MATCHER(hasLoopInit); + REGISTER_MATCHER(hasLoopVariable); + REGISTER_MATCHER(hasMethod); + REGISTER_MATCHER(hasName); + REGISTER_MATCHER(hasNullSelector); + REGISTER_MATCHER(hasObjectExpression); + REGISTER_MATCHER(hasOperatorName); + REGISTER_MATCHER(hasOverloadedOperatorName); + REGISTER_MATCHER(hasParameter); + REGISTER_MATCHER(hasParent); + REGISTER_MATCHER(hasQualifier); + REGISTER_MATCHER(hasRHS); + REGISTER_MATCHER(hasRangeInit); + REGISTER_MATCHER(hasReceiver); + REGISTER_MATCHER(hasReceiverType); + REGISTER_MATCHER(hasReplacementType); + REGISTER_MATCHER(hasReturnValue); + 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(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(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(isAllowedToContainClauseKind); + REGISTER_MATCHER(isAnonymous); + REGISTER_MATCHER(isAnyCharacter); + REGISTER_MATCHER(isAnyPointer); + REGISTER_MATCHER(isArray); + REGISTER_MATCHER(isArrow); + REGISTER_MATCHER(isAssignmentOperator); + REGISTER_MATCHER(isBaseInitializer); + REGISTER_MATCHER(isBitField); + REGISTER_MATCHER(isCatchAll); + REGISTER_MATCHER(isClass); + REGISTER_MATCHER(isClassMessage); + REGISTER_MATCHER(isClassMethod); + REGISTER_MATCHER(isConst); + REGISTER_MATCHER(isConstQualified); + REGISTER_MATCHER(isConstexpr); + REGISTER_MATCHER(isCopyAssignmentOperator); + REGISTER_MATCHER(isCopyConstructor); + REGISTER_MATCHER(isDefaultConstructor); + REGISTER_MATCHER(isDefaulted); + REGISTER_MATCHER(isDefinition); + REGISTER_MATCHER(isDelegatingConstructor); + REGISTER_MATCHER(isDeleted); + REGISTER_MATCHER(isExceptionVariable); + REGISTER_MATCHER(isExpansionInFileMatching); + REGISTER_MATCHER(isExpansionInMainFile); + REGISTER_MATCHER(isExpansionInSystemHeader); + REGISTER_MATCHER(isExplicit); + REGISTER_MATCHER(isExplicitTemplateSpecialization); + REGISTER_MATCHER(isExpr); + REGISTER_MATCHER(isExternC); + REGISTER_MATCHER(isFinal); + REGISTER_MATCHER(isImplicit); + REGISTER_MATCHER(isInStdNamespace); + REGISTER_MATCHER(isInTemplateInstantiation); + 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(isListInitialization); + REGISTER_MATCHER(isMain); + REGISTER_MATCHER(isMemberInitializer); + REGISTER_MATCHER(isMoveAssignmentOperator); + REGISTER_MATCHER(isMoveConstructor); + REGISTER_MATCHER(isNoReturn); + REGISTER_MATCHER(isNoThrow); + REGISTER_MATCHER(isNoneKind); + REGISTER_MATCHER(isOMPStructuredBlock); + REGISTER_MATCHER(isOverride); + REGISTER_MATCHER(isPrivate); + REGISTER_MATCHER(isProtected); + REGISTER_MATCHER(isPublic); + REGISTER_MATCHER(isPure); + 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(isUnion); + REGISTER_MATCHER(isUnsignedInteger); + REGISTER_MATCHER(isUserProvided); + REGISTER_MATCHER(isValueDependent); + REGISTER_MATCHER(isVariadic); + REGISTER_MATCHER(isVirtual); + REGISTER_MATCHER(isVirtualAsWritten); + REGISTER_MATCHER(isVolatileQualified); + REGISTER_MATCHER(isWritten); + REGISTER_MATCHER(lValueReferenceType); + REGISTER_MATCHER(labelDecl); + REGISTER_MATCHER(labelStmt); + REGISTER_MATCHER(lambdaExpr); + REGISTER_MATCHER(linkageSpecDecl); + REGISTER_MATCHER(matchesName); + REGISTER_MATCHER(matchesSelector); + REGISTER_MATCHER(materializeTemporaryExpr); + REGISTER_MATCHER(member); + REGISTER_MATCHER(memberExpr); + 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(objcThrowStmt); + REGISTER_MATCHER(objcTryStmt); + REGISTER_MATCHER(ofClass); + REGISTER_MATCHER(ompDefaultClause); + REGISTER_MATCHER(ompExecutableDirective); + REGISTER_MATCHER(on); + REGISTER_MATCHER(onImplicitObjectArgument); + REGISTER_MATCHER(opaqueValueExpr); + REGISTER_MATCHER(parameterCountIs); + REGISTER_MATCHER(parenExpr); + REGISTER_MATCHER(parenListExpr); + REGISTER_MATCHER(parenType); + REGISTER_MATCHER(parmVarDecl); + REGISTER_MATCHER(pointee); + REGISTER_MATCHER(pointerType); + REGISTER_MATCHER(predefinedExpr); + REGISTER_MATCHER(qualType); + REGISTER_MATCHER(rValueReferenceType); + REGISTER_MATCHER(realFloatingPointType); + REGISTER_MATCHER(recordDecl); + REGISTER_MATCHER(recordType); + REGISTER_MATCHER(referenceType); + 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(tagType); + REGISTER_MATCHER(templateArgument); + REGISTER_MATCHER(templateArgumentCountIs); + REGISTER_MATCHER(templateName); + REGISTER_MATCHER(templateSpecializationType); + 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(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; + +// static +llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) { + auto it = RegistryData->constructors().find(MatcherName); + return it == RegistryData->constructors().end() + ? llvm::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(std::begin(InitialTypes), std::end(InitialTypes)); + 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; + for (const ArgKind& Kind : AcceptedTypes) { + if (Kind.getArgKind() != Kind.AK_Matcher) + continue; + 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); + + 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 << ")"; + + std::string TypedText = Name; + TypedText += "("; + if (ArgsKinds.empty()) + TypedText += ")"; + else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String) + TypedText += "\""; + + Completions.emplace_back(TypedText, OS.str(), 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; + + llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher(); + if (Result.hasValue()) { + llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID); + if (Bound.hasValue()) { + return VariantMatcher::SingleMatcher(*Bound); + } + } + Error->addError(NameRange, Error->ET_RegistryNotBindable); + return VariantMatcher(); +} + +} // namespace dynamic +} // namespace ast_matchers +} // namespace clang |