Samuel Benzaquen | e30903d | 2013-05-15 19:49:05 +0000 | [diff] [blame] | 1 | //===--- Registry.cpp - Matcher registry -------------------------===// |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 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 | // |
Samuel Benzaquen | e30903d | 2013-05-15 19:49:05 +0000 | [diff] [blame] | 8 | //===------------------------------------------------------------===// |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 9 | /// |
| 10 | /// \file |
| 11 | /// \brief Registry map populated at static initialization time. |
| 12 | /// |
Samuel Benzaquen | e30903d | 2013-05-15 19:49:05 +0000 | [diff] [blame] | 13 | //===------------------------------------------------------------===// |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 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::MatcherCreateCallback; |
| 31 | |
| 32 | typedef llvm::StringMap<const MatcherCreateCallback *> 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, MatcherCreateCallback *Callback); |
| 42 | ConstructorMap Constructors; |
| 43 | }; |
| 44 | |
| 45 | void RegistryMaps::registerMatcher(StringRef MatcherName, |
| 46 | MatcherCreateCallback *Callback) { |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 47 | assert(Constructors.find(MatcherName) == Constructors.end()); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 48 | Constructors[MatcherName] = Callback; |
| 49 | } |
| 50 | |
| 51 | #define REGISTER_MATCHER(name) \ |
| 52 | registerMatcher(#name, internal::makeMatcherAutoMarshall( \ |
| 53 | ::clang::ast_matchers::name, #name)); |
| 54 | |
| 55 | /// \brief Generate a registry map with all the known matchers. |
| 56 | RegistryMaps::RegistryMaps() { |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 57 | // TODO: Here is the list of the missing matchers, grouped by reason. |
| 58 | // |
| 59 | // Need DynTypedNode fixes: |
| 60 | // hasAnyTemplateArgument |
| 61 | // hasTemplateArgument |
| 62 | // |
| 63 | // Need Variant/Parser fixes: |
| 64 | // ofKind |
| 65 | // |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 66 | // Function overloaded by args: |
| 67 | // hasType |
| 68 | // callee |
| 69 | // hasPrefix |
| 70 | // isDerivedFrom |
| 71 | // isSameOrDerivedFrom |
| 72 | // pointsTo |
| 73 | // references |
| 74 | // thisPointerType |
| 75 | // |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 76 | // Polymorphic + argument overload: |
| 77 | // unless |
| 78 | // eachOf |
| 79 | // anyOf |
| 80 | // allOf |
| 81 | // findAll |
| 82 | // |
| 83 | // Adaptative matcher (similar to polymorphic matcher): |
| 84 | // has |
| 85 | // forEach |
| 86 | // forEachDescendant |
| 87 | // hasDescendant |
| 88 | // hasParent |
| 89 | // hasAncestor |
| 90 | // |
| 91 | // Other: |
| 92 | // loc |
| 93 | // equals |
| 94 | // equalsNode |
| 95 | // hasDeclaration |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 96 | |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 97 | REGISTER_MATCHER(accessSpecDecl); |
| 98 | REGISTER_MATCHER(alignOfExpr); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 99 | REGISTER_MATCHER(anything); |
| 100 | REGISTER_MATCHER(argumentCountIs); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 101 | REGISTER_MATCHER(arraySubscriptExpr); |
| 102 | REGISTER_MATCHER(arrayType); |
| 103 | REGISTER_MATCHER(asString); |
| 104 | REGISTER_MATCHER(asmStmt); |
| 105 | REGISTER_MATCHER(atomicType); |
| 106 | REGISTER_MATCHER(autoType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 107 | REGISTER_MATCHER(binaryOperator); |
| 108 | REGISTER_MATCHER(bindTemporaryExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 109 | REGISTER_MATCHER(blockPointerType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 110 | REGISTER_MATCHER(boolLiteral); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 111 | REGISTER_MATCHER(breakStmt); |
| 112 | REGISTER_MATCHER(builtinType); |
| 113 | REGISTER_MATCHER(cStyleCastExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 114 | REGISTER_MATCHER(callExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 115 | REGISTER_MATCHER(castExpr); |
| 116 | REGISTER_MATCHER(catchStmt); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 117 | REGISTER_MATCHER(characterLiteral); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 118 | REGISTER_MATCHER(classTemplateDecl); |
| 119 | REGISTER_MATCHER(classTemplateSpecializationDecl); |
| 120 | REGISTER_MATCHER(complexType); |
| 121 | REGISTER_MATCHER(compoundLiteralExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 122 | REGISTER_MATCHER(compoundStmt); |
| 123 | REGISTER_MATCHER(conditionalOperator); |
| 124 | REGISTER_MATCHER(constCastExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 125 | REGISTER_MATCHER(constantArrayType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 126 | REGISTER_MATCHER(constructExpr); |
| 127 | REGISTER_MATCHER(constructorDecl); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 128 | REGISTER_MATCHER(containsDeclaration); |
| 129 | REGISTER_MATCHER(continueStmt); |
| 130 | REGISTER_MATCHER(decl); |
| 131 | REGISTER_MATCHER(declCountIs); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 132 | REGISTER_MATCHER(declRefExpr); |
| 133 | REGISTER_MATCHER(declStmt); |
| 134 | REGISTER_MATCHER(defaultArgExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 135 | REGISTER_MATCHER(deleteExpr); |
| 136 | REGISTER_MATCHER(dependentSizedArrayType); |
| 137 | REGISTER_MATCHER(destructorDecl); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 138 | REGISTER_MATCHER(doStmt); |
| 139 | REGISTER_MATCHER(dynamicCastExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 140 | REGISTER_MATCHER(elaboratedType); |
| 141 | REGISTER_MATCHER(enumConstantDecl); |
| 142 | REGISTER_MATCHER(enumDecl); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 143 | REGISTER_MATCHER(explicitCastExpr); |
| 144 | REGISTER_MATCHER(expr); |
| 145 | REGISTER_MATCHER(fieldDecl); |
Samuel Benzaquen | 86e4d74 | 2013-07-17 14:28:00 +0000 | [diff] [blame^] | 146 | REGISTER_MATCHER(forField); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 147 | REGISTER_MATCHER(forRangeStmt); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 148 | REGISTER_MATCHER(forStmt); |
| 149 | REGISTER_MATCHER(functionDecl); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 150 | REGISTER_MATCHER(functionTemplateDecl); |
| 151 | REGISTER_MATCHER(functionType); |
| 152 | REGISTER_MATCHER(functionalCastExpr); |
| 153 | REGISTER_MATCHER(gotoStmt); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 154 | REGISTER_MATCHER(hasAnyArgument); |
Samuel Benzaquen | 86e4d74 | 2013-07-17 14:28:00 +0000 | [diff] [blame^] | 155 | REGISTER_MATCHER(hasAnyConstructorInitializer); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 156 | REGISTER_MATCHER(hasAnyParameter); |
| 157 | REGISTER_MATCHER(hasAnySubstatement); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 158 | REGISTER_MATCHER(hasAnyUsingShadowDecl); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 159 | REGISTER_MATCHER(hasArgument); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 160 | REGISTER_MATCHER(hasArgumentOfType); |
| 161 | REGISTER_MATCHER(hasBase); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 162 | REGISTER_MATCHER(hasBody); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 163 | REGISTER_MATCHER(hasCanonicalType); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 164 | REGISTER_MATCHER(hasCondition); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 165 | REGISTER_MATCHER(hasConditionVariableStatement); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 166 | REGISTER_MATCHER(hasDeclContext); |
Samuel Benzaquen | 3f84bb3 | 2013-07-15 19:25:06 +0000 | [diff] [blame] | 167 | REGISTER_MATCHER(hasDeducedType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 168 | REGISTER_MATCHER(hasDestinationType); |
| 169 | REGISTER_MATCHER(hasEitherOperand); |
Samuel Benzaquen | 3f84bb3 | 2013-07-15 19:25:06 +0000 | [diff] [blame] | 170 | REGISTER_MATCHER(hasElementType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 171 | REGISTER_MATCHER(hasFalseExpression); |
| 172 | REGISTER_MATCHER(hasImplicitDestinationType); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 173 | REGISTER_MATCHER(hasIncrement); |
| 174 | REGISTER_MATCHER(hasIndex); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 175 | REGISTER_MATCHER(hasInitializer); |
| 176 | REGISTER_MATCHER(hasLHS); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 177 | REGISTER_MATCHER(hasLocalQualifiers); |
| 178 | REGISTER_MATCHER(hasLoopInit); |
| 179 | REGISTER_MATCHER(hasMethod); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 180 | REGISTER_MATCHER(hasName); |
| 181 | REGISTER_MATCHER(hasObjectExpression); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 182 | REGISTER_MATCHER(hasOperatorName); |
| 183 | REGISTER_MATCHER(hasOverloadedOperatorName); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 184 | REGISTER_MATCHER(hasParameter); |
| 185 | REGISTER_MATCHER(hasQualifier); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 186 | REGISTER_MATCHER(hasRHS); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 187 | REGISTER_MATCHER(hasSingleDecl); |
| 188 | REGISTER_MATCHER(hasSize); |
| 189 | REGISTER_MATCHER(hasSizeExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 190 | REGISTER_MATCHER(hasSourceExpression); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 191 | REGISTER_MATCHER(hasTargetDecl); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 192 | REGISTER_MATCHER(hasTrueExpression); |
| 193 | REGISTER_MATCHER(hasUnaryOperand); |
Samuel Benzaquen | 3f84bb3 | 2013-07-15 19:25:06 +0000 | [diff] [blame] | 194 | REGISTER_MATCHER(hasValueType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 195 | REGISTER_MATCHER(ifStmt); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 196 | REGISTER_MATCHER(ignoringImpCasts); |
| 197 | REGISTER_MATCHER(ignoringParenCasts); |
| 198 | REGISTER_MATCHER(ignoringParenImpCasts); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 199 | REGISTER_MATCHER(implicitCastExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 200 | REGISTER_MATCHER(incompleteArrayType); |
| 201 | REGISTER_MATCHER(initListExpr); |
Samuel Benzaquen | 3f84bb3 | 2013-07-15 19:25:06 +0000 | [diff] [blame] | 202 | REGISTER_MATCHER(innerType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 203 | REGISTER_MATCHER(integerLiteral); |
| 204 | REGISTER_MATCHER(isArrow); |
| 205 | REGISTER_MATCHER(isConstQualified); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 206 | REGISTER_MATCHER(isDefinition); |
| 207 | REGISTER_MATCHER(isExplicitTemplateSpecialization); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 208 | REGISTER_MATCHER(isExternC); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 209 | REGISTER_MATCHER(isImplicit); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 210 | REGISTER_MATCHER(isInteger); |
| 211 | REGISTER_MATCHER(isOverride); |
| 212 | REGISTER_MATCHER(isPrivate); |
| 213 | REGISTER_MATCHER(isProtected); |
| 214 | REGISTER_MATCHER(isPublic); |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 215 | REGISTER_MATCHER(isTemplateInstantiation); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 216 | REGISTER_MATCHER(isVirtual); |
Samuel Benzaquen | 86e4d74 | 2013-07-17 14:28:00 +0000 | [diff] [blame^] | 217 | REGISTER_MATCHER(isWritten); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 218 | REGISTER_MATCHER(lValueReferenceType); |
| 219 | REGISTER_MATCHER(labelStmt); |
| 220 | REGISTER_MATCHER(lambdaExpr); |
| 221 | REGISTER_MATCHER(matchesName); |
| 222 | REGISTER_MATCHER(materializeTemporaryExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 223 | REGISTER_MATCHER(member); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 224 | REGISTER_MATCHER(memberCallExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 225 | REGISTER_MATCHER(memberExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 226 | REGISTER_MATCHER(memberPointerType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 227 | REGISTER_MATCHER(methodDecl); |
| 228 | REGISTER_MATCHER(namedDecl); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 229 | REGISTER_MATCHER(namesType); |
| 230 | REGISTER_MATCHER(namespaceDecl); |
| 231 | REGISTER_MATCHER(nestedNameSpecifier); |
| 232 | REGISTER_MATCHER(nestedNameSpecifierLoc); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 233 | REGISTER_MATCHER(newExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 234 | REGISTER_MATCHER(nullPtrLiteralExpr); |
| 235 | REGISTER_MATCHER(nullStmt); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 236 | REGISTER_MATCHER(ofClass); |
| 237 | REGISTER_MATCHER(on); |
| 238 | REGISTER_MATCHER(onImplicitObjectArgument); |
| 239 | REGISTER_MATCHER(operatorCallExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 240 | REGISTER_MATCHER(parameterCountIs); |
| 241 | REGISTER_MATCHER(parenType); |
Samuel Benzaquen | 3f84bb3 | 2013-07-15 19:25:06 +0000 | [diff] [blame] | 242 | REGISTER_MATCHER(pointee); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 243 | REGISTER_MATCHER(pointerType); |
| 244 | REGISTER_MATCHER(qualType); |
| 245 | REGISTER_MATCHER(rValueReferenceType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 246 | REGISTER_MATCHER(recordDecl); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 247 | REGISTER_MATCHER(recordType); |
| 248 | REGISTER_MATCHER(referenceType); |
| 249 | REGISTER_MATCHER(refersToDeclaration); |
| 250 | REGISTER_MATCHER(refersToType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 251 | REGISTER_MATCHER(reinterpretCastExpr); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 252 | REGISTER_MATCHER(returnStmt); |
| 253 | REGISTER_MATCHER(returns); |
| 254 | REGISTER_MATCHER(sizeOfExpr); |
| 255 | REGISTER_MATCHER(specifiesNamespace); |
| 256 | REGISTER_MATCHER(specifiesType); |
| 257 | REGISTER_MATCHER(specifiesTypeLoc); |
| 258 | REGISTER_MATCHER(statementCountIs); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 259 | REGISTER_MATCHER(staticCastExpr); |
| 260 | REGISTER_MATCHER(stmt); |
| 261 | REGISTER_MATCHER(stringLiteral); |
| 262 | REGISTER_MATCHER(switchCase); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 263 | REGISTER_MATCHER(switchStmt); |
| 264 | REGISTER_MATCHER(templateSpecializationType); |
| 265 | REGISTER_MATCHER(thisExpr); |
| 266 | REGISTER_MATCHER(throughUsingDecl); |
| 267 | REGISTER_MATCHER(throwExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 268 | REGISTER_MATCHER(to); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 269 | REGISTER_MATCHER(tryStmt); |
| 270 | REGISTER_MATCHER(type); |
| 271 | REGISTER_MATCHER(typeLoc); |
| 272 | REGISTER_MATCHER(typedefType); |
| 273 | REGISTER_MATCHER(unaryExprOrTypeTraitExpr); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 274 | REGISTER_MATCHER(unaryOperator); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 275 | REGISTER_MATCHER(userDefinedLiteral); |
| 276 | REGISTER_MATCHER(usingDecl); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 277 | REGISTER_MATCHER(varDecl); |
Samuel Benzaquen | 7a337af | 2013-06-04 15:46:22 +0000 | [diff] [blame] | 278 | REGISTER_MATCHER(variableArrayType); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 279 | REGISTER_MATCHER(whileStmt); |
Samuel Benzaquen | 86e4d74 | 2013-07-17 14:28:00 +0000 | [diff] [blame^] | 280 | REGISTER_MATCHER(withInitializer); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | RegistryMaps::~RegistryMaps() { |
| 284 | for (ConstructorMap::iterator it = Constructors.begin(), |
| 285 | end = Constructors.end(); |
| 286 | it != end; ++it) { |
| 287 | delete it->second; |
| 288 | } |
| 289 | } |
| 290 | |
| 291 | static llvm::ManagedStatic<RegistryMaps> RegistryData; |
| 292 | |
| 293 | } // anonymous namespace |
| 294 | |
| 295 | // static |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 296 | MatcherList Registry::constructMatcher(StringRef MatcherName, |
| 297 | const SourceRange &NameRange, |
| 298 | ArrayRef<ParserValue> Args, |
| 299 | Diagnostics *Error) { |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 300 | ConstructorMap::const_iterator it = |
| 301 | RegistryData->constructors().find(MatcherName); |
| 302 | if (it == RegistryData->constructors().end()) { |
| 303 | Error->pushErrorFrame(NameRange, Error->ET_RegistryNotFound) |
| 304 | << MatcherName; |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 305 | return MatcherList(); |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 306 | } |
| 307 | |
| 308 | return it->second->run(NameRange, Args, Error); |
| 309 | } |
| 310 | |
Samuel Benzaquen | 4f37d92 | 2013-06-03 19:31:08 +0000 | [diff] [blame] | 311 | // static |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 312 | MatcherList Registry::constructBoundMatcher(StringRef MatcherName, |
| 313 | const SourceRange &NameRange, |
| 314 | StringRef BindID, |
| 315 | ArrayRef<ParserValue> Args, |
| 316 | Diagnostics *Error) { |
| 317 | MatcherList Out = constructMatcher(MatcherName, NameRange, Args, Error); |
| 318 | if (Out.empty()) return Out; |
| 319 | |
| 320 | ArrayRef<const DynTypedMatcher*> Matchers = Out.matchers(); |
| 321 | if (Matchers.size() == 1) { |
| 322 | OwningPtr<DynTypedMatcher> Bound(Matchers[0]->tryBind(BindID)); |
| 323 | if (Bound) { |
| 324 | return *Bound; |
| 325 | } |
Samuel Benzaquen | 4f37d92 | 2013-06-03 19:31:08 +0000 | [diff] [blame] | 326 | } |
Samuel Benzaquen | ef7eb02 | 2013-06-21 15:51:31 +0000 | [diff] [blame] | 327 | Error->pushErrorFrame(NameRange, Error->ET_RegistryNotBindable); |
| 328 | return MatcherList(); |
Samuel Benzaquen | 4f37d92 | 2013-06-03 19:31:08 +0000 | [diff] [blame] | 329 | } |
| 330 | |
Manuel Klimek | f7f295f | 2013-05-14 09:13:00 +0000 | [diff] [blame] | 331 | } // namespace dynamic |
| 332 | } // namespace ast_matchers |
| 333 | } // namespace clang |