832 lines · cpp
1//===- Registry.cpp - Matcher registry ------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9/// \file10/// Registry map populated at static initialization time.11//12//===----------------------------------------------------------------------===//13 14#include "clang/ASTMatchers/Dynamic/Registry.h"15#include "Marshallers.h"16#include "clang/AST/ASTTypeTraits.h"17#include "clang/ASTMatchers/ASTMatchers.h"18#include "clang/ASTMatchers/Dynamic/Diagnostics.h"19#include "clang/ASTMatchers/Dynamic/VariantValue.h"20#include "llvm/ADT/StringMap.h"21#include "llvm/ADT/StringRef.h"22#include "llvm/Support/ManagedStatic.h"23#include "llvm/Support/raw_ostream.h"24#include <cassert>25#include <memory>26#include <optional>27#include <set>28#include <string>29#include <utility>30#include <vector>31 32namespace clang {33namespace ast_matchers {34namespace dynamic {35 36namespace {37 38using internal::MatcherDescriptor;39 40using ConstructorMap =41 llvm::StringMap<std::unique_ptr<const MatcherDescriptor>>;42 43class RegistryMaps {44public:45 RegistryMaps();46 ~RegistryMaps();47 48 const ConstructorMap &constructors() const { return Constructors; }49 50private:51 void registerMatcher(StringRef MatcherName,52 std::unique_ptr<MatcherDescriptor> Callback);53 54 ConstructorMap Constructors;55};56 57} // namespace58 59void RegistryMaps::registerMatcher(60 StringRef MatcherName, std::unique_ptr<MatcherDescriptor> Callback) {61 assert(!Constructors.contains(MatcherName));62 Constructors[MatcherName] = std::move(Callback);63}64 65#define REGISTER_MATCHER(name) \66 registerMatcher(#name, internal::makeMatcherAutoMarshall( \67 ::clang::ast_matchers::name, #name));68 69#define REGISTER_MATCHER_OVERLOAD(name) \70 registerMatcher(#name, \71 std::make_unique<internal::OverloadedMatcherDescriptor>(name##Callbacks))72 73#define SPECIFIC_MATCHER_OVERLOAD(name, Id) \74 static_cast<::clang::ast_matchers::name##_Type##Id>( \75 ::clang::ast_matchers::name)76 77#define MATCHER_OVERLOAD_ENTRY(name, Id) \78 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, Id), \79 #name)80 81#define REGISTER_OVERLOADED_2(name) \82 do { \83 std::unique_ptr<MatcherDescriptor> name##Callbacks[] = { \84 MATCHER_OVERLOAD_ENTRY(name, 0), \85 MATCHER_OVERLOAD_ENTRY(name, 1)}; \86 REGISTER_MATCHER_OVERLOAD(name); \87 } while (false)88 89#define REGISTER_REGEX_MATCHER(name) \90 registerMatcher(#name, internal::makeMatcherRegexMarshall(name, name))91 92/// Generate a registry map with all the known matchers.93/// Please keep sorted alphabetically!94RegistryMaps::RegistryMaps() {95 // TODO: Here is the list of the missing matchers, grouped by reason.96 //97 // Polymorphic + argument overload:98 // findAll99 //100 // Other:101 // equalsNode102 103 registerMatcher("mapAnyOf",104 std::make_unique<internal::MapAnyOfBuilderDescriptor>());105 106 REGISTER_OVERLOADED_2(callee);107 REGISTER_OVERLOADED_2(hasPrefix);108 REGISTER_OVERLOADED_2(hasType);109 REGISTER_OVERLOADED_2(ignoringParens);110 REGISTER_OVERLOADED_2(isDerivedFrom);111 REGISTER_OVERLOADED_2(isDirectlyDerivedFrom);112 REGISTER_OVERLOADED_2(isSameOrDerivedFrom);113 REGISTER_OVERLOADED_2(loc);114 REGISTER_OVERLOADED_2(pointsTo);115 REGISTER_OVERLOADED_2(references);116 REGISTER_OVERLOADED_2(thisPointerType);117 118 std::unique_ptr<MatcherDescriptor> equalsCallbacks[] = {119 MATCHER_OVERLOAD_ENTRY(equals, 0),120 MATCHER_OVERLOAD_ENTRY(equals, 1),121 MATCHER_OVERLOAD_ENTRY(equals, 2),122 };123 REGISTER_MATCHER_OVERLOAD(equals);124 125 REGISTER_REGEX_MATCHER(isExpansionInFileMatching);126 REGISTER_REGEX_MATCHER(matchesName);127 REGISTER_REGEX_MATCHER(matchesSelector);128 129 REGISTER_MATCHER(accessSpecDecl);130 REGISTER_MATCHER(addrLabelExpr);131 REGISTER_MATCHER(alignOfExpr);132 REGISTER_MATCHER(allOf);133 REGISTER_MATCHER(anyOf);134 REGISTER_MATCHER(anything);135 REGISTER_MATCHER(arrayInitIndexExpr);136 REGISTER_MATCHER(arrayInitLoopExpr);137 REGISTER_MATCHER(argumentCountIs);138 REGISTER_MATCHER(argumentCountAtLeast);139 REGISTER_MATCHER(arraySubscriptExpr);140 REGISTER_MATCHER(arrayType);141 REGISTER_MATCHER(arrayTypeLoc);142 REGISTER_MATCHER(asString);143 REGISTER_MATCHER(asmStmt);144 REGISTER_MATCHER(atomicExpr);145 REGISTER_MATCHER(atomicType);146 REGISTER_MATCHER(attr);147 REGISTER_MATCHER(autoType);148 REGISTER_MATCHER(autoreleasePoolStmt)149 REGISTER_MATCHER(binaryConditionalOperator);150 REGISTER_MATCHER(binaryOperator);151 REGISTER_MATCHER(binaryOperation);152 REGISTER_MATCHER(bindingDecl);153 REGISTER_MATCHER(blockDecl);154 REGISTER_MATCHER(blockExpr);155 REGISTER_MATCHER(blockPointerType);156 REGISTER_MATCHER(booleanType);157 REGISTER_MATCHER(breakStmt);158 REGISTER_MATCHER(builtinType);159 REGISTER_MATCHER(cStyleCastExpr);160 REGISTER_MATCHER(callExpr);161 REGISTER_MATCHER(capturesThis);162 REGISTER_MATCHER(capturesVar);163 REGISTER_MATCHER(caseStmt);164 REGISTER_MATCHER(castExpr);165 REGISTER_MATCHER(characterLiteral);166 REGISTER_MATCHER(chooseExpr);167 REGISTER_MATCHER(classTemplateDecl);168 REGISTER_MATCHER(classTemplatePartialSpecializationDecl);169 REGISTER_MATCHER(classTemplateSpecializationDecl);170 REGISTER_MATCHER(complexType);171 REGISTER_MATCHER(compoundLiteralExpr);172 REGISTER_MATCHER(compoundStmt);173 REGISTER_MATCHER(coawaitExpr);174 REGISTER_MATCHER(conceptDecl);175 REGISTER_MATCHER(conditionalOperator);176 REGISTER_MATCHER(constantArrayType);177 REGISTER_MATCHER(constantExpr);178 REGISTER_MATCHER(containsDeclaration);179 REGISTER_MATCHER(continueStmt);180 REGISTER_MATCHER(convertVectorExpr);181 REGISTER_MATCHER(coreturnStmt);182 REGISTER_MATCHER(coroutineBodyStmt);183 REGISTER_MATCHER(coyieldExpr);184 REGISTER_MATCHER(cudaKernelCallExpr);185 REGISTER_MATCHER(cxxBaseSpecifier);186 REGISTER_MATCHER(cxxBindTemporaryExpr);187 REGISTER_MATCHER(cxxBoolLiteral);188 REGISTER_MATCHER(cxxCatchStmt);189 REGISTER_MATCHER(cxxConstCastExpr);190 REGISTER_MATCHER(cxxConstructExpr);191 REGISTER_MATCHER(cxxConstructorDecl);192 REGISTER_MATCHER(cxxConversionDecl);193 REGISTER_MATCHER(cxxCtorInitializer);194 REGISTER_MATCHER(cxxDeductionGuideDecl);195 REGISTER_MATCHER(cxxDefaultArgExpr);196 REGISTER_MATCHER(cxxDeleteExpr);197 REGISTER_MATCHER(cxxDependentScopeMemberExpr);198 REGISTER_MATCHER(cxxDestructorDecl);199 REGISTER_MATCHER(cxxDynamicCastExpr);200 REGISTER_MATCHER(cxxFoldExpr);201 REGISTER_MATCHER(cxxForRangeStmt);202 REGISTER_MATCHER(cxxFunctionalCastExpr);203 REGISTER_MATCHER(cxxMemberCallExpr);204 REGISTER_MATCHER(cxxMethodDecl);205 REGISTER_MATCHER(cxxNewExpr);206 REGISTER_MATCHER(cxxNoexceptExpr);207 REGISTER_MATCHER(cxxNullPtrLiteralExpr);208 REGISTER_MATCHER(cxxOperatorCallExpr);209 REGISTER_MATCHER(cxxRecordDecl);210 REGISTER_MATCHER(cxxReinterpretCastExpr);211 REGISTER_MATCHER(cxxRewrittenBinaryOperator);212 REGISTER_MATCHER(cxxStaticCastExpr);213 REGISTER_MATCHER(cxxStdInitializerListExpr);214 REGISTER_MATCHER(cxxTemporaryObjectExpr);215 REGISTER_MATCHER(cxxThisExpr);216 REGISTER_MATCHER(cxxThrowExpr);217 REGISTER_MATCHER(cxxTryStmt);218 REGISTER_MATCHER(cxxUnresolvedConstructExpr);219 REGISTER_MATCHER(decayedType);220 REGISTER_MATCHER(decl);221 REGISTER_MATCHER(decompositionDecl);222 REGISTER_MATCHER(declCountIs);223 REGISTER_MATCHER(declRefExpr);224 REGISTER_MATCHER(dependentNameType);225 REGISTER_MATCHER(dependentScopeDeclRefExpr);226 REGISTER_MATCHER(declStmt);227 REGISTER_MATCHER(declaratorDecl);228 REGISTER_MATCHER(decltypeType);229 REGISTER_MATCHER(deducedTemplateSpecializationType);230 REGISTER_MATCHER(defaultStmt);231 REGISTER_MATCHER(dependentCoawaitExpr);232 REGISTER_MATCHER(dependentSizedArrayType);233 REGISTER_MATCHER(dependentSizedExtVectorType);234 REGISTER_MATCHER(designatedInitExpr);235 REGISTER_MATCHER(designatorCountIs);236 REGISTER_MATCHER(doStmt);237 REGISTER_MATCHER(eachOf);238 REGISTER_MATCHER(usingType);239 REGISTER_MATCHER(enumConstantDecl);240 REGISTER_MATCHER(enumDecl);241 REGISTER_MATCHER(enumType);242 REGISTER_MATCHER(equalsBoundNode);243 REGISTER_MATCHER(declaresSameEntityAsBoundNode);244 REGISTER_MATCHER(equalsIntegralValue);245 REGISTER_MATCHER(explicitCastExpr);246 REGISTER_MATCHER(exportDecl);247 REGISTER_MATCHER(expr);248 REGISTER_MATCHER(exprWithCleanups);249 REGISTER_MATCHER(fieldDecl);250 REGISTER_MATCHER(fileScopeAsmDecl);251 REGISTER_MATCHER(fixedPointLiteral);252 REGISTER_MATCHER(floatLiteral);253 REGISTER_MATCHER(forCallable);254 REGISTER_MATCHER(forDecomposition);255 REGISTER_MATCHER(forEach);256 REGISTER_MATCHER(forEachArgumentWithParam);257 REGISTER_MATCHER(forEachArgumentWithParamType);258 REGISTER_MATCHER(forEachConstructorInitializer);259 REGISTER_MATCHER(forEachDescendant);260 REGISTER_MATCHER(forEachLambdaCapture);261 REGISTER_MATCHER(forEachOverridden);262 REGISTER_MATCHER(forEachSwitchCase);263 REGISTER_MATCHER(forEachTemplateArgument);264 REGISTER_MATCHER(forField);265 REGISTER_MATCHER(forFunction);266 REGISTER_MATCHER(forStmt);267 REGISTER_MATCHER(friendDecl);268 REGISTER_MATCHER(functionDecl);269 REGISTER_MATCHER(functionProtoType);270 REGISTER_MATCHER(functionTemplateDecl);271 REGISTER_MATCHER(functionType);272 REGISTER_MATCHER(genericSelectionExpr);273 REGISTER_MATCHER(gnuNullExpr);274 REGISTER_MATCHER(gotoStmt);275 REGISTER_MATCHER(has);276 REGISTER_MATCHER(hasAncestor);277 REGISTER_MATCHER(hasAnyArgument);278 REGISTER_MATCHER(hasAnyBase);279 REGISTER_MATCHER(hasAnyBinding);280 REGISTER_MATCHER(hasAnyBody);281 REGISTER_MATCHER(hasAnyCapture);282 REGISTER_MATCHER(hasAnyClause);283 REGISTER_MATCHER(hasAnyConstructorInitializer);284 REGISTER_MATCHER(hasAnyDeclaration);285 REGISTER_MATCHER(hasAnyName);286 REGISTER_MATCHER(hasAnyOperatorName);287 REGISTER_MATCHER(hasAnyOverloadedOperatorName);288 REGISTER_MATCHER(hasAnyParameter);289 REGISTER_MATCHER(hasAnyPlacementArg);290 REGISTER_MATCHER(hasAnySelector);291 REGISTER_MATCHER(hasAnySubstatement);292 REGISTER_MATCHER(hasAnyTemplateArgument);293 REGISTER_MATCHER(hasAnyTemplateArgumentLoc);294 REGISTER_MATCHER(hasAnyUsingShadowDecl);295 REGISTER_MATCHER(hasArgument);296 REGISTER_MATCHER(hasArgumentOfType);297 REGISTER_MATCHER(hasArraySize);298 REGISTER_MATCHER(hasAttr);299 REGISTER_MATCHER(hasAutomaticStorageDuration);300 REGISTER_MATCHER(hasBase);301 REGISTER_MATCHER(hasBinding);302 REGISTER_MATCHER(hasBitWidth);303 REGISTER_MATCHER(hasBody);304 REGISTER_MATCHER(hasCanonicalType);305 REGISTER_MATCHER(hasCaseConstant);306 REGISTER_MATCHER(hasCastKind);307 REGISTER_MATCHER(hasCondition);308 REGISTER_MATCHER(hasConditionVariableStatement);309 REGISTER_MATCHER(hasDecayedType);310 REGISTER_MATCHER(hasDeclContext);311 REGISTER_MATCHER(hasDeclaration);312 REGISTER_MATCHER(hasDeducedType);313 REGISTER_MATCHER(hasDefaultArgument);314 REGISTER_MATCHER(hasDefinition);315 REGISTER_MATCHER(hasDependentName);316 REGISTER_MATCHER(hasDescendant);317 REGISTER_MATCHER(hasDestinationType);318 REGISTER_MATCHER(hasDirectBase);319 REGISTER_MATCHER(hasDynamicExceptionSpec);320 REGISTER_MATCHER(hasEitherOperand);321 REGISTER_MATCHER(hasElementType);322 REGISTER_MATCHER(hasElse);323 REGISTER_MATCHER(hasExplicitSpecifier);324 REGISTER_MATCHER(hasExternalFormalLinkage);325 REGISTER_MATCHER(hasFalseExpression);326 REGISTER_MATCHER(hasFoldInit);327 REGISTER_MATCHER(hasGlobalStorage);328 REGISTER_MATCHER(hasImplicitDestinationType);329 REGISTER_MATCHER(hasInClassInitializer);330 REGISTER_MATCHER(hasIncrement);331 REGISTER_MATCHER(hasIndex);332 REGISTER_MATCHER(hasInit);333 REGISTER_MATCHER(hasInitializer);334 REGISTER_MATCHER(hasInitStatement);335 REGISTER_MATCHER(hasKeywordSelector);336 REGISTER_MATCHER(hasLHS);337 REGISTER_MATCHER(hasLocalQualifiers);338 REGISTER_MATCHER(hasLocalStorage);339 REGISTER_MATCHER(hasLoopInit);340 REGISTER_MATCHER(hasLoopVariable);341 REGISTER_MATCHER(hasMemberName);342 REGISTER_MATCHER(hasMethod);343 REGISTER_MATCHER(hasName);344 REGISTER_MATCHER(hasNullSelector);345 REGISTER_MATCHER(hasObjectExpression);346 REGISTER_MATCHER(hasOperands);347 REGISTER_MATCHER(hasOperatorName);348 REGISTER_MATCHER(hasOverloadedOperatorName);349 REGISTER_MATCHER(hasParameter);350 REGISTER_MATCHER(hasParent);351 REGISTER_MATCHER(hasPattern);352 REGISTER_MATCHER(hasPointeeLoc);353 REGISTER_MATCHER(hasQualifier);354 REGISTER_MATCHER(hasRHS);355 REGISTER_MATCHER(hasRangeInit);356 REGISTER_MATCHER(hasReceiver);357 REGISTER_MATCHER(hasReceiverType);358 REGISTER_MATCHER(hasReferentLoc);359 REGISTER_MATCHER(hasReplacementType);360 REGISTER_MATCHER(hasReturnTypeLoc);361 REGISTER_MATCHER(hasReturnValue);362 REGISTER_MATCHER(hasPlacementArg);363 REGISTER_MATCHER(hasSelector);364 REGISTER_MATCHER(hasSingleDecl);365 REGISTER_MATCHER(hasSize);366 REGISTER_MATCHER(hasSizeExpr);367 REGISTER_MATCHER(hasSourceExpression);368 REGISTER_MATCHER(hasSpecializedTemplate);369 REGISTER_MATCHER(hasStaticStorageDuration);370 REGISTER_MATCHER(hasStructuredBlock);371 REGISTER_MATCHER(hasSyntacticForm);372 REGISTER_MATCHER(hasTargetDecl);373 REGISTER_MATCHER(hasTemplateArgument);374 REGISTER_MATCHER(hasTemplateArgumentLoc);375 REGISTER_MATCHER(hasThen);376 REGISTER_MATCHER(hasThreadStorageDuration);377 REGISTER_MATCHER(hasTrailingReturn);378 REGISTER_MATCHER(hasTrueExpression);379 REGISTER_MATCHER(hasTypeLoc);380 REGISTER_MATCHER(hasUnaryOperand);381 REGISTER_MATCHER(hasUnarySelector);382 REGISTER_MATCHER(hasUnderlyingDecl);383 REGISTER_MATCHER(hasUnderlyingType);384 REGISTER_MATCHER(hasUnqualifiedDesugaredType);385 REGISTER_MATCHER(hasUnqualifiedLoc);386 REGISTER_MATCHER(hasValueType);387 REGISTER_MATCHER(ifStmt);388 REGISTER_MATCHER(ignoringElidableConstructorCall);389 REGISTER_MATCHER(ignoringImpCasts);390 REGISTER_MATCHER(ignoringImplicit);391 REGISTER_MATCHER(ignoringParenCasts);392 REGISTER_MATCHER(ignoringParenImpCasts);393 REGISTER_MATCHER(imaginaryLiteral);394 REGISTER_MATCHER(implicitCastExpr);395 REGISTER_MATCHER(implicitValueInitExpr);396 REGISTER_MATCHER(incompleteArrayType);397 REGISTER_MATCHER(indirectFieldDecl);398 REGISTER_MATCHER(initListExpr);399 REGISTER_MATCHER(injectedClassNameType);400 REGISTER_MATCHER(innerType);401 REGISTER_MATCHER(integerLiteral);402 REGISTER_MATCHER(invocation);403 REGISTER_MATCHER(isAllowedToContainClauseKind);404 REGISTER_MATCHER(isAnonymous);405 REGISTER_MATCHER(isAnyCharacter);406 REGISTER_MATCHER(isAnyPointer);407 REGISTER_MATCHER(isArray);408 REGISTER_MATCHER(isArrow);409 REGISTER_MATCHER(isAssignmentOperator);410 REGISTER_MATCHER(isAtPosition);411 REGISTER_MATCHER(isBaseInitializer);412 REGISTER_MATCHER(isBinaryFold);413 REGISTER_MATCHER(isBitField);414 REGISTER_MATCHER(isCatchAll);415 REGISTER_MATCHER(isClass);416 REGISTER_MATCHER(isClassMessage);417 REGISTER_MATCHER(isClassMethod);418 REGISTER_MATCHER(isComparisonOperator);419 REGISTER_MATCHER(isConst);420 REGISTER_MATCHER(isConstQualified);421 REGISTER_MATCHER(isConsteval);422 REGISTER_MATCHER(isConstexpr);423 REGISTER_MATCHER(isConstinit);424 REGISTER_MATCHER(isCopyAssignmentOperator);425 REGISTER_MATCHER(isCopyConstructor);426 REGISTER_MATCHER(isDefaultConstructor);427 REGISTER_MATCHER(isDefaulted);428 REGISTER_MATCHER(isDefinition);429 REGISTER_MATCHER(isDelegatingConstructor);430 REGISTER_MATCHER(isDeleted);431 REGISTER_MATCHER(isEnum);432 REGISTER_MATCHER(isExceptionVariable);433 REGISTER_MATCHER(isExpandedFromMacro);434 REGISTER_MATCHER(isExpansionInMainFile);435 REGISTER_MATCHER(isExpansionInSystemHeader);436 REGISTER_MATCHER(isExplicit);437 REGISTER_MATCHER(isExplicitObjectMemberFunction);438 REGISTER_MATCHER(isExplicitTemplateSpecialization);439 REGISTER_MATCHER(isExpr);440 REGISTER_MATCHER(isExternC);441 REGISTER_MATCHER(isFinal);442 REGISTER_MATCHER(isPrivateKind);443 REGISTER_MATCHER(isFirstPrivateKind);444 REGISTER_MATCHER(isImplicit);445 REGISTER_MATCHER(isInAnonymousNamespace);446 REGISTER_MATCHER(isInStdNamespace);447 REGISTER_MATCHER(isInTemplateInstantiation);448 REGISTER_MATCHER(isInitCapture);449 REGISTER_MATCHER(isInline);450 REGISTER_MATCHER(isInstanceMessage);451 REGISTER_MATCHER(isInstanceMethod);452 REGISTER_MATCHER(isInstantiated);453 REGISTER_MATCHER(isInstantiationDependent);454 REGISTER_MATCHER(isInteger);455 REGISTER_MATCHER(isIntegral);456 REGISTER_MATCHER(isLambda);457 REGISTER_MATCHER(isLeftFold);458 REGISTER_MATCHER(isListInitialization);459 REGISTER_MATCHER(isMain);460 REGISTER_MATCHER(isMemberInitializer);461 REGISTER_MATCHER(isMoveAssignmentOperator);462 REGISTER_MATCHER(isMoveConstructor);463 REGISTER_MATCHER(isNoReturn);464 REGISTER_MATCHER(isNoThrow);465 REGISTER_MATCHER(isNoneKind);466 REGISTER_MATCHER(isOverride);467 REGISTER_MATCHER(isPrivate);468 REGISTER_MATCHER(isProtected);469 REGISTER_MATCHER(isPublic);470 REGISTER_MATCHER(isPure);471 REGISTER_MATCHER(isRightFold);472 REGISTER_MATCHER(isScoped);473 REGISTER_MATCHER(isSharedKind);474 REGISTER_MATCHER(isSignedInteger);475 REGISTER_MATCHER(isStandaloneDirective);476 REGISTER_MATCHER(isStaticLocal);477 REGISTER_MATCHER(isStaticStorageClass);478 REGISTER_MATCHER(isStruct);479 REGISTER_MATCHER(isTemplateInstantiation);480 REGISTER_MATCHER(isTypeDependent);481 REGISTER_MATCHER(isUnaryFold);482 REGISTER_MATCHER(isUnion);483 REGISTER_MATCHER(isUnsignedInteger);484 REGISTER_MATCHER(isUserProvided);485 REGISTER_MATCHER(isValueDependent);486 REGISTER_MATCHER(isVariadic);487 REGISTER_MATCHER(isVirtual);488 REGISTER_MATCHER(isVirtualAsWritten);489 REGISTER_MATCHER(isVolatileQualified);490 REGISTER_MATCHER(isWeak);491 REGISTER_MATCHER(isWritten);492 REGISTER_MATCHER(lValueReferenceType);493 REGISTER_MATCHER(labelDecl);494 REGISTER_MATCHER(labelStmt);495 REGISTER_MATCHER(lambdaCapture);496 REGISTER_MATCHER(lambdaExpr);497 REGISTER_MATCHER(linkageSpecDecl);498 REGISTER_MATCHER(macroQualifiedType);499 REGISTER_MATCHER(materializeTemporaryExpr);500 REGISTER_MATCHER(member);501 REGISTER_MATCHER(memberExpr);502 REGISTER_MATCHER(memberHasSameNameAsBoundNode);503 REGISTER_MATCHER(memberPointerType);504 REGISTER_MATCHER(namedDecl);505 REGISTER_MATCHER(namespaceAliasDecl);506 REGISTER_MATCHER(namespaceDecl);507 REGISTER_MATCHER(nestedNameSpecifier);508 REGISTER_MATCHER(nestedNameSpecifierLoc);509 REGISTER_MATCHER(nonTypeTemplateParmDecl);510 REGISTER_MATCHER(nullPointerConstant);511 REGISTER_MATCHER(nullStmt);512 REGISTER_MATCHER(numSelectorArgs);513 REGISTER_MATCHER(objcCatchStmt);514 REGISTER_MATCHER(objcCategoryDecl);515 REGISTER_MATCHER(objcCategoryImplDecl);516 REGISTER_MATCHER(objcFinallyStmt);517 REGISTER_MATCHER(objcImplementationDecl);518 REGISTER_MATCHER(objcInterfaceDecl);519 REGISTER_MATCHER(objcIvarDecl);520 REGISTER_MATCHER(objcIvarRefExpr);521 REGISTER_MATCHER(objcMessageExpr);522 REGISTER_MATCHER(objcMethodDecl);523 REGISTER_MATCHER(objcObjectPointerType);524 REGISTER_MATCHER(objcPropertyDecl);525 REGISTER_MATCHER(objcProtocolDecl);526 REGISTER_MATCHER(objcStringLiteral);527 REGISTER_MATCHER(objcThrowStmt);528 REGISTER_MATCHER(objcTryStmt);529 REGISTER_MATCHER(ofClass);530 REGISTER_MATCHER(ofKind);531 REGISTER_MATCHER(ompDefaultClause);532 REGISTER_MATCHER(ompExecutableDirective);533 REGISTER_MATCHER(on);534 REGISTER_MATCHER(onImplicitObjectArgument);535 REGISTER_MATCHER(opaqueValueExpr);536 REGISTER_MATCHER(optionally);537 REGISTER_MATCHER(parameterCountIs);538 REGISTER_MATCHER(parenExpr);539 REGISTER_MATCHER(parenListExpr);540 REGISTER_MATCHER(parenType);541 REGISTER_MATCHER(parmVarDecl);542 REGISTER_MATCHER(pointee);543 REGISTER_MATCHER(pointerType);544 REGISTER_MATCHER(pointerTypeLoc);545 REGISTER_MATCHER(predefinedExpr);546 REGISTER_MATCHER(qualType);547 REGISTER_MATCHER(qualifiedTypeLoc);548 REGISTER_MATCHER(rValueReferenceType);549 REGISTER_MATCHER(realFloatingPointType);550 REGISTER_MATCHER(recordDecl);551 REGISTER_MATCHER(recordType);552 REGISTER_MATCHER(referenceType);553 REGISTER_MATCHER(referenceTypeLoc);554 REGISTER_MATCHER(refersToDeclaration);555 REGISTER_MATCHER(refersToIntegralType);556 REGISTER_MATCHER(refersToTemplate);557 REGISTER_MATCHER(refersToType);558 REGISTER_MATCHER(requiresZeroInitialization);559 REGISTER_MATCHER(returnStmt);560 REGISTER_MATCHER(returns);561 REGISTER_MATCHER(sizeOfExpr);562 REGISTER_MATCHER(specifiesNamespace);563 REGISTER_MATCHER(specifiesType);564 REGISTER_MATCHER(specifiesTypeLoc);565 REGISTER_MATCHER(statementCountIs);566 REGISTER_MATCHER(staticAssertDecl);567 REGISTER_MATCHER(stmt);568 REGISTER_MATCHER(stmtExpr);569 REGISTER_MATCHER(stringLiteral);570 REGISTER_MATCHER(substNonTypeTemplateParmExpr);571 REGISTER_MATCHER(substTemplateTypeParmType);572 REGISTER_MATCHER(switchCase);573 REGISTER_MATCHER(switchStmt);574 REGISTER_MATCHER(tagDecl);575 REGISTER_MATCHER(tagType);576 REGISTER_MATCHER(templateArgument);577 REGISTER_MATCHER(templateArgumentCountIs);578 REGISTER_MATCHER(templateArgumentLoc);579 REGISTER_MATCHER(templateName);580 REGISTER_MATCHER(templateSpecializationType);581 REGISTER_MATCHER(templateSpecializationTypeLoc);582 REGISTER_MATCHER(templateTemplateParmDecl);583 REGISTER_MATCHER(templateTypeParmDecl);584 REGISTER_MATCHER(templateTypeParmType);585 REGISTER_MATCHER(throughUsingDecl);586 REGISTER_MATCHER(to);587 REGISTER_MATCHER(translationUnitDecl);588 REGISTER_MATCHER(type);589 REGISTER_MATCHER(typeAliasDecl);590 REGISTER_MATCHER(typeAliasTemplateDecl);591 REGISTER_MATCHER(typeLoc);592 REGISTER_MATCHER(typedefDecl);593 REGISTER_MATCHER(typedefNameDecl);594 REGISTER_MATCHER(usingShadowDecl);595 REGISTER_MATCHER(typedefType);596 REGISTER_MATCHER(unaryExprOrTypeTraitExpr);597 REGISTER_MATCHER(unaryOperator);598 REGISTER_MATCHER(unaryTransformType);599 REGISTER_MATCHER(unless);600 REGISTER_MATCHER(unresolvedLookupExpr);601 REGISTER_MATCHER(unresolvedMemberExpr);602 REGISTER_MATCHER(unresolvedUsingTypenameDecl);603 REGISTER_MATCHER(unresolvedUsingValueDecl);604 REGISTER_MATCHER(userDefinedLiteral);605 REGISTER_MATCHER(usesADL);606 REGISTER_MATCHER(usingDecl);607 REGISTER_MATCHER(usingEnumDecl);608 REGISTER_MATCHER(usingDirectiveDecl);609 REGISTER_MATCHER(valueDecl);610 REGISTER_MATCHER(varDecl);611 REGISTER_MATCHER(variableArrayType);612 REGISTER_MATCHER(voidType);613 REGISTER_MATCHER(whileStmt);614 REGISTER_MATCHER(withInitializer);615}616 617RegistryMaps::~RegistryMaps() = default;618 619static llvm::ManagedStatic<RegistryMaps> RegistryData;620 621ASTNodeKind Registry::nodeMatcherType(MatcherCtor Ctor) {622 return Ctor->nodeMatcherType();623}624 625internal::MatcherDescriptorPtr::MatcherDescriptorPtr(MatcherDescriptor *Ptr)626 : Ptr(Ptr) {}627 628internal::MatcherDescriptorPtr::~MatcherDescriptorPtr() { delete Ptr; }629 630bool Registry::isBuilderMatcher(MatcherCtor Ctor) {631 return Ctor->isBuilderMatcher();632}633 634internal::MatcherDescriptorPtr635Registry::buildMatcherCtor(MatcherCtor Ctor, SourceRange NameRange,636 ArrayRef<ParserValue> Args, Diagnostics *Error) {637 return internal::MatcherDescriptorPtr(638 Ctor->buildMatcherCtor(NameRange, Args, Error).release());639}640 641// static642std::optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {643 auto it = RegistryData->constructors().find(MatcherName);644 return it == RegistryData->constructors().end() ? std::optional<MatcherCtor>()645 : it->second.get();646}647 648static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,649 const std::set<ASTNodeKind> &KS) {650 unsigned Count = 0;651 for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();652 I != E; ++I) {653 if (I != KS.begin())654 OS << "|";655 if (Count++ == 3) {656 OS << "...";657 break;658 }659 OS << *I;660 }661 return OS;662}663 664std::vector<ArgKind> Registry::getAcceptedCompletionTypes(665 ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {666 ASTNodeKind InitialTypes[] = {667 ASTNodeKind::getFromNodeKind<Decl>(),668 ASTNodeKind::getFromNodeKind<QualType>(),669 ASTNodeKind::getFromNodeKind<Type>(),670 ASTNodeKind::getFromNodeKind<Stmt>(),671 ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),672 ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),673 ASTNodeKind::getFromNodeKind<TypeLoc>()};674 675 // Starting with the above seed of acceptable top-level matcher types, compute676 // the acceptable type set for the argument indicated by each context element.677 std::set<ArgKind> TypeSet;678 for (auto IT : InitialTypes) {679 TypeSet.insert(ArgKind::MakeMatcherArg(IT));680 }681 for (const auto &CtxEntry : Context) {682 MatcherCtor Ctor = CtxEntry.first;683 unsigned ArgNumber = CtxEntry.second;684 std::vector<ArgKind> NextTypeSet;685 for (const ArgKind &Kind : TypeSet) {686 if (Kind.getArgKind() == Kind.AK_Matcher &&687 Ctor->isConvertibleTo(Kind.getMatcherKind()) &&688 (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))689 Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);690 }691 TypeSet.clear();692 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());693 }694 return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());695}696 697std::vector<MatcherCompletion>698Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {699 std::vector<MatcherCompletion> Completions;700 701 // Search the registry for acceptable matchers.702 for (const auto &M : RegistryData->constructors()) {703 const MatcherDescriptor& Matcher = *M.getValue();704 StringRef Name = M.getKey();705 706 std::set<ASTNodeKind> RetKinds;707 unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs();708 bool IsPolymorphic = Matcher.isPolymorphic();709 std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);710 unsigned MaxSpecificity = 0;711 bool NodeArgs = false;712 for (const ArgKind& Kind : AcceptedTypes) {713 if (Kind.getArgKind() != Kind.AK_Matcher &&714 Kind.getArgKind() != Kind.AK_Node) {715 continue;716 }717 718 if (Kind.getArgKind() == Kind.AK_Node) {719 NodeArgs = true;720 unsigned Specificity;721 ASTNodeKind LeastDerivedKind;722 if (Matcher.isConvertibleTo(Kind.getNodeKind(), &Specificity,723 &LeastDerivedKind)) {724 if (MaxSpecificity < Specificity)725 MaxSpecificity = Specificity;726 RetKinds.insert(LeastDerivedKind);727 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)728 Matcher.getArgKinds(Kind.getNodeKind(), Arg, ArgsKinds[Arg]);729 if (IsPolymorphic)730 break;731 }732 } else {733 unsigned Specificity;734 ASTNodeKind LeastDerivedKind;735 if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity,736 &LeastDerivedKind)) {737 if (MaxSpecificity < Specificity)738 MaxSpecificity = Specificity;739 RetKinds.insert(LeastDerivedKind);740 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)741 Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);742 if (IsPolymorphic)743 break;744 }745 }746 }747 748 if (!RetKinds.empty() && MaxSpecificity > 0) {749 std::string Decl;750 llvm::raw_string_ostream OS(Decl);751 752 std::string TypedText = std::string(Name);753 754 if (NodeArgs) {755 OS << Name;756 } else {757 758 if (IsPolymorphic) {759 OS << "Matcher<T> " << Name << "(Matcher<T>";760 } else {761 OS << "Matcher<" << RetKinds << "> " << Name << "(";762 for (const std::vector<ArgKind> &Arg : ArgsKinds) {763 if (&Arg != &ArgsKinds[0])764 OS << ", ";765 766 bool FirstArgKind = true;767 std::set<ASTNodeKind> MatcherKinds;768 // Two steps. First all non-matchers, then matchers only.769 for (const ArgKind &AK : Arg) {770 if (AK.getArgKind() == ArgKind::AK_Matcher) {771 MatcherKinds.insert(AK.getMatcherKind());772 } else {773 if (!FirstArgKind)774 OS << "|";775 FirstArgKind = false;776 OS << AK.asString();777 }778 }779 if (!MatcherKinds.empty()) {780 if (!FirstArgKind) OS << "|";781 OS << "Matcher<" << MatcherKinds << ">";782 }783 }784 }785 if (Matcher.isVariadic())786 OS << "...";787 OS << ")";788 789 TypedText += "(";790 if (ArgsKinds.empty())791 TypedText += ")";792 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)793 TypedText += "\"";794 }795 796 Completions.emplace_back(TypedText, Decl, MaxSpecificity);797 }798 }799 800 return Completions;801}802 803VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,804 SourceRange NameRange,805 ArrayRef<ParserValue> Args,806 Diagnostics *Error) {807 return Ctor->create(NameRange, Args, Error);808}809 810VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,811 SourceRange NameRange,812 StringRef BindID,813 ArrayRef<ParserValue> Args,814 Diagnostics *Error) {815 VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);816 if (Out.isNull()) return Out;817 818 std::optional<DynTypedMatcher> Result = Out.getSingleMatcher();819 if (Result) {820 std::optional<DynTypedMatcher> Bound = Result->tryBind(BindID);821 if (Bound) {822 return VariantMatcher::SingleMatcher(*Bound);823 }824 }825 Error->addError(NameRange, Error->ET_RegistryNotBindable);826 return VariantMatcher();827}828 829} // namespace dynamic830} // namespace ast_matchers831} // namespace clang832