1 //===--- Registry.cpp - Matcher registry -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===------------------------------------------------------------===//
11 /// \brief Registry map populated at static initialization time.
13 //===------------------------------------------------------------===//
15 #include "clang/ASTMatchers/Dynamic/Registry.h"
16 #include "Marshallers.h"
17 #include "clang/ASTMatchers/ASTMatchers.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/ManagedStatic.h"
24 using namespace clang::ast_type_traits;
27 namespace ast_matchers {
31 using internal::MatcherDescriptor;
33 typedef llvm::StringMap<const MatcherDescriptor *> ConstructorMap;
39 const ConstructorMap &constructors() const { return Constructors; }
42 void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback);
43 ConstructorMap Constructors;
46 void RegistryMaps::registerMatcher(StringRef MatcherName,
47 MatcherDescriptor *Callback) {
48 assert(Constructors.find(MatcherName) == Constructors.end());
49 Constructors[MatcherName] = Callback;
52 #define REGISTER_MATCHER(name) \
53 registerMatcher(#name, internal::makeMatcherAutoMarshall( \
54 ::clang::ast_matchers::name, #name));
56 #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
57 static_cast< ::clang::ast_matchers::name##_Type##Id>( \
58 ::clang::ast_matchers::name)
60 #define REGISTER_OVERLOADED_2(name) \
62 MatcherDescriptor *Callbacks[] = { \
63 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
65 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
68 registerMatcher(#name, \
69 new internal::OverloadedMatcherDescriptor(Callbacks)); \
72 /// \brief Generate a registry map with all the known matchers.
73 RegistryMaps::RegistryMaps() {
74 // TODO: Here is the list of the missing matchers, grouped by reason.
76 // Need Variant/Parser fixes:
79 // Polymorphic + argument overload:
86 REGISTER_OVERLOADED_2(callee);
87 REGISTER_OVERLOADED_2(hasPrefix);
88 REGISTER_OVERLOADED_2(hasType);
89 REGISTER_OVERLOADED_2(isDerivedFrom);
90 REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
91 REGISTER_OVERLOADED_2(loc);
92 REGISTER_OVERLOADED_2(pointsTo);
93 REGISTER_OVERLOADED_2(references);
94 REGISTER_OVERLOADED_2(thisPointerType);
96 REGISTER_MATCHER(accessSpecDecl);
97 REGISTER_MATCHER(alignOfExpr);
98 REGISTER_MATCHER(allOf);
99 REGISTER_MATCHER(anyOf);
100 REGISTER_MATCHER(anything);
101 REGISTER_MATCHER(argumentCountIs);
102 REGISTER_MATCHER(arraySubscriptExpr);
103 REGISTER_MATCHER(arrayType);
104 REGISTER_MATCHER(asmStmt);
105 REGISTER_MATCHER(asString);
106 REGISTER_MATCHER(atomicType);
107 REGISTER_MATCHER(autoType);
108 REGISTER_MATCHER(binaryOperator);
109 REGISTER_MATCHER(bindTemporaryExpr);
110 REGISTER_MATCHER(blockPointerType);
111 REGISTER_MATCHER(boolLiteral);
112 REGISTER_MATCHER(breakStmt);
113 REGISTER_MATCHER(builtinType);
114 REGISTER_MATCHER(callExpr);
115 REGISTER_MATCHER(caseStmt);
116 REGISTER_MATCHER(castExpr);
117 REGISTER_MATCHER(catchStmt);
118 REGISTER_MATCHER(characterLiteral);
119 REGISTER_MATCHER(classTemplateDecl);
120 REGISTER_MATCHER(classTemplateSpecializationDecl);
121 REGISTER_MATCHER(complexType);
122 REGISTER_MATCHER(compoundLiteralExpr);
123 REGISTER_MATCHER(compoundStmt);
124 REGISTER_MATCHER(conditionalOperator);
125 REGISTER_MATCHER(constantArrayType);
126 REGISTER_MATCHER(constCastExpr);
127 REGISTER_MATCHER(constructExpr);
128 REGISTER_MATCHER(constructorDecl);
129 REGISTER_MATCHER(containsDeclaration);
130 REGISTER_MATCHER(continueStmt);
131 REGISTER_MATCHER(conversionDecl);
132 REGISTER_MATCHER(cStyleCastExpr);
133 REGISTER_MATCHER(ctorInitializer);
134 REGISTER_MATCHER(CUDAKernelCallExpr);
135 REGISTER_MATCHER(decl);
136 REGISTER_MATCHER(declaratorDecl);
137 REGISTER_MATCHER(declCountIs);
138 REGISTER_MATCHER(declRefExpr);
139 REGISTER_MATCHER(declStmt);
140 REGISTER_MATCHER(defaultArgExpr);
141 REGISTER_MATCHER(defaultStmt);
142 REGISTER_MATCHER(deleteExpr);
143 REGISTER_MATCHER(dependentSizedArrayType);
144 REGISTER_MATCHER(destructorDecl);
145 REGISTER_MATCHER(doStmt);
146 REGISTER_MATCHER(dynamicCastExpr);
147 REGISTER_MATCHER(eachOf);
148 REGISTER_MATCHER(elaboratedType);
149 REGISTER_MATCHER(enumConstantDecl);
150 REGISTER_MATCHER(enumDecl);
151 REGISTER_MATCHER(equalsBoundNode);
152 REGISTER_MATCHER(equalsIntegralValue);
153 REGISTER_MATCHER(explicitCastExpr);
154 REGISTER_MATCHER(expr);
155 REGISTER_MATCHER(exprWithCleanups);
156 REGISTER_MATCHER(fieldDecl);
157 REGISTER_MATCHER(floatLiteral);
158 REGISTER_MATCHER(forEach);
159 REGISTER_MATCHER(forEachConstructorInitializer);
160 REGISTER_MATCHER(forEachDescendant);
161 REGISTER_MATCHER(forEachSwitchCase);
162 REGISTER_MATCHER(forField);
163 REGISTER_MATCHER(forRangeStmt);
164 REGISTER_MATCHER(forStmt);
165 REGISTER_MATCHER(friendDecl);
166 REGISTER_MATCHER(functionalCastExpr);
167 REGISTER_MATCHER(functionDecl);
168 REGISTER_MATCHER(functionTemplateDecl);
169 REGISTER_MATCHER(functionType);
170 REGISTER_MATCHER(gotoStmt);
171 REGISTER_MATCHER(has);
172 REGISTER_MATCHER(hasAncestor);
173 REGISTER_MATCHER(hasAnyArgument);
174 REGISTER_MATCHER(hasAnyConstructorInitializer);
175 REGISTER_MATCHER(hasAnyParameter);
176 REGISTER_MATCHER(hasAnySubstatement);
177 REGISTER_MATCHER(hasAnyTemplateArgument);
178 REGISTER_MATCHER(hasAnyUsingShadowDecl);
179 REGISTER_MATCHER(hasArgument);
180 REGISTER_MATCHER(hasArgumentOfType);
181 REGISTER_MATCHER(hasAttr);
182 REGISTER_MATCHER(hasBase);
183 REGISTER_MATCHER(hasBody);
184 REGISTER_MATCHER(hasCanonicalType);
185 REGISTER_MATCHER(hasCaseConstant);
186 REGISTER_MATCHER(hasCondition);
187 REGISTER_MATCHER(hasConditionVariableStatement);
188 REGISTER_MATCHER(hasDeclaration);
189 REGISTER_MATCHER(hasDeclContext);
190 REGISTER_MATCHER(hasDeducedType);
191 REGISTER_MATCHER(hasDescendant);
192 REGISTER_MATCHER(hasDestinationType);
193 REGISTER_MATCHER(hasEitherOperand);
194 REGISTER_MATCHER(hasElementType);
195 REGISTER_MATCHER(hasElse);
196 REGISTER_MATCHER(hasFalseExpression);
197 REGISTER_MATCHER(hasGlobalStorage);
198 REGISTER_MATCHER(hasImplicitDestinationType);
199 REGISTER_MATCHER(hasIncrement);
200 REGISTER_MATCHER(hasIndex);
201 REGISTER_MATCHER(hasInitializer);
202 REGISTER_MATCHER(hasKeywordSelector);
203 REGISTER_MATCHER(hasLHS);
204 REGISTER_MATCHER(hasLocalQualifiers);
205 REGISTER_MATCHER(hasLocalStorage);
206 REGISTER_MATCHER(hasLoopInit);
207 REGISTER_MATCHER(hasLoopVariable);
208 REGISTER_MATCHER(hasMethod);
209 REGISTER_MATCHER(hasName);
210 REGISTER_MATCHER(hasNullSelector);
211 REGISTER_MATCHER(hasObjectExpression);
212 REGISTER_MATCHER(hasOperatorName);
213 REGISTER_MATCHER(hasOverloadedOperatorName);
214 REGISTER_MATCHER(hasParameter);
215 REGISTER_MATCHER(hasParent);
216 REGISTER_MATCHER(hasQualifier);
217 REGISTER_MATCHER(hasRangeInit);
218 REGISTER_MATCHER(hasReceiverType);
219 REGISTER_MATCHER(hasRHS);
220 REGISTER_MATCHER(hasSelector);
221 REGISTER_MATCHER(hasSingleDecl);
222 REGISTER_MATCHER(hasSize);
223 REGISTER_MATCHER(hasSizeExpr);
224 REGISTER_MATCHER(hasSourceExpression);
225 REGISTER_MATCHER(hasTargetDecl);
226 REGISTER_MATCHER(hasTemplateArgument);
227 REGISTER_MATCHER(hasThen);
228 REGISTER_MATCHER(hasTrueExpression);
229 REGISTER_MATCHER(hasTypeLoc);
230 REGISTER_MATCHER(hasUnaryOperand);
231 REGISTER_MATCHER(hasUnarySelector);
232 REGISTER_MATCHER(hasValueType);
233 REGISTER_MATCHER(ifStmt);
234 REGISTER_MATCHER(ignoringImpCasts);
235 REGISTER_MATCHER(ignoringParenCasts);
236 REGISTER_MATCHER(ignoringParenImpCasts);
237 REGISTER_MATCHER(implicitCastExpr);
238 REGISTER_MATCHER(incompleteArrayType);
239 REGISTER_MATCHER(initListExpr);
240 REGISTER_MATCHER(innerType);
241 REGISTER_MATCHER(integerLiteral);
242 REGISTER_MATCHER(isArrow);
243 REGISTER_MATCHER(isConst);
244 REGISTER_MATCHER(isConstQualified);
245 REGISTER_MATCHER(isDefinition);
246 REGISTER_MATCHER(isDeleted);
247 REGISTER_MATCHER(isExplicitTemplateSpecialization);
248 REGISTER_MATCHER(isExpr);
249 REGISTER_MATCHER(isExternC);
250 REGISTER_MATCHER(isImplicit);
251 REGISTER_MATCHER(isExpansionInFileMatching);
252 REGISTER_MATCHER(isExpansionInMainFile);
253 REGISTER_MATCHER(isInstantiated);
254 REGISTER_MATCHER(isExpansionInSystemHeader);
255 REGISTER_MATCHER(isInteger);
256 REGISTER_MATCHER(isIntegral);
257 REGISTER_MATCHER(isInTemplateInstantiation);
258 REGISTER_MATCHER(isListInitialization);
259 REGISTER_MATCHER(isOverride);
260 REGISTER_MATCHER(isPrivate);
261 REGISTER_MATCHER(isProtected);
262 REGISTER_MATCHER(isPublic);
263 REGISTER_MATCHER(isPure);
264 REGISTER_MATCHER(isTemplateInstantiation);
265 REGISTER_MATCHER(isVirtual);
266 REGISTER_MATCHER(isWritten);
267 REGISTER_MATCHER(labelStmt);
268 REGISTER_MATCHER(lambdaExpr);
269 REGISTER_MATCHER(lValueReferenceType);
270 REGISTER_MATCHER(matchesName);
271 REGISTER_MATCHER(matchesSelector);
272 REGISTER_MATCHER(materializeTemporaryExpr);
273 REGISTER_MATCHER(member);
274 REGISTER_MATCHER(memberCallExpr);
275 REGISTER_MATCHER(memberExpr);
276 REGISTER_MATCHER(memberPointerType);
277 REGISTER_MATCHER(methodDecl);
278 REGISTER_MATCHER(namedDecl);
279 REGISTER_MATCHER(namespaceDecl);
280 REGISTER_MATCHER(namesType);
281 REGISTER_MATCHER(nestedNameSpecifier);
282 REGISTER_MATCHER(nestedNameSpecifierLoc);
283 REGISTER_MATCHER(newExpr);
284 REGISTER_MATCHER(nullPtrLiteralExpr);
285 REGISTER_MATCHER(nullStmt);
286 REGISTER_MATCHER(numSelectorArgs);
287 REGISTER_MATCHER(ofClass);
288 REGISTER_MATCHER(objcMessageExpr);
289 REGISTER_MATCHER(on);
290 REGISTER_MATCHER(onImplicitObjectArgument);
291 REGISTER_MATCHER(operatorCallExpr);
292 REGISTER_MATCHER(parameterCountIs);
293 REGISTER_MATCHER(parenType);
294 REGISTER_MATCHER(parmVarDecl);
295 REGISTER_MATCHER(pointee);
296 REGISTER_MATCHER(pointerType);
297 REGISTER_MATCHER(qualType);
298 REGISTER_MATCHER(recordDecl);
299 REGISTER_MATCHER(recordType);
300 REGISTER_MATCHER(referenceType);
301 REGISTER_MATCHER(refersToDeclaration);
302 REGISTER_MATCHER(refersToIntegralType);
303 REGISTER_MATCHER(refersToType);
304 REGISTER_MATCHER(reinterpretCastExpr);
305 REGISTER_MATCHER(returns);
306 REGISTER_MATCHER(returnStmt);
307 REGISTER_MATCHER(rValueReferenceType);
308 REGISTER_MATCHER(sizeOfExpr);
309 REGISTER_MATCHER(specifiesNamespace);
310 REGISTER_MATCHER(specifiesType);
311 REGISTER_MATCHER(specifiesTypeLoc);
312 REGISTER_MATCHER(statementCountIs);
313 REGISTER_MATCHER(staticCastExpr);
314 REGISTER_MATCHER(stmt);
315 REGISTER_MATCHER(stringLiteral);
316 REGISTER_MATCHER(substNonTypeTemplateParmExpr);
317 REGISTER_MATCHER(switchCase);
318 REGISTER_MATCHER(switchStmt);
319 REGISTER_MATCHER(templateArgument);
320 REGISTER_MATCHER(templateArgumentCountIs);
321 REGISTER_MATCHER(templateSpecializationType);
322 REGISTER_MATCHER(temporaryObjectExpr);
323 REGISTER_MATCHER(thisExpr);
324 REGISTER_MATCHER(throughUsingDecl);
325 REGISTER_MATCHER(throwExpr);
326 REGISTER_MATCHER(to);
327 REGISTER_MATCHER(translationUnitDecl);
328 REGISTER_MATCHER(tryStmt);
329 REGISTER_MATCHER(type);
330 REGISTER_MATCHER(typedefDecl);
331 REGISTER_MATCHER(typedefType);
332 REGISTER_MATCHER(typeLoc);
333 REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
334 REGISTER_MATCHER(unaryOperator);
335 REGISTER_MATCHER(unaryTransformType);
336 REGISTER_MATCHER(unless);
337 REGISTER_MATCHER(unresolvedConstructExpr);
338 REGISTER_MATCHER(unresolvedUsingValueDecl);
339 REGISTER_MATCHER(userDefinedLiteral);
340 REGISTER_MATCHER(usingDecl);
341 REGISTER_MATCHER(usingDirectiveDecl);
342 REGISTER_MATCHER(valueDecl);
343 REGISTER_MATCHER(varDecl);
344 REGISTER_MATCHER(variableArrayType);
345 REGISTER_MATCHER(voidType);
346 REGISTER_MATCHER(whileStmt);
347 REGISTER_MATCHER(withInitializer);
350 RegistryMaps::~RegistryMaps() {
351 for (ConstructorMap::iterator it = Constructors.begin(),
352 end = Constructors.end();
358 static llvm::ManagedStatic<RegistryMaps> RegistryData;
360 } // anonymous namespace
363 llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
364 ConstructorMap::const_iterator it =
365 RegistryData->constructors().find(MatcherName);
366 return it == RegistryData->constructors().end()
367 ? llvm::Optional<MatcherCtor>()
373 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
374 const std::set<ASTNodeKind> &KS) {
376 for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
391 std::vector<ArgKind> Registry::getAcceptedCompletionTypes(
392 ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
393 ASTNodeKind InitialTypes[] = {
394 ASTNodeKind::getFromNodeKind<Decl>(),
395 ASTNodeKind::getFromNodeKind<QualType>(),
396 ASTNodeKind::getFromNodeKind<Type>(),
397 ASTNodeKind::getFromNodeKind<Stmt>(),
398 ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
399 ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
400 ASTNodeKind::getFromNodeKind<TypeLoc>()};
402 // Starting with the above seed of acceptable top-level matcher types, compute
403 // the acceptable type set for the argument indicated by each context element.
404 std::set<ArgKind> TypeSet(std::begin(InitialTypes), std::end(InitialTypes));
405 for (const auto &CtxEntry : Context) {
406 MatcherCtor Ctor = CtxEntry.first;
407 unsigned ArgNumber = CtxEntry.second;
408 std::vector<ArgKind> NextTypeSet;
409 for (const ArgKind &Kind : TypeSet) {
410 if (Kind.getArgKind() == Kind.AK_Matcher &&
411 Ctor->isConvertibleTo(Kind.getMatcherKind()) &&
412 (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))
413 Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);
416 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());
418 return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());
421 std::vector<MatcherCompletion>
422 Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {
423 std::vector<MatcherCompletion> Completions;
425 // Search the registry for acceptable matchers.
426 for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(),
427 E = RegistryData->constructors().end();
429 std::set<ASTNodeKind> RetKinds;
430 unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs();
431 bool IsPolymorphic = I->second->isPolymorphic();
432 std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);
433 unsigned MaxSpecificity = 0;
434 for (const ArgKind& Kind : AcceptedTypes) {
435 if (Kind.getArgKind() != Kind.AK_Matcher)
437 unsigned Specificity;
438 ASTNodeKind LeastDerivedKind;
439 if (I->second->isConvertibleTo(Kind.getMatcherKind(), &Specificity,
440 &LeastDerivedKind)) {
441 if (MaxSpecificity < Specificity)
442 MaxSpecificity = Specificity;
443 RetKinds.insert(LeastDerivedKind);
444 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
445 I->second->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);
451 if (!RetKinds.empty() && MaxSpecificity > 0) {
453 llvm::raw_string_ostream OS(Decl);
456 OS << "Matcher<T> " << I->first() << "(Matcher<T>";
458 OS << "Matcher<" << RetKinds << "> " << I->first() << "(";
459 for (const std::vector<ArgKind> &Arg : ArgsKinds) {
460 if (&Arg != &ArgsKinds[0])
463 bool FirstArgKind = true;
464 std::set<ASTNodeKind> MatcherKinds;
465 // Two steps. First all non-matchers, then matchers only.
466 for (const ArgKind &AK : Arg) {
467 if (AK.getArgKind() == ArgKind::AK_Matcher) {
468 MatcherKinds.insert(AK.getMatcherKind());
470 if (!FirstArgKind) OS << "|";
471 FirstArgKind = false;
475 if (!MatcherKinds.empty()) {
476 if (!FirstArgKind) OS << "|";
477 OS << "Matcher<" << MatcherKinds << ">";
481 if (I->second->isVariadic())
485 std::string TypedText = I->first();
487 if (ArgsKinds.empty())
489 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)
492 Completions.emplace_back(TypedText, OS.str(), MaxSpecificity);
500 VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
501 const SourceRange &NameRange,
502 ArrayRef<ParserValue> Args,
503 Diagnostics *Error) {
504 return Ctor->create(NameRange, Args, Error);
508 VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
509 const SourceRange &NameRange,
511 ArrayRef<ParserValue> Args,
512 Diagnostics *Error) {
513 VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
514 if (Out.isNull()) return Out;
516 llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
517 if (Result.hasValue()) {
518 llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
519 if (Bound.hasValue()) {
520 return VariantMatcher::SingleMatcher(*Bound);
523 Error->addError(NameRange, Error->ET_RegistryNotBindable);
524 return VariantMatcher();
527 } // namespace dynamic
528 } // namespace ast_matchers