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 
17 #include <utility>
18 
19 #include "Marshallers.h"
20 #include "clang/ASTMatchers/ASTMatchers.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/Support/ManagedStatic.h"
24 
25 namespace clang {
26 namespace ast_matchers {
27 namespace dynamic {
28 namespace {
29 
30 using internal::MatcherDescriptor;
31 
32 typedef llvm::StringMap<const MatcherDescriptor *> ConstructorMap;
33 class RegistryMaps {
34 public:
35   RegistryMaps();
36   ~RegistryMaps();
37 
38   const ConstructorMap &constructors() const { return Constructors; }
39 
40 private:
41   void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback);
42   ConstructorMap Constructors;
43 };
44 
45 void RegistryMaps::registerMatcher(StringRef MatcherName,
46                                    MatcherDescriptor *Callback) {
47   assert(Constructors.find(MatcherName) == Constructors.end());
48   Constructors[MatcherName] = Callback;
49 }
50 
51 #define REGISTER_MATCHER(name)                                                 \
52   registerMatcher(#name, internal::makeMatcherAutoMarshall(                    \
53                              ::clang::ast_matchers::name, #name));
54 
55 #define SPECIFIC_MATCHER_OVERLOAD(name, Id)                                    \
56   static_cast< ::clang::ast_matchers::name##_Type##Id>(                        \
57       ::clang::ast_matchers::name)
58 
59 #define REGISTER_OVERLOADED_2(name)                                            \
60   do {                                                                         \
61     MatcherDescriptor *Callbacks[] = {                                         \
62       internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0),    \
63                                         #name),                                \
64       internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1),    \
65                                         #name)                                 \
66     };                                                                         \
67     registerMatcher(#name,                                                     \
68                     new internal::OverloadedMatcherDescriptor(Callbacks));     \
69   } while (0)
70 
71 /// \brief Generate a registry map with all the known matchers.
72 RegistryMaps::RegistryMaps() {
73   // TODO: Here is the list of the missing matchers, grouped by reason.
74   //
75   // Need Variant/Parser fixes:
76   // ofKind
77   //
78   // Polymorphic + argument overload:
79   // findAll
80   //
81   // Other:
82   // loc
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(pointsTo);
92   REGISTER_OVERLOADED_2(references);
93   REGISTER_OVERLOADED_2(thisPointerType);
94 
95   REGISTER_MATCHER(accessSpecDecl);
96   REGISTER_MATCHER(alignOfExpr);
97   REGISTER_MATCHER(allOf);
98   REGISTER_MATCHER(anyOf);
99   REGISTER_MATCHER(anything);
100   REGISTER_MATCHER(argumentCountIs);
101   REGISTER_MATCHER(arraySubscriptExpr);
102   REGISTER_MATCHER(arrayType);
103   REGISTER_MATCHER(asString);
104   REGISTER_MATCHER(asmStmt);
105   REGISTER_MATCHER(atomicType);
106   REGISTER_MATCHER(autoType);
107   REGISTER_MATCHER(binaryOperator);
108   REGISTER_MATCHER(bindTemporaryExpr);
109   REGISTER_MATCHER(blockPointerType);
110   REGISTER_MATCHER(boolLiteral);
111   REGISTER_MATCHER(breakStmt);
112   REGISTER_MATCHER(builtinType);
113   REGISTER_MATCHER(cStyleCastExpr);
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(constCastExpr);
126   REGISTER_MATCHER(constantArrayType);
127   REGISTER_MATCHER(constructExpr);
128   REGISTER_MATCHER(constructorDecl);
129   REGISTER_MATCHER(containsDeclaration);
130   REGISTER_MATCHER(continueStmt);
131   REGISTER_MATCHER(ctorInitializer);
132   REGISTER_MATCHER(decl);
133   REGISTER_MATCHER(declCountIs);
134   REGISTER_MATCHER(declRefExpr);
135   REGISTER_MATCHER(declStmt);
136   REGISTER_MATCHER(declaratorDecl);
137   REGISTER_MATCHER(defaultArgExpr);
138   REGISTER_MATCHER(defaultStmt);
139   REGISTER_MATCHER(deleteExpr);
140   REGISTER_MATCHER(dependentSizedArrayType);
141   REGISTER_MATCHER(destructorDecl);
142   REGISTER_MATCHER(doStmt);
143   REGISTER_MATCHER(dynamicCastExpr);
144   REGISTER_MATCHER(eachOf);
145   REGISTER_MATCHER(elaboratedType);
146   REGISTER_MATCHER(enumConstantDecl);
147   REGISTER_MATCHER(enumDecl);
148   REGISTER_MATCHER(equalsBoundNode);
149   REGISTER_MATCHER(explicitCastExpr);
150   REGISTER_MATCHER(expr);
151   REGISTER_MATCHER(fieldDecl);
152   REGISTER_MATCHER(floatLiteral);
153   REGISTER_MATCHER(forEach);
154   REGISTER_MATCHER(forEachConstructorInitializer);
155   REGISTER_MATCHER(forEachDescendant);
156   REGISTER_MATCHER(forEachSwitchCase);
157   REGISTER_MATCHER(forField);
158   REGISTER_MATCHER(forRangeStmt);
159   REGISTER_MATCHER(forStmt);
160   REGISTER_MATCHER(friendDecl);
161   REGISTER_MATCHER(functionDecl);
162   REGISTER_MATCHER(functionTemplateDecl);
163   REGISTER_MATCHER(functionType);
164   REGISTER_MATCHER(functionalCastExpr);
165   REGISTER_MATCHER(gotoStmt);
166   REGISTER_MATCHER(has);
167   REGISTER_MATCHER(hasAncestor);
168   REGISTER_MATCHER(hasAnyArgument);
169   REGISTER_MATCHER(hasAnyConstructorInitializer);
170   REGISTER_MATCHER(hasAnyParameter);
171   REGISTER_MATCHER(hasAnySubstatement);
172   REGISTER_MATCHER(hasAnyTemplateArgument);
173   REGISTER_MATCHER(hasAnyUsingShadowDecl);
174   REGISTER_MATCHER(hasArgument);
175   REGISTER_MATCHER(hasArgumentOfType);
176   REGISTER_MATCHER(hasBase);
177   REGISTER_MATCHER(hasBody);
178   REGISTER_MATCHER(hasCanonicalType);
179   REGISTER_MATCHER(hasCaseConstant);
180   REGISTER_MATCHER(hasCondition);
181   REGISTER_MATCHER(hasConditionVariableStatement);
182   REGISTER_MATCHER(hasDeclContext);
183   REGISTER_MATCHER(hasDeclaration);
184   REGISTER_MATCHER(hasDeducedType);
185   REGISTER_MATCHER(hasDescendant);
186   REGISTER_MATCHER(hasDestinationType);
187   REGISTER_MATCHER(hasEitherOperand);
188   REGISTER_MATCHER(hasElementType);
189   REGISTER_MATCHER(hasFalseExpression);
190   REGISTER_MATCHER(hasImplicitDestinationType);
191   REGISTER_MATCHER(hasIncrement);
192   REGISTER_MATCHER(hasIndex);
193   REGISTER_MATCHER(hasInitializer);
194   REGISTER_MATCHER(hasLHS);
195   REGISTER_MATCHER(hasLocalQualifiers);
196   REGISTER_MATCHER(hasLoopInit);
197   REGISTER_MATCHER(hasMethod);
198   REGISTER_MATCHER(hasName);
199   REGISTER_MATCHER(hasObjectExpression);
200   REGISTER_MATCHER(hasOperatorName);
201   REGISTER_MATCHER(hasOverloadedOperatorName);
202   REGISTER_MATCHER(hasParameter);
203   REGISTER_MATCHER(hasParent);
204   REGISTER_MATCHER(hasQualifier);
205   REGISTER_MATCHER(hasRHS);
206   REGISTER_MATCHER(hasSingleDecl);
207   REGISTER_MATCHER(hasSize);
208   REGISTER_MATCHER(hasSizeExpr);
209   REGISTER_MATCHER(hasSourceExpression);
210   REGISTER_MATCHER(hasTargetDecl);
211   REGISTER_MATCHER(hasTemplateArgument);
212   REGISTER_MATCHER(hasTrueExpression);
213   REGISTER_MATCHER(hasTypeLoc);
214   REGISTER_MATCHER(hasUnaryOperand);
215   REGISTER_MATCHER(hasValueType);
216   REGISTER_MATCHER(ifStmt);
217   REGISTER_MATCHER(ignoringImpCasts);
218   REGISTER_MATCHER(ignoringParenCasts);
219   REGISTER_MATCHER(ignoringParenImpCasts);
220   REGISTER_MATCHER(implicitCastExpr);
221   REGISTER_MATCHER(incompleteArrayType);
222   REGISTER_MATCHER(initListExpr);
223   REGISTER_MATCHER(innerType);
224   REGISTER_MATCHER(integerLiteral);
225   REGISTER_MATCHER(isArrow);
226   REGISTER_MATCHER(isConst);
227   REGISTER_MATCHER(isConstQualified);
228   REGISTER_MATCHER(isDefinition);
229   REGISTER_MATCHER(isExplicitTemplateSpecialization);
230   REGISTER_MATCHER(isExternC);
231   REGISTER_MATCHER(isImplicit);
232   REGISTER_MATCHER(isInteger);
233   REGISTER_MATCHER(isOverride);
234   REGISTER_MATCHER(isPrivate);
235   REGISTER_MATCHER(isProtected);
236   REGISTER_MATCHER(isPublic);
237   REGISTER_MATCHER(isTemplateInstantiation);
238   REGISTER_MATCHER(isVirtual);
239   REGISTER_MATCHER(isWritten);
240   REGISTER_MATCHER(lValueReferenceType);
241   REGISTER_MATCHER(labelStmt);
242   REGISTER_MATCHER(lambdaExpr);
243   REGISTER_MATCHER(matchesName);
244   REGISTER_MATCHER(materializeTemporaryExpr);
245   REGISTER_MATCHER(member);
246   REGISTER_MATCHER(memberCallExpr);
247   REGISTER_MATCHER(memberExpr);
248   REGISTER_MATCHER(memberPointerType);
249   REGISTER_MATCHER(methodDecl);
250   REGISTER_MATCHER(namedDecl);
251   REGISTER_MATCHER(namesType);
252   REGISTER_MATCHER(namespaceDecl);
253   REGISTER_MATCHER(nestedNameSpecifier);
254   REGISTER_MATCHER(nestedNameSpecifierLoc);
255   REGISTER_MATCHER(newExpr);
256   REGISTER_MATCHER(nullPtrLiteralExpr);
257   REGISTER_MATCHER(nullStmt);
258   REGISTER_MATCHER(ofClass);
259   REGISTER_MATCHER(on);
260   REGISTER_MATCHER(onImplicitObjectArgument);
261   REGISTER_MATCHER(operatorCallExpr);
262   REGISTER_MATCHER(parameterCountIs);
263   REGISTER_MATCHER(parenType);
264   REGISTER_MATCHER(parmVarDecl);
265   REGISTER_MATCHER(pointee);
266   REGISTER_MATCHER(pointerType);
267   REGISTER_MATCHER(qualType);
268   REGISTER_MATCHER(rValueReferenceType);
269   REGISTER_MATCHER(recordDecl);
270   REGISTER_MATCHER(recordType);
271   REGISTER_MATCHER(referenceType);
272   REGISTER_MATCHER(refersToDeclaration);
273   REGISTER_MATCHER(refersToType);
274   REGISTER_MATCHER(reinterpretCastExpr);
275   REGISTER_MATCHER(returnStmt);
276   REGISTER_MATCHER(returns);
277   REGISTER_MATCHER(sizeOfExpr);
278   REGISTER_MATCHER(specifiesNamespace);
279   REGISTER_MATCHER(specifiesType);
280   REGISTER_MATCHER(specifiesTypeLoc);
281   REGISTER_MATCHER(statementCountIs);
282   REGISTER_MATCHER(staticCastExpr);
283   REGISTER_MATCHER(stmt);
284   REGISTER_MATCHER(stringLiteral);
285   REGISTER_MATCHER(switchCase);
286   REGISTER_MATCHER(switchStmt);
287   REGISTER_MATCHER(templateSpecializationType);
288   REGISTER_MATCHER(temporaryObjectExpr);
289   REGISTER_MATCHER(thisExpr);
290   REGISTER_MATCHER(throughUsingDecl);
291   REGISTER_MATCHER(throwExpr);
292   REGISTER_MATCHER(to);
293   REGISTER_MATCHER(tryStmt);
294   REGISTER_MATCHER(type);
295   REGISTER_MATCHER(typeLoc);
296   REGISTER_MATCHER(typedefType);
297   REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
298   REGISTER_MATCHER(unaryOperator);
299   REGISTER_MATCHER(unaryTransformType);
300   REGISTER_MATCHER(unless);
301   REGISTER_MATCHER(unresolvedConstructExpr);
302   REGISTER_MATCHER(unresolvedUsingValueDecl);
303   REGISTER_MATCHER(userDefinedLiteral);
304   REGISTER_MATCHER(usingDecl);
305   REGISTER_MATCHER(varDecl);
306   REGISTER_MATCHER(variableArrayType);
307   REGISTER_MATCHER(whileStmt);
308   REGISTER_MATCHER(withInitializer);
309 }
310 
311 RegistryMaps::~RegistryMaps() {
312   for (ConstructorMap::iterator it = Constructors.begin(),
313                                 end = Constructors.end();
314        it != end; ++it) {
315     delete it->second;
316   }
317 }
318 
319 static llvm::ManagedStatic<RegistryMaps> RegistryData;
320 
321 } // anonymous namespace
322 
323 // static
324 llvm::Optional<MatcherCtor>
325 Registry::lookupMatcherCtor(StringRef MatcherName, const SourceRange &NameRange,
326                             Diagnostics *Error) {
327   ConstructorMap::const_iterator it =
328       RegistryData->constructors().find(MatcherName);
329   if (it == RegistryData->constructors().end()) {
330     Error->addError(NameRange, Error->ET_RegistryNotFound) << MatcherName;
331     return llvm::Optional<MatcherCtor>();
332   }
333 
334   return it->second;
335 }
336 
337 // static
338 VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
339                                           const SourceRange &NameRange,
340                                           ArrayRef<ParserValue> Args,
341                                           Diagnostics *Error) {
342   return Ctor->create(NameRange, Args, Error);
343 }
344 
345 // static
346 VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
347                                                const SourceRange &NameRange,
348                                                StringRef BindID,
349                                                ArrayRef<ParserValue> Args,
350                                                Diagnostics *Error) {
351   VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
352   if (Out.isNull()) return Out;
353 
354   llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
355   if (Result.hasValue()) {
356     llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
357     if (Bound.hasValue()) {
358       return VariantMatcher::SingleMatcher(*Bound);
359     }
360   }
361   Error->addError(NameRange, Error->ET_RegistryNotBindable);
362   return VariantMatcher();
363 }
364 
365 }  // namespace dynamic
366 }  // namespace ast_matchers
367 }  // namespace clang
368