1 //===--- Registry.cpp - Matcher registry -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief Registry map populated at static initialization time.
12 ///
13 //===------------------------------------------------------------===//
14
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"
21 #include <set>
22 #include <utility>
23
24 using namespace clang::ast_type_traits;
25
26 namespace clang {
27 namespace ast_matchers {
28 namespace dynamic {
29 namespace {
30
31 using internal::MatcherDescriptor;
32
33 typedef llvm::StringMap<const MatcherDescriptor *> ConstructorMap;
34 class RegistryMaps {
35 public:
36 RegistryMaps();
37 ~RegistryMaps();
38
constructors() const39 const ConstructorMap &constructors() const { return Constructors; }
40
41 private:
42 void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback);
43 ConstructorMap Constructors;
44 };
45
registerMatcher(StringRef MatcherName,MatcherDescriptor * Callback)46 void RegistryMaps::registerMatcher(StringRef MatcherName,
47 MatcherDescriptor *Callback) {
48 assert(Constructors.find(MatcherName) == Constructors.end());
49 Constructors[MatcherName] = Callback;
50 }
51
52 #define REGISTER_MATCHER(name) \
53 registerMatcher(#name, internal::makeMatcherAutoMarshall( \
54 ::clang::ast_matchers::name, #name));
55
56 #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
57 static_cast< ::clang::ast_matchers::name##_Type##Id>( \
58 ::clang::ast_matchers::name)
59
60 #define REGISTER_OVERLOADED_2(name) \
61 do { \
62 MatcherDescriptor *Callbacks[] = { \
63 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
64 #name), \
65 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
66 #name) \
67 }; \
68 registerMatcher(#name, \
69 new internal::OverloadedMatcherDescriptor(Callbacks)); \
70 } while (0)
71
72 /// \brief Generate a registry map with all the known matchers.
RegistryMaps()73 RegistryMaps::RegistryMaps() {
74 // TODO: Here is the list of the missing matchers, grouped by reason.
75 //
76 // Need Variant/Parser fixes:
77 // ofKind
78 //
79 // Polymorphic + argument overload:
80 // findAll
81 //
82 // Other:
83 // equals
84 // equalsNode
85
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);
95
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(cStyleCastExpr);
132 REGISTER_MATCHER(ctorInitializer);
133 REGISTER_MATCHER(CUDAKernelCallExpr);
134 REGISTER_MATCHER(decl);
135 REGISTER_MATCHER(declaratorDecl);
136 REGISTER_MATCHER(declCountIs);
137 REGISTER_MATCHER(declRefExpr);
138 REGISTER_MATCHER(declStmt);
139 REGISTER_MATCHER(defaultArgExpr);
140 REGISTER_MATCHER(defaultStmt);
141 REGISTER_MATCHER(deleteExpr);
142 REGISTER_MATCHER(dependentSizedArrayType);
143 REGISTER_MATCHER(destructorDecl);
144 REGISTER_MATCHER(doStmt);
145 REGISTER_MATCHER(dynamicCastExpr);
146 REGISTER_MATCHER(eachOf);
147 REGISTER_MATCHER(elaboratedType);
148 REGISTER_MATCHER(enumConstantDecl);
149 REGISTER_MATCHER(enumDecl);
150 REGISTER_MATCHER(equalsBoundNode);
151 REGISTER_MATCHER(equalsIntegralValue);
152 REGISTER_MATCHER(explicitCastExpr);
153 REGISTER_MATCHER(expr);
154 REGISTER_MATCHER(exprWithCleanups);
155 REGISTER_MATCHER(fieldDecl);
156 REGISTER_MATCHER(floatLiteral);
157 REGISTER_MATCHER(forEach);
158 REGISTER_MATCHER(forEachConstructorInitializer);
159 REGISTER_MATCHER(forEachDescendant);
160 REGISTER_MATCHER(forEachSwitchCase);
161 REGISTER_MATCHER(forField);
162 REGISTER_MATCHER(forRangeStmt);
163 REGISTER_MATCHER(forStmt);
164 REGISTER_MATCHER(friendDecl);
165 REGISTER_MATCHER(functionalCastExpr);
166 REGISTER_MATCHER(functionDecl);
167 REGISTER_MATCHER(functionTemplateDecl);
168 REGISTER_MATCHER(functionType);
169 REGISTER_MATCHER(gotoStmt);
170 REGISTER_MATCHER(has);
171 REGISTER_MATCHER(hasAncestor);
172 REGISTER_MATCHER(hasAnyArgument);
173 REGISTER_MATCHER(hasAnyConstructorInitializer);
174 REGISTER_MATCHER(hasAnyParameter);
175 REGISTER_MATCHER(hasAnySubstatement);
176 REGISTER_MATCHER(hasAnyTemplateArgument);
177 REGISTER_MATCHER(hasAnyUsingShadowDecl);
178 REGISTER_MATCHER(hasArgument);
179 REGISTER_MATCHER(hasArgumentOfType);
180 REGISTER_MATCHER(hasAttr);
181 REGISTER_MATCHER(hasBase);
182 REGISTER_MATCHER(hasBody);
183 REGISTER_MATCHER(hasCanonicalType);
184 REGISTER_MATCHER(hasCaseConstant);
185 REGISTER_MATCHER(hasCondition);
186 REGISTER_MATCHER(hasConditionVariableStatement);
187 REGISTER_MATCHER(hasDeclaration);
188 REGISTER_MATCHER(hasDeclContext);
189 REGISTER_MATCHER(hasDeducedType);
190 REGISTER_MATCHER(hasDescendant);
191 REGISTER_MATCHER(hasDestinationType);
192 REGISTER_MATCHER(hasEitherOperand);
193 REGISTER_MATCHER(hasElementType);
194 REGISTER_MATCHER(hasElse);
195 REGISTER_MATCHER(hasFalseExpression);
196 REGISTER_MATCHER(hasGlobalStorage);
197 REGISTER_MATCHER(hasImplicitDestinationType);
198 REGISTER_MATCHER(hasIncrement);
199 REGISTER_MATCHER(hasIndex);
200 REGISTER_MATCHER(hasInitializer);
201 REGISTER_MATCHER(hasLHS);
202 REGISTER_MATCHER(hasLocalQualifiers);
203 REGISTER_MATCHER(hasLocalStorage);
204 REGISTER_MATCHER(hasLoopInit);
205 REGISTER_MATCHER(hasLoopVariable);
206 REGISTER_MATCHER(hasMethod);
207 REGISTER_MATCHER(hasName);
208 REGISTER_MATCHER(hasObjectExpression);
209 REGISTER_MATCHER(hasOperatorName);
210 REGISTER_MATCHER(hasOverloadedOperatorName);
211 REGISTER_MATCHER(hasParameter);
212 REGISTER_MATCHER(hasParent);
213 REGISTER_MATCHER(hasQualifier);
214 REGISTER_MATCHER(hasRangeInit);
215 REGISTER_MATCHER(hasRHS);
216 REGISTER_MATCHER(hasSingleDecl);
217 REGISTER_MATCHER(hasSize);
218 REGISTER_MATCHER(hasSizeExpr);
219 REGISTER_MATCHER(hasSourceExpression);
220 REGISTER_MATCHER(hasTargetDecl);
221 REGISTER_MATCHER(hasTemplateArgument);
222 REGISTER_MATCHER(hasThen);
223 REGISTER_MATCHER(hasTrueExpression);
224 REGISTER_MATCHER(hasTypeLoc);
225 REGISTER_MATCHER(hasUnaryOperand);
226 REGISTER_MATCHER(hasValueType);
227 REGISTER_MATCHER(ifStmt);
228 REGISTER_MATCHER(ignoringImpCasts);
229 REGISTER_MATCHER(ignoringParenCasts);
230 REGISTER_MATCHER(ignoringParenImpCasts);
231 REGISTER_MATCHER(implicitCastExpr);
232 REGISTER_MATCHER(incompleteArrayType);
233 REGISTER_MATCHER(initListExpr);
234 REGISTER_MATCHER(innerType);
235 REGISTER_MATCHER(integerLiteral);
236 REGISTER_MATCHER(isArrow);
237 REGISTER_MATCHER(isConst);
238 REGISTER_MATCHER(isConstQualified);
239 REGISTER_MATCHER(isDefinition);
240 REGISTER_MATCHER(isDeleted);
241 REGISTER_MATCHER(isExplicitTemplateSpecialization);
242 REGISTER_MATCHER(isExpr);
243 REGISTER_MATCHER(isExternC);
244 REGISTER_MATCHER(isImplicit);
245 REGISTER_MATCHER(isExpansionInFileMatching);
246 REGISTER_MATCHER(isExpansionInMainFile);
247 REGISTER_MATCHER(isInstantiated);
248 REGISTER_MATCHER(isExpansionInSystemHeader);
249 REGISTER_MATCHER(isInteger);
250 REGISTER_MATCHER(isIntegral);
251 REGISTER_MATCHER(isInTemplateInstantiation);
252 REGISTER_MATCHER(isListInitialization);
253 REGISTER_MATCHER(isOverride);
254 REGISTER_MATCHER(isPrivate);
255 REGISTER_MATCHER(isProtected);
256 REGISTER_MATCHER(isPublic);
257 REGISTER_MATCHER(isPure);
258 REGISTER_MATCHER(isTemplateInstantiation);
259 REGISTER_MATCHER(isVirtual);
260 REGISTER_MATCHER(isWritten);
261 REGISTER_MATCHER(labelStmt);
262 REGISTER_MATCHER(lambdaExpr);
263 REGISTER_MATCHER(lValueReferenceType);
264 REGISTER_MATCHER(matchesName);
265 REGISTER_MATCHER(materializeTemporaryExpr);
266 REGISTER_MATCHER(member);
267 REGISTER_MATCHER(memberCallExpr);
268 REGISTER_MATCHER(memberExpr);
269 REGISTER_MATCHER(memberPointerType);
270 REGISTER_MATCHER(methodDecl);
271 REGISTER_MATCHER(namedDecl);
272 REGISTER_MATCHER(namespaceDecl);
273 REGISTER_MATCHER(namesType);
274 REGISTER_MATCHER(nestedNameSpecifier);
275 REGISTER_MATCHER(nestedNameSpecifierLoc);
276 REGISTER_MATCHER(newExpr);
277 REGISTER_MATCHER(nullPtrLiteralExpr);
278 REGISTER_MATCHER(nullStmt);
279 REGISTER_MATCHER(ofClass);
280 REGISTER_MATCHER(on);
281 REGISTER_MATCHER(onImplicitObjectArgument);
282 REGISTER_MATCHER(operatorCallExpr);
283 REGISTER_MATCHER(parameterCountIs);
284 REGISTER_MATCHER(parenType);
285 REGISTER_MATCHER(parmVarDecl);
286 REGISTER_MATCHER(pointee);
287 REGISTER_MATCHER(pointerType);
288 REGISTER_MATCHER(qualType);
289 REGISTER_MATCHER(recordDecl);
290 REGISTER_MATCHER(recordType);
291 REGISTER_MATCHER(referenceType);
292 REGISTER_MATCHER(refersToDeclaration);
293 REGISTER_MATCHER(refersToIntegralType);
294 REGISTER_MATCHER(refersToType);
295 REGISTER_MATCHER(reinterpretCastExpr);
296 REGISTER_MATCHER(returns);
297 REGISTER_MATCHER(returnStmt);
298 REGISTER_MATCHER(rValueReferenceType);
299 REGISTER_MATCHER(sizeOfExpr);
300 REGISTER_MATCHER(specifiesNamespace);
301 REGISTER_MATCHER(specifiesType);
302 REGISTER_MATCHER(specifiesTypeLoc);
303 REGISTER_MATCHER(statementCountIs);
304 REGISTER_MATCHER(staticCastExpr);
305 REGISTER_MATCHER(stmt);
306 REGISTER_MATCHER(stringLiteral);
307 REGISTER_MATCHER(substNonTypeTemplateParmExpr);
308 REGISTER_MATCHER(switchCase);
309 REGISTER_MATCHER(switchStmt);
310 REGISTER_MATCHER(templateArgument);
311 REGISTER_MATCHER(templateArgumentCountIs);
312 REGISTER_MATCHER(templateSpecializationType);
313 REGISTER_MATCHER(temporaryObjectExpr);
314 REGISTER_MATCHER(thisExpr);
315 REGISTER_MATCHER(throughUsingDecl);
316 REGISTER_MATCHER(throwExpr);
317 REGISTER_MATCHER(to);
318 REGISTER_MATCHER(tryStmt);
319 REGISTER_MATCHER(type);
320 REGISTER_MATCHER(typedefDecl);
321 REGISTER_MATCHER(typedefType);
322 REGISTER_MATCHER(typeLoc);
323 REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
324 REGISTER_MATCHER(unaryOperator);
325 REGISTER_MATCHER(unaryTransformType);
326 REGISTER_MATCHER(unless);
327 REGISTER_MATCHER(unresolvedConstructExpr);
328 REGISTER_MATCHER(unresolvedUsingValueDecl);
329 REGISTER_MATCHER(userDefinedLiteral);
330 REGISTER_MATCHER(usingDecl);
331 REGISTER_MATCHER(usingDirectiveDecl);
332 REGISTER_MATCHER(valueDecl);
333 REGISTER_MATCHER(varDecl);
334 REGISTER_MATCHER(variableArrayType);
335 REGISTER_MATCHER(voidType);
336 REGISTER_MATCHER(whileStmt);
337 REGISTER_MATCHER(withInitializer);
338 }
339
~RegistryMaps()340 RegistryMaps::~RegistryMaps() {
341 for (ConstructorMap::iterator it = Constructors.begin(),
342 end = Constructors.end();
343 it != end; ++it) {
344 delete it->second;
345 }
346 }
347
348 static llvm::ManagedStatic<RegistryMaps> RegistryData;
349
350 } // anonymous namespace
351
352 // static
lookupMatcherCtor(StringRef MatcherName)353 llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
354 ConstructorMap::const_iterator it =
355 RegistryData->constructors().find(MatcherName);
356 return it == RegistryData->constructors().end()
357 ? llvm::Optional<MatcherCtor>()
358 : it->second;
359 }
360
361 namespace {
362
operator <<(llvm::raw_ostream & OS,const std::set<ASTNodeKind> & KS)363 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
364 const std::set<ASTNodeKind> &KS) {
365 unsigned Count = 0;
366 for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
367 I != E; ++I) {
368 if (I != KS.begin())
369 OS << "|";
370 if (Count++ == 3) {
371 OS << "...";
372 break;
373 }
374 OS << *I;
375 }
376 return OS;
377 }
378
379 } // namespace
380
getAcceptedCompletionTypes(ArrayRef<std::pair<MatcherCtor,unsigned>> Context)381 std::vector<ArgKind> Registry::getAcceptedCompletionTypes(
382 ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
383 ASTNodeKind InitialTypes[] = {
384 ASTNodeKind::getFromNodeKind<Decl>(),
385 ASTNodeKind::getFromNodeKind<QualType>(),
386 ASTNodeKind::getFromNodeKind<Type>(),
387 ASTNodeKind::getFromNodeKind<Stmt>(),
388 ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
389 ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
390 ASTNodeKind::getFromNodeKind<TypeLoc>()};
391
392 // Starting with the above seed of acceptable top-level matcher types, compute
393 // the acceptable type set for the argument indicated by each context element.
394 std::set<ArgKind> TypeSet(std::begin(InitialTypes), std::end(InitialTypes));
395 for (const auto &CtxEntry : Context) {
396 MatcherCtor Ctor = CtxEntry.first;
397 unsigned ArgNumber = CtxEntry.second;
398 std::vector<ArgKind> NextTypeSet;
399 for (const ArgKind &Kind : TypeSet) {
400 if (Kind.getArgKind() == Kind.AK_Matcher &&
401 Ctor->isConvertibleTo(Kind.getMatcherKind()) &&
402 (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))
403 Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);
404 }
405 TypeSet.clear();
406 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());
407 }
408 return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());
409 }
410
411 std::vector<MatcherCompletion>
getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes)412 Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {
413 std::vector<MatcherCompletion> Completions;
414
415 // Search the registry for acceptable matchers.
416 for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(),
417 E = RegistryData->constructors().end();
418 I != E; ++I) {
419 std::set<ASTNodeKind> RetKinds;
420 unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs();
421 bool IsPolymorphic = I->second->isPolymorphic();
422 std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);
423 unsigned MaxSpecificity = 0;
424 for (const ArgKind& Kind : AcceptedTypes) {
425 if (Kind.getArgKind() != Kind.AK_Matcher)
426 continue;
427 unsigned Specificity;
428 ASTNodeKind LeastDerivedKind;
429 if (I->second->isConvertibleTo(Kind.getMatcherKind(), &Specificity,
430 &LeastDerivedKind)) {
431 if (MaxSpecificity < Specificity)
432 MaxSpecificity = Specificity;
433 RetKinds.insert(LeastDerivedKind);
434 for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
435 I->second->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);
436 if (IsPolymorphic)
437 break;
438 }
439 }
440
441 if (!RetKinds.empty() && MaxSpecificity > 0) {
442 std::string Decl;
443 llvm::raw_string_ostream OS(Decl);
444
445 if (IsPolymorphic) {
446 OS << "Matcher<T> " << I->first() << "(Matcher<T>";
447 } else {
448 OS << "Matcher<" << RetKinds << "> " << I->first() << "(";
449 for (const std::vector<ArgKind> &Arg : ArgsKinds) {
450 if (&Arg != &ArgsKinds[0])
451 OS << ", ";
452
453 bool FirstArgKind = true;
454 std::set<ASTNodeKind> MatcherKinds;
455 // Two steps. First all non-matchers, then matchers only.
456 for (const ArgKind &AK : Arg) {
457 if (AK.getArgKind() == ArgKind::AK_Matcher) {
458 MatcherKinds.insert(AK.getMatcherKind());
459 } else {
460 if (!FirstArgKind) OS << "|";
461 FirstArgKind = false;
462 OS << AK.asString();
463 }
464 }
465 if (!MatcherKinds.empty()) {
466 if (!FirstArgKind) OS << "|";
467 OS << "Matcher<" << MatcherKinds << ">";
468 }
469 }
470 }
471 if (I->second->isVariadic())
472 OS << "...";
473 OS << ")";
474
475 std::string TypedText = I->first();
476 TypedText += "(";
477 if (ArgsKinds.empty())
478 TypedText += ")";
479 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)
480 TypedText += "\"";
481
482 Completions.emplace_back(TypedText, OS.str(), MaxSpecificity);
483 }
484 }
485
486 return Completions;
487 }
488
489 // static
constructMatcher(MatcherCtor Ctor,const SourceRange & NameRange,ArrayRef<ParserValue> Args,Diagnostics * Error)490 VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
491 const SourceRange &NameRange,
492 ArrayRef<ParserValue> Args,
493 Diagnostics *Error) {
494 return Ctor->create(NameRange, Args, Error);
495 }
496
497 // static
constructBoundMatcher(MatcherCtor Ctor,const SourceRange & NameRange,StringRef BindID,ArrayRef<ParserValue> Args,Diagnostics * Error)498 VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
499 const SourceRange &NameRange,
500 StringRef BindID,
501 ArrayRef<ParserValue> Args,
502 Diagnostics *Error) {
503 VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
504 if (Out.isNull()) return Out;
505
506 llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
507 if (Result.hasValue()) {
508 llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
509 if (Bound.hasValue()) {
510 return VariantMatcher::SingleMatcher(*Bound);
511 }
512 }
513 Error->addError(NameRange, Error->ET_RegistryNotBindable);
514 return VariantMatcher();
515 }
516
517 } // namespace dynamic
518 } // namespace ast_matchers
519 } // namespace clang
520