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"
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"
26 namespace ast_matchers {
30 using internal::MatcherCreateCallback;
32 typedef llvm::StringMap<const MatcherCreateCallback *> ConstructorMap;
38 const ConstructorMap &constructors() const { return Constructors; }
41 void registerMatcher(StringRef MatcherName, MatcherCreateCallback *Callback);
42 ConstructorMap Constructors;
45 void RegistryMaps::registerMatcher(StringRef MatcherName,
46 MatcherCreateCallback *Callback) {
47 assert(Constructors.find(MatcherName) == Constructors.end());
48 Constructors[MatcherName] = Callback;
51 #define REGISTER_MATCHER(name) \
52 registerMatcher(#name, internal::makeMatcherAutoMarshall( \
53 ::clang::ast_matchers::name, #name));
55 #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
56 static_cast< ::clang::ast_matchers::name##_Type##Id>( \
57 ::clang::ast_matchers::name)
59 #define REGISTER_OVERLOADED_2(name) \
61 MatcherCreateCallback *Callbacks[] = { \
62 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
64 internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
67 registerMatcher(#name, \
68 new internal::OverloadedMatcherCreateCallback(Callbacks)); \
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.
75 // Need Variant/Parser fixes:
78 // Polymorphic + argument overload:
87 REGISTER_OVERLOADED_2(callee);
88 REGISTER_OVERLOADED_2(hasPrefix);
89 REGISTER_OVERLOADED_2(hasType);
90 REGISTER_OVERLOADED_2(isDerivedFrom);
91 REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
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(asString);
105 REGISTER_MATCHER(asmStmt);
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(cStyleCastExpr);
115 REGISTER_MATCHER(callExpr);
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(defaultArgExpr);
137 REGISTER_MATCHER(deleteExpr);
138 REGISTER_MATCHER(dependentSizedArrayType);
139 REGISTER_MATCHER(destructorDecl);
140 REGISTER_MATCHER(doStmt);
141 REGISTER_MATCHER(dynamicCastExpr);
142 REGISTER_MATCHER(eachOf);
143 REGISTER_MATCHER(elaboratedType);
144 REGISTER_MATCHER(enumConstantDecl);
145 REGISTER_MATCHER(enumDecl);
146 REGISTER_MATCHER(explicitCastExpr);
147 REGISTER_MATCHER(expr);
148 REGISTER_MATCHER(fieldDecl);
149 REGISTER_MATCHER(floatLiteral);
150 REGISTER_MATCHER(forEach);
151 REGISTER_MATCHER(forEachDescendant);
152 REGISTER_MATCHER(forField);
153 REGISTER_MATCHER(forRangeStmt);
154 REGISTER_MATCHER(forStmt);
155 REGISTER_MATCHER(functionDecl);
156 REGISTER_MATCHER(functionTemplateDecl);
157 REGISTER_MATCHER(functionType);
158 REGISTER_MATCHER(functionalCastExpr);
159 REGISTER_MATCHER(gotoStmt);
160 REGISTER_MATCHER(has);
161 REGISTER_MATCHER(hasAncestor);
162 REGISTER_MATCHER(hasAnyArgument);
163 REGISTER_MATCHER(hasAnyConstructorInitializer);
164 REGISTER_MATCHER(hasAnyParameter);
165 REGISTER_MATCHER(hasAnySubstatement);
166 REGISTER_MATCHER(hasAnyTemplateArgument);
167 REGISTER_MATCHER(hasAnyUsingShadowDecl);
168 REGISTER_MATCHER(hasArgument);
169 REGISTER_MATCHER(hasArgumentOfType);
170 REGISTER_MATCHER(hasBase);
171 REGISTER_MATCHER(hasBody);
172 REGISTER_MATCHER(hasCanonicalType);
173 REGISTER_MATCHER(hasCondition);
174 REGISTER_MATCHER(hasConditionVariableStatement);
175 REGISTER_MATCHER(hasDeclContext);
176 REGISTER_MATCHER(hasDeclaration);
177 REGISTER_MATCHER(hasDeducedType);
178 REGISTER_MATCHER(hasDescendant);
179 REGISTER_MATCHER(hasDestinationType);
180 REGISTER_MATCHER(hasEitherOperand);
181 REGISTER_MATCHER(hasElementType);
182 REGISTER_MATCHER(hasFalseExpression);
183 REGISTER_MATCHER(hasImplicitDestinationType);
184 REGISTER_MATCHER(hasIncrement);
185 REGISTER_MATCHER(hasIndex);
186 REGISTER_MATCHER(hasInitializer);
187 REGISTER_MATCHER(hasLHS);
188 REGISTER_MATCHER(hasLocalQualifiers);
189 REGISTER_MATCHER(hasLoopInit);
190 REGISTER_MATCHER(hasMethod);
191 REGISTER_MATCHER(hasName);
192 REGISTER_MATCHER(hasObjectExpression);
193 REGISTER_MATCHER(hasOperatorName);
194 REGISTER_MATCHER(hasOverloadedOperatorName);
195 REGISTER_MATCHER(hasParameter);
196 REGISTER_MATCHER(hasParent);
197 REGISTER_MATCHER(hasQualifier);
198 REGISTER_MATCHER(hasRHS);
199 REGISTER_MATCHER(hasSingleDecl);
200 REGISTER_MATCHER(hasSize);
201 REGISTER_MATCHER(hasSizeExpr);
202 REGISTER_MATCHER(hasSourceExpression);
203 REGISTER_MATCHER(hasTargetDecl);
204 REGISTER_MATCHER(hasTemplateArgument);
205 REGISTER_MATCHER(hasTrueExpression);
206 REGISTER_MATCHER(hasUnaryOperand);
207 REGISTER_MATCHER(hasValueType);
208 REGISTER_MATCHER(ifStmt);
209 REGISTER_MATCHER(ignoringImpCasts);
210 REGISTER_MATCHER(ignoringParenCasts);
211 REGISTER_MATCHER(ignoringParenImpCasts);
212 REGISTER_MATCHER(implicitCastExpr);
213 REGISTER_MATCHER(incompleteArrayType);
214 REGISTER_MATCHER(initListExpr);
215 REGISTER_MATCHER(innerType);
216 REGISTER_MATCHER(integerLiteral);
217 REGISTER_MATCHER(isArrow);
218 REGISTER_MATCHER(isConstQualified);
219 REGISTER_MATCHER(isDefinition);
220 REGISTER_MATCHER(isExplicitTemplateSpecialization);
221 REGISTER_MATCHER(isExternC);
222 REGISTER_MATCHER(isImplicit);
223 REGISTER_MATCHER(isInteger);
224 REGISTER_MATCHER(isOverride);
225 REGISTER_MATCHER(isPrivate);
226 REGISTER_MATCHER(isProtected);
227 REGISTER_MATCHER(isPublic);
228 REGISTER_MATCHER(isTemplateInstantiation);
229 REGISTER_MATCHER(isVirtual);
230 REGISTER_MATCHER(isWritten);
231 REGISTER_MATCHER(lValueReferenceType);
232 REGISTER_MATCHER(labelStmt);
233 REGISTER_MATCHER(lambdaExpr);
234 REGISTER_MATCHER(matchesName);
235 REGISTER_MATCHER(materializeTemporaryExpr);
236 REGISTER_MATCHER(member);
237 REGISTER_MATCHER(memberCallExpr);
238 REGISTER_MATCHER(memberExpr);
239 REGISTER_MATCHER(memberPointerType);
240 REGISTER_MATCHER(methodDecl);
241 REGISTER_MATCHER(namedDecl);
242 REGISTER_MATCHER(namesType);
243 REGISTER_MATCHER(namespaceDecl);
244 REGISTER_MATCHER(nestedNameSpecifier);
245 REGISTER_MATCHER(nestedNameSpecifierLoc);
246 REGISTER_MATCHER(newExpr);
247 REGISTER_MATCHER(nullPtrLiteralExpr);
248 REGISTER_MATCHER(nullStmt);
249 REGISTER_MATCHER(ofClass);
250 REGISTER_MATCHER(on);
251 REGISTER_MATCHER(onImplicitObjectArgument);
252 REGISTER_MATCHER(operatorCallExpr);
253 REGISTER_MATCHER(parameterCountIs);
254 REGISTER_MATCHER(parenType);
255 REGISTER_MATCHER(pointee);
256 REGISTER_MATCHER(pointerType);
257 REGISTER_MATCHER(qualType);
258 REGISTER_MATCHER(rValueReferenceType);
259 REGISTER_MATCHER(recordDecl);
260 REGISTER_MATCHER(recordType);
261 REGISTER_MATCHER(referenceType);
262 REGISTER_MATCHER(refersToDeclaration);
263 REGISTER_MATCHER(refersToType);
264 REGISTER_MATCHER(reinterpretCastExpr);
265 REGISTER_MATCHER(returnStmt);
266 REGISTER_MATCHER(returns);
267 REGISTER_MATCHER(sizeOfExpr);
268 REGISTER_MATCHER(specifiesNamespace);
269 REGISTER_MATCHER(specifiesType);
270 REGISTER_MATCHER(specifiesTypeLoc);
271 REGISTER_MATCHER(statementCountIs);
272 REGISTER_MATCHER(staticCastExpr);
273 REGISTER_MATCHER(stmt);
274 REGISTER_MATCHER(stringLiteral);
275 REGISTER_MATCHER(switchCase);
276 REGISTER_MATCHER(switchStmt);
277 REGISTER_MATCHER(templateSpecializationType);
278 REGISTER_MATCHER(thisExpr);
279 REGISTER_MATCHER(throughUsingDecl);
280 REGISTER_MATCHER(throwExpr);
281 REGISTER_MATCHER(to);
282 REGISTER_MATCHER(tryStmt);
283 REGISTER_MATCHER(type);
284 REGISTER_MATCHER(typeLoc);
285 REGISTER_MATCHER(typedefType);
286 REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
287 REGISTER_MATCHER(unaryOperator);
288 REGISTER_MATCHER(userDefinedLiteral);
289 REGISTER_MATCHER(usingDecl);
290 REGISTER_MATCHER(varDecl);
291 REGISTER_MATCHER(variableArrayType);
292 REGISTER_MATCHER(whileStmt);
293 REGISTER_MATCHER(withInitializer);
296 RegistryMaps::~RegistryMaps() {
297 for (ConstructorMap::iterator it = Constructors.begin(),
298 end = Constructors.end();
304 static llvm::ManagedStatic<RegistryMaps> RegistryData;
306 } // anonymous namespace
309 VariantMatcher Registry::constructMatcher(StringRef MatcherName,
310 const SourceRange &NameRange,
311 ArrayRef<ParserValue> Args,
312 Diagnostics *Error) {
313 ConstructorMap::const_iterator it =
314 RegistryData->constructors().find(MatcherName);
315 if (it == RegistryData->constructors().end()) {
316 Error->addError(NameRange, Error->ET_RegistryNotFound) << MatcherName;
317 return VariantMatcher();
320 return it->second->run(NameRange, Args, Error);
324 VariantMatcher Registry::constructBoundMatcher(StringRef MatcherName,
325 const SourceRange &NameRange,
327 ArrayRef<ParserValue> Args,
328 Diagnostics *Error) {
329 VariantMatcher Out = constructMatcher(MatcherName, NameRange, Args, Error);
330 if (Out.isNull()) return Out;
332 llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
333 if (Result.hasValue()) {
334 llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
335 if (Bound.hasValue()) {
336 return VariantMatcher::SingleMatcher(*Bound);
339 Error->addError(NameRange, Error->ET_RegistryNotBindable);
340 return VariantMatcher();
343 } // namespace dynamic
344 } // namespace ast_matchers